Subversion Repositories SmartDukaan

Rev

Rev 7080 | Rev 7096 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
527 
    Returns the final flag status.
528 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
7075 rajveer 1475 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1476 
    """
1477 
    Parameters:
1478 
     - orderId
7075 rajveer 1479 
     - userId
6988 rajveer 1480 
    """
1481 
    pass
6985 anupam.sin 1482 
 
7026 rajveer 1483 
  def receiveUpdatesForRedExpress(self, awbNumber):
1484 
    """
1485 
    Parameters:
1486 
     - awbNumber
1487 
    """
1488 
    pass
6988 rajveer 1489 
 
7073 anupam.sin 1490 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1491 
    """
1492 
    Parameters:
1493 
     - thriftRechargeTransaction
1494 
    """
1495 
    pass
7026 rajveer 1496 
 
7085 rajveer 1497 
  def getRechargeTransactions(self, storeId):
1498 
    """
1499 
    Parameters:
1500 
     - storeId
1501 
    """
1502 
    pass
1503 
 
7080 anupam.sin 1504 
  def getRechargeTransaction(self, rechargeId):
1505 
    """
1506 
    Parameters:
1507 
     - rechargeId
1508 
    """
1509 
    pass
7073 anupam.sin 1510 
 
7080 anupam.sin 1511 
  def getFRCs(self, circleId, operatorId):
1512 
    """
1513 
    Parameters:
1514 
     - circleId
1515 
     - operatorId
1516 
    """
1517 
    pass
1518 
 
1519 
 
3376 rajveer 1520 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1521 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1522 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1523 
 
1524 
  def createTransaction(self, transaction):
1525 
    """
1526 
    Parameters:
1527 
     - transaction
1528 
    """
1529 
    self.send_createTransaction(transaction)
132 ashish 1530 
    return self.recv_createTransaction()
94 ashish 1531 
 
1532 
  def send_createTransaction(self, transaction):
1533 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1534 
    args = createTransaction_args()
1535 
    args.transaction = transaction
1536 
    args.write(self._oprot)
1537 
    self._oprot.writeMessageEnd()
1538 
    self._oprot.trans.flush()
1539 
 
1540 
  def recv_createTransaction(self, ):
1541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1542 
    if mtype == TMessageType.EXCEPTION:
1543 
      x = TApplicationException()
1544 
      x.read(self._iprot)
1545 
      self._iprot.readMessageEnd()
1546 
      raise x
1547 
    result = createTransaction_result()
1548 
    result.read(self._iprot)
1549 
    self._iprot.readMessageEnd()
3431 rajveer 1550 
    if result.success is not None:
132 ashish 1551 
      return result.success
3431 rajveer 1552 
    if result.ex is not None:
94 ashish 1553 
      raise result.ex
132 ashish 1554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1555 
 
1556 
  def getTransaction(self, id):
1557 
    """
1558 
    Parameters:
1559 
     - id
1560 
    """
1561 
    self.send_getTransaction(id)
1562 
    return self.recv_getTransaction()
1563 
 
1564 
  def send_getTransaction(self, id):
1565 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1566 
    args = getTransaction_args()
1567 
    args.id = id
1568 
    args.write(self._oprot)
1569 
    self._oprot.writeMessageEnd()
1570 
    self._oprot.trans.flush()
1571 
 
1572 
  def recv_getTransaction(self, ):
1573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1574 
    if mtype == TMessageType.EXCEPTION:
1575 
      x = TApplicationException()
1576 
      x.read(self._iprot)
1577 
      self._iprot.readMessageEnd()
1578 
      raise x
1579 
    result = getTransaction_result()
1580 
    result.read(self._iprot)
1581 
    self._iprot.readMessageEnd()
3431 rajveer 1582 
    if result.success is not None:
94 ashish 1583 
      return result.success
3431 rajveer 1584 
    if result.ex is not None:
94 ashish 1585 
      raise result.ex
1586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1587 
 
1588 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1589 
    """
1590 
    Parameters:
1591 
     - customerId
1592 
     - from_date
1593 
     - to_date
1594 
     - status
1595 
    """
1596 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1597 
    return self.recv_getTransactionsForCustomer()
1598 
 
1599 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1600 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1601 
    args = getTransactionsForCustomer_args()
1602 
    args.customerId = customerId
1603 
    args.from_date = from_date
1604 
    args.to_date = to_date
1605 
    args.status = status
1606 
    args.write(self._oprot)
1607 
    self._oprot.writeMessageEnd()
1608 
    self._oprot.trans.flush()
1609 
 
1610 
  def recv_getTransactionsForCustomer(self, ):
1611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1612 
    if mtype == TMessageType.EXCEPTION:
1613 
      x = TApplicationException()
1614 
      x.read(self._iprot)
1615 
      self._iprot.readMessageEnd()
1616 
      raise x
1617 
    result = getTransactionsForCustomer_result()
1618 
    result.read(self._iprot)
1619 
    self._iprot.readMessageEnd()
3431 rajveer 1620 
    if result.success is not None:
94 ashish 1621 
      return result.success
3431 rajveer 1622 
    if result.ex is not None:
94 ashish 1623 
      raise result.ex
1624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1625 
 
132 ashish 1626 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1627 
    """
1628 
    Parameters:
1629 
     - shoppingCartId
1630 
    """
1631 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1632 
    return self.recv_getTransactionsForShoppingCartId()
1633 
 
1634 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1635 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1636 
    args = getTransactionsForShoppingCartId_args()
1637 
    args.shoppingCartId = shoppingCartId
1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_getTransactionsForShoppingCartId(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = getTransactionsForShoppingCartId_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
132 ashish 1653 
      return result.success
3431 rajveer 1654 
    if result.ex is not None:
132 ashish 1655 
      raise result.ex
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1657 
 
94 ashish 1658 
  def getTransactionStatus(self, transactionId):
1659 
    """
1660 
    Parameters:
1661 
     - transactionId
1662 
    """
1663 
    self.send_getTransactionStatus(transactionId)
1664 
    return self.recv_getTransactionStatus()
1665 
 
1666 
  def send_getTransactionStatus(self, transactionId):
1667 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1668 
    args = getTransactionStatus_args()
1669 
    args.transactionId = transactionId
1670 
    args.write(self._oprot)
1671 
    self._oprot.writeMessageEnd()
1672 
    self._oprot.trans.flush()
1673 
 
1674 
  def recv_getTransactionStatus(self, ):
1675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1676 
    if mtype == TMessageType.EXCEPTION:
1677 
      x = TApplicationException()
1678 
      x.read(self._iprot)
1679 
      self._iprot.readMessageEnd()
1680 
      raise x
1681 
    result = getTransactionStatus_result()
1682 
    result.read(self._iprot)
1683 
    self._iprot.readMessageEnd()
3431 rajveer 1684 
    if result.success is not None:
94 ashish 1685 
      return result.success
3431 rajveer 1686 
    if result.ex is not None:
94 ashish 1687 
      raise result.ex
1688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1689 
 
5527 anupam.sin 1690 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1691 
    """
1692 
    Parameters:
1693 
     - transactionId
1694 
     - status
1695 
     - description
5527 anupam.sin 1696 
     - pickUp
1697 
     - orderType
94 ashish 1698 
    """
5527 anupam.sin 1699 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1700 
    return self.recv_changeTransactionStatus()
1701 
 
5527 anupam.sin 1702 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1703 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1704 
    args = changeTransactionStatus_args()
1705 
    args.transactionId = transactionId
1706 
    args.status = status
1707 
    args.description = description
5527 anupam.sin 1708 
    args.pickUp = pickUp
1709 
    args.orderType = orderType
94 ashish 1710 
    args.write(self._oprot)
1711 
    self._oprot.writeMessageEnd()
1712 
    self._oprot.trans.flush()
1713 
 
1714 
  def recv_changeTransactionStatus(self, ):
1715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1716 
    if mtype == TMessageType.EXCEPTION:
1717 
      x = TApplicationException()
1718 
      x.read(self._iprot)
1719 
      self._iprot.readMessageEnd()
1720 
      raise x
1721 
    result = changeTransactionStatus_result()
1722 
    result.read(self._iprot)
1723 
    self._iprot.readMessageEnd()
3431 rajveer 1724 
    if result.success is not None:
94 ashish 1725 
      return result.success
3431 rajveer 1726 
    if result.ex is not None:
94 ashish 1727 
      raise result.ex
1728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1729 
 
1398 varun.gupt 1730 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1731 
    """
1732 
    Parameters:
1733 
     - transactionId
1734 
    """
1398 varun.gupt 1735 
    self.send_enqueueTransactionInfoEmail(transactionId)
1736 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1737 
 
1398 varun.gupt 1738 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1739 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1740 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1741 
    args.transactionId = transactionId
1742 
    args.write(self._oprot)
1743 
    self._oprot.writeMessageEnd()
1744 
    self._oprot.trans.flush()
1745 
 
1398 varun.gupt 1746 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1748 
    if mtype == TMessageType.EXCEPTION:
1749 
      x = TApplicationException()
1750 
      x.read(self._iprot)
1751 
      self._iprot.readMessageEnd()
1752 
      raise x
1398 varun.gupt 1753 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1754 
    result.read(self._iprot)
1755 
    self._iprot.readMessageEnd()
3431 rajveer 1756 
    if result.success is not None:
1382 varun.gupt 1757 
      return result.success
3431 rajveer 1758 
    if result.ex is not None:
1382 varun.gupt 1759 
      raise result.ex
1398 varun.gupt 1760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1761 
 
4801 anupam.sin 1762 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1763 
    """
1764 
    Parameters:
4801 anupam.sin 1765 
     - statuses
483 rajveer 1766 
     - from_date
1767 
     - to_date
1768 
     - warehouse_id
94 ashish 1769 
    """
4801 anupam.sin 1770 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1771 
    return self.recv_getAllOrders()
94 ashish 1772 
 
4801 anupam.sin 1773 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1774 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1775 
    args = getAllOrders_args()
4801 anupam.sin 1776 
    args.statuses = statuses
483 rajveer 1777 
    args.from_date = from_date
1778 
    args.to_date = to_date
1779 
    args.warehouse_id = warehouse_id
94 ashish 1780 
    args.write(self._oprot)
1781 
    self._oprot.writeMessageEnd()
1782 
    self._oprot.trans.flush()
1783 
 
483 rajveer 1784 
  def recv_getAllOrders(self, ):
94 ashish 1785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1786 
    if mtype == TMessageType.EXCEPTION:
1787 
      x = TApplicationException()
1788 
      x.read(self._iprot)
1789 
      self._iprot.readMessageEnd()
1790 
      raise x
483 rajveer 1791 
    result = getAllOrders_result()
94 ashish 1792 
    result.read(self._iprot)
1793 
    self._iprot.readMessageEnd()
3431 rajveer 1794 
    if result.success is not None:
94 ashish 1795 
      return result.success
3431 rajveer 1796 
    if result.ex is not None:
94 ashish 1797 
      raise result.ex
483 rajveer 1798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1799 
 
4133 chandransh 1800 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1801 
    """
1802 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1803 
    Pass the status as null and the limit as 0 to ignore them.
1804 
 
1805 
    Parameters:
1806 
     - statuses
1807 
     - offset
1808 
     - limit
1809 
     - warehouse_id
1810 
    """
1811 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1812 
    return self.recv_getOrdersInBatch()
1813 
 
1814 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1815 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1816 
    args = getOrdersInBatch_args()
1817 
    args.statuses = statuses
1818 
    args.offset = offset
1819 
    args.limit = limit
1820 
    args.warehouse_id = warehouse_id
1821 
    args.write(self._oprot)
1822 
    self._oprot.writeMessageEnd()
1823 
    self._oprot.trans.flush()
1824 
 
1825 
  def recv_getOrdersInBatch(self, ):
1826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1827 
    if mtype == TMessageType.EXCEPTION:
1828 
      x = TApplicationException()
1829 
      x.read(self._iprot)
1830 
      self._iprot.readMessageEnd()
1831 
      raise x
1832 
    result = getOrdersInBatch_result()
1833 
    result.read(self._iprot)
1834 
    self._iprot.readMessageEnd()
1835 
    if result.success is not None:
1836 
      return result.success
1837 
    if result.ex is not None:
1838 
      raise result.ex
1839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1840 
 
1841 
  def getOrderCount(self, statuses, warehouseId):
1842 
    """
1843 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1844 
 
1845 
    Parameters:
1846 
     - statuses
1847 
     - warehouseId
1848 
    """
1849 
    self.send_getOrderCount(statuses, warehouseId)
1850 
    return self.recv_getOrderCount()
1851 
 
1852 
  def send_getOrderCount(self, statuses, warehouseId):
1853 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1854 
    args = getOrderCount_args()
1855 
    args.statuses = statuses
1856 
    args.warehouseId = warehouseId
1857 
    args.write(self._oprot)
1858 
    self._oprot.writeMessageEnd()
1859 
    self._oprot.trans.flush()
1860 
 
1861 
  def recv_getOrderCount(self, ):
1862 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1863 
    if mtype == TMessageType.EXCEPTION:
1864 
      x = TApplicationException()
1865 
      x.read(self._iprot)
1866 
      self._iprot.readMessageEnd()
1867 
      raise x
1868 
    result = getOrderCount_result()
1869 
    result.read(self._iprot)
1870 
    self._iprot.readMessageEnd()
1871 
    if result.success is not None:
1872 
      return result.success
1873 
    if result.ex is not None:
1874 
      raise result.ex
1875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1876 
 
999 varun.gupt 1877 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1878 
    """
1132 chandransh 1879 
    Returns orders within a range of their billing dates
3431 rajveer 1880 
 
999 varun.gupt 1881 
    Parameters:
1882 
     - status
1883 
     - start_billing_date
1884 
     - end_billing_date
1885 
     - warehouse_id
1886 
    """
1887 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1888 
    return self.recv_getOrdersByBillingDate()
1889 
 
1890 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1891 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1892 
    args = getOrdersByBillingDate_args()
1893 
    args.status = status
1894 
    args.start_billing_date = start_billing_date
1895 
    args.end_billing_date = end_billing_date
1896 
    args.warehouse_id = warehouse_id
1897 
    args.write(self._oprot)
1898 
    self._oprot.writeMessageEnd()
1899 
    self._oprot.trans.flush()
1900 
 
1901 
  def recv_getOrdersByBillingDate(self, ):
1902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1903 
    if mtype == TMessageType.EXCEPTION:
1904 
      x = TApplicationException()
1905 
      x.read(self._iprot)
1906 
      self._iprot.readMessageEnd()
1907 
      raise x
1908 
    result = getOrdersByBillingDate_result()
1909 
    result.read(self._iprot)
1910 
    self._iprot.readMessageEnd()
3431 rajveer 1911 
    if result.success is not None:
999 varun.gupt 1912 
      return result.success
3431 rajveer 1913 
    if result.ex is not None:
999 varun.gupt 1914 
      raise result.ex
1915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1916 
 
3451 chandransh 1917 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1918 
    """
1919 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1920 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1921 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1922 
 
3427 chandransh 1923 
    Parameters:
1924 
     - fromShippingDate
1925 
     - toShippingDate
1926 
     - providerId
1927 
     - warehouseId
3451 chandransh 1928 
     - cod
3427 chandransh 1929 
    """
3451 chandransh 1930 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1931 
    return self.recv_getOrdersByShippingDate()
1932 
 
3451 chandransh 1933 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1934 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1935 
    args = getOrdersByShippingDate_args()
1936 
    args.fromShippingDate = fromShippingDate
1937 
    args.toShippingDate = toShippingDate
1938 
    args.providerId = providerId
1939 
    args.warehouseId = warehouseId
3451 chandransh 1940 
    args.cod = cod
3427 chandransh 1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
1945 
  def recv_getOrdersByShippingDate(self, ):
1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
1952 
    result = getOrdersByShippingDate_result()
1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
3431 rajveer 1955 
    if result.success is not None:
3427 chandransh 1956 
      return result.success
3431 rajveer 1957 
    if result.ex is not None:
3427 chandransh 1958 
      raise result.ex
1959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1960 
 
1382 varun.gupt 1961 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1962 
    """
1963 
    Returns order ids for orders which can be returned
3431 rajveer 1964 
 
1382 varun.gupt 1965 
    Parameters:
1966 
     - customer_id
1967 
     - limit
1968 
    """
1969 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1970 
    return self.recv_getReturnableOrdersForCustomer()
1971 
 
1972 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1973 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1974 
    args = getReturnableOrdersForCustomer_args()
1975 
    args.customer_id = customer_id
1976 
    args.limit = limit
1977 
    args.write(self._oprot)
1978 
    self._oprot.writeMessageEnd()
1979 
    self._oprot.trans.flush()
1980 
 
1981 
  def recv_getReturnableOrdersForCustomer(self, ):
1982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1983 
    if mtype == TMessageType.EXCEPTION:
1984 
      x = TApplicationException()
1985 
      x.read(self._iprot)
1986 
      self._iprot.readMessageEnd()
1987 
      raise x
1988 
    result = getReturnableOrdersForCustomer_result()
1989 
    result.read(self._iprot)
1990 
    self._iprot.readMessageEnd()
3431 rajveer 1991 
    if result.success is not None:
1382 varun.gupt 1992 
      return result.success
3431 rajveer 1993 
    if result.ex is not None:
1382 varun.gupt 1994 
      raise result.ex
1995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1996 
 
1997 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1998 
    """
1999 
    Returns order ids for orders which can be cancelled
3431 rajveer 2000 
 
1382 varun.gupt 2001 
    Parameters:
2002 
     - customer_id
2003 
     - limit
2004 
    """
2005 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2006 
    return self.recv_getCancellableOrdersForCustomer()
2007 
 
2008 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2009 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2010 
    args = getCancellableOrdersForCustomer_args()
2011 
    args.customer_id = customer_id
2012 
    args.limit = limit
2013 
    args.write(self._oprot)
2014 
    self._oprot.writeMessageEnd()
2015 
    self._oprot.trans.flush()
2016 
 
2017 
  def recv_getCancellableOrdersForCustomer(self, ):
2018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2019 
    if mtype == TMessageType.EXCEPTION:
2020 
      x = TApplicationException()
2021 
      x.read(self._iprot)
2022 
      self._iprot.readMessageEnd()
2023 
      raise x
2024 
    result = getCancellableOrdersForCustomer_result()
2025 
    result.read(self._iprot)
2026 
    self._iprot.readMessageEnd()
3431 rajveer 2027 
    if result.success is not None:
1382 varun.gupt 2028 
      return result.success
3431 rajveer 2029 
    if result.ex is not None:
1382 varun.gupt 2030 
      raise result.ex
2031 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2032 
 
483 rajveer 2033 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2034 
    """
2035 
    Parameters:
483 rajveer 2036 
     - orderId
2037 
     - status
2038 
     - description
94 ashish 2039 
    """
483 rajveer 2040 
    self.send_changeOrderStatus(orderId, status, description)
2041 
    return self.recv_changeOrderStatus()
94 ashish 2042 
 
483 rajveer 2043 
  def send_changeOrderStatus(self, orderId, status, description):
2044 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2045 
    args = changeOrderStatus_args()
2046 
    args.orderId = orderId
2047 
    args.status = status
2048 
    args.description = description
94 ashish 2049 
    args.write(self._oprot)
2050 
    self._oprot.writeMessageEnd()
2051 
    self._oprot.trans.flush()
2052 
 
483 rajveer 2053 
  def recv_changeOrderStatus(self, ):
94 ashish 2054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2055 
    if mtype == TMessageType.EXCEPTION:
2056 
      x = TApplicationException()
2057 
      x.read(self._iprot)
2058 
      self._iprot.readMessageEnd()
2059 
      raise x
483 rajveer 2060 
    result = changeOrderStatus_result()
94 ashish 2061 
    result.read(self._iprot)
2062 
    self._iprot.readMessageEnd()
3431 rajveer 2063 
    if result.success is not None:
94 ashish 2064 
      return result.success
3431 rajveer 2065 
    if result.ex is not None:
94 ashish 2066 
      raise result.ex
483 rajveer 2067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2068 
 
1528 ankur.sing 2069 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2070 
    """
1528 ankur.sing 2071 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2072 
    only user who owns the transaction can view its order details.
3431 rajveer 2073 
 
94 ashish 2074 
    Parameters:
2075 
     - transactionId
1528 ankur.sing 2076 
     - customerId
94 ashish 2077 
    """
1528 ankur.sing 2078 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2079 
    return self.recv_getOrdersForTransaction()
94 ashish 2080 
 
1528 ankur.sing 2081 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2082 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2083 
    args = getOrdersForTransaction_args()
94 ashish 2084 
    args.transactionId = transactionId
1528 ankur.sing 2085 
    args.customerId = customerId
94 ashish 2086 
    args.write(self._oprot)
2087 
    self._oprot.writeMessageEnd()
2088 
    self._oprot.trans.flush()
2089 
 
483 rajveer 2090 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2092 
    if mtype == TMessageType.EXCEPTION:
2093 
      x = TApplicationException()
2094 
      x.read(self._iprot)
2095 
      self._iprot.readMessageEnd()
2096 
      raise x
483 rajveer 2097 
    result = getOrdersForTransaction_result()
94 ashish 2098 
    result.read(self._iprot)
2099 
    self._iprot.readMessageEnd()
3431 rajveer 2100 
    if result.success is not None:
94 ashish 2101 
      return result.success
3431 rajveer 2102 
    if result.ex is not None:
94 ashish 2103 
      raise result.ex
483 rajveer 2104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2105 
 
3014 chandransh 2106 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2107 
    """
3014 chandransh 2108 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2109 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2110 
 
94 ashish 2111 
    Parameters:
483 rajveer 2112 
     - customerId
2113 
     - from_date
2114 
     - to_date
3014 chandransh 2115 
     - statuses
94 ashish 2116 
    """
3014 chandransh 2117 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2118 
    return self.recv_getOrdersForCustomer()
94 ashish 2119 
 
3014 chandransh 2120 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2121 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2122 
    args = getOrdersForCustomer_args()
2123 
    args.customerId = customerId
2124 
    args.from_date = from_date
2125 
    args.to_date = to_date
3014 chandransh 2126 
    args.statuses = statuses
94 ashish 2127 
    args.write(self._oprot)
2128 
    self._oprot.writeMessageEnd()
2129 
    self._oprot.trans.flush()
2130 
 
483 rajveer 2131 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2133 
    if mtype == TMessageType.EXCEPTION:
2134 
      x = TApplicationException()
2135 
      x.read(self._iprot)
2136 
      self._iprot.readMessageEnd()
2137 
      raise x
483 rajveer 2138 
    result = getOrdersForCustomer_result()
94 ashish 2139 
    result.read(self._iprot)
2140 
    self._iprot.readMessageEnd()
3431 rajveer 2141 
    if result.success is not None:
94 ashish 2142 
      return result.success
3431 rajveer 2143 
    if result.ex is not None:
94 ashish 2144 
      raise result.ex
483 rajveer 2145 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2146 
 
483 rajveer 2147 
  def createOrder(self, order):
94 ashish 2148 
    """
2149 
    Parameters:
483 rajveer 2150 
     - order
94 ashish 2151 
    """
483 rajveer 2152 
    self.send_createOrder(order)
2153 
    return self.recv_createOrder()
94 ashish 2154 
 
483 rajveer 2155 
  def send_createOrder(self, order):
2156 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2157 
    args = createOrder_args()
2158 
    args.order = order
94 ashish 2159 
    args.write(self._oprot)
2160 
    self._oprot.writeMessageEnd()
2161 
    self._oprot.trans.flush()
2162 
 
483 rajveer 2163 
  def recv_createOrder(self, ):
94 ashish 2164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2165 
    if mtype == TMessageType.EXCEPTION:
2166 
      x = TApplicationException()
2167 
      x.read(self._iprot)
2168 
      self._iprot.readMessageEnd()
2169 
      raise x
483 rajveer 2170 
    result = createOrder_result()
94 ashish 2171 
    result.read(self._iprot)
2172 
    self._iprot.readMessageEnd()
3431 rajveer 2173 
    if result.success is not None:
94 ashish 2174 
      return result.success
3431 rajveer 2175 
    if result.ex is not None:
94 ashish 2176 
      raise result.ex
483 rajveer 2177 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2178 
 
483 rajveer 2179 
  def getOrder(self, id):
94 ashish 2180 
    """
2181 
    Parameters:
483 rajveer 2182 
     - id
94 ashish 2183 
    """
483 rajveer 2184 
    self.send_getOrder(id)
2185 
    return self.recv_getOrder()
94 ashish 2186 
 
483 rajveer 2187 
  def send_getOrder(self, id):
2188 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2189 
    args = getOrder_args()
2190 
    args.id = id
94 ashish 2191 
    args.write(self._oprot)
2192 
    self._oprot.writeMessageEnd()
2193 
    self._oprot.trans.flush()
2194 
 
483 rajveer 2195 
  def recv_getOrder(self, ):
94 ashish 2196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2197 
    if mtype == TMessageType.EXCEPTION:
2198 
      x = TApplicationException()
2199 
      x.read(self._iprot)
2200 
      self._iprot.readMessageEnd()
2201 
      raise x
483 rajveer 2202 
    result = getOrder_result()
94 ashish 2203 
    result.read(self._iprot)
2204 
    self._iprot.readMessageEnd()
3431 rajveer 2205 
    if result.success is not None:
94 ashish 2206 
      return result.success
3431 rajveer 2207 
    if result.ex is not None:
94 ashish 2208 
      raise result.ex
483 rajveer 2209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2210 
 
483 rajveer 2211 
  def getLineItemsForOrder(self, orderId):
94 ashish 2212 
    """
2213 
    Parameters:
483 rajveer 2214 
     - orderId
94 ashish 2215 
    """
483 rajveer 2216 
    self.send_getLineItemsForOrder(orderId)
2217 
    return self.recv_getLineItemsForOrder()
94 ashish 2218 
 
483 rajveer 2219 
  def send_getLineItemsForOrder(self, orderId):
2220 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2221 
    args = getLineItemsForOrder_args()
2222 
    args.orderId = orderId
94 ashish 2223 
    args.write(self._oprot)
2224 
    self._oprot.writeMessageEnd()
2225 
    self._oprot.trans.flush()
2226 
 
483 rajveer 2227 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2229 
    if mtype == TMessageType.EXCEPTION:
2230 
      x = TApplicationException()
2231 
      x.read(self._iprot)
2232 
      self._iprot.readMessageEnd()
2233 
      raise x
483 rajveer 2234 
    result = getLineItemsForOrder_result()
94 ashish 2235 
    result.read(self._iprot)
2236 
    self._iprot.readMessageEnd()
3431 rajveer 2237 
    if result.success is not None:
94 ashish 2238 
      return result.success
3431 rajveer 2239 
    if result.ex is not None:
94 ashish 2240 
      raise result.ex
483 rajveer 2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2242 
 
4999 phani.kuma 2243 
  def getOrderList(self, order_ids):
2244 
    """
2245 
    Parameters:
2246 
     - order_ids
2247 
    """
2248 
    self.send_getOrderList(order_ids)
2249 
    return self.recv_getOrderList()
2250 
 
2251 
  def send_getOrderList(self, order_ids):
2252 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2253 
    args = getOrderList_args()
2254 
    args.order_ids = order_ids
2255 
    args.write(self._oprot)
2256 
    self._oprot.writeMessageEnd()
2257 
    self._oprot.trans.flush()
2258 
 
2259 
  def recv_getOrderList(self, ):
2260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2261 
    if mtype == TMessageType.EXCEPTION:
2262 
      x = TApplicationException()
2263 
      x.read(self._iprot)
2264 
      self._iprot.readMessageEnd()
2265 
      raise x
2266 
    result = getOrderList_result()
2267 
    result.read(self._iprot)
2268 
    self._iprot.readMessageEnd()
2269 
    if result.success is not None:
2270 
      return result.success
2271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2272 
 
5386 phani.kuma 2273 
  def getOrderListForVendor(self, order_ids, vendorId):
2274 
    """
2275 
    Parameters:
2276 
     - order_ids
2277 
     - vendorId
2278 
    """
2279 
    self.send_getOrderListForVendor(order_ids, vendorId)
2280 
    return self.recv_getOrderListForVendor()
2281 
 
2282 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2283 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2284 
    args = getOrderListForVendor_args()
2285 
    args.order_ids = order_ids
2286 
    args.vendorId = vendorId
2287 
    args.write(self._oprot)
2288 
    self._oprot.writeMessageEnd()
2289 
    self._oprot.trans.flush()
2290 
 
2291 
  def recv_getOrderListForVendor(self, ):
2292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2293 
    if mtype == TMessageType.EXCEPTION:
2294 
      x = TApplicationException()
2295 
      x.read(self._iprot)
2296 
      self._iprot.readMessageEnd()
2297 
      raise x
2298 
    result = getOrderListForVendor_result()
2299 
    result.read(self._iprot)
2300 
    self._iprot.readMessageEnd()
2301 
    if result.success is not None:
2302 
      return result.success
2303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2304 
 
1528 ankur.sing 2305 
  def getOrderForCustomer(self, orderId, customerId):
2306 
    """
2307 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2308 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2309 
 
1528 ankur.sing 2310 
    Parameters:
2311 
     - orderId
2312 
     - customerId
2313 
    """
2314 
    self.send_getOrderForCustomer(orderId, customerId)
2315 
    return self.recv_getOrderForCustomer()
2316 
 
2317 
  def send_getOrderForCustomer(self, orderId, customerId):
2318 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2319 
    args = getOrderForCustomer_args()
2320 
    args.orderId = orderId
2321 
    args.customerId = customerId
2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
2326 
  def recv_getOrderForCustomer(self, ):
2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
2333 
    result = getOrderForCustomer_result()
2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
3431 rajveer 2336 
    if result.success is not None:
1528 ankur.sing 2337 
      return result.success
3431 rajveer 2338 
    if result.ex is not None:
1528 ankur.sing 2339 
      raise result.ex
2340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2341 
 
4444 rajveer 2342 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2343 
    """
2344 
    Parameters:
4394 rajveer 2345 
     - type
4444 rajveer 2346 
     - warehouseId
4394 rajveer 2347 
     - status
2348 
     - timestamp
3064 chandransh 2349 
    """
4444 rajveer 2350 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2351 
    return self.recv_getAlerts()
2352 
 
4444 rajveer 2353 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2354 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2355 
    args = getAlerts_args()
4394 rajveer 2356 
    args.type = type
4444 rajveer 2357 
    args.warehouseId = warehouseId
4394 rajveer 2358 
    args.status = status
2359 
    args.timestamp = timestamp
3064 chandransh 2360 
    args.write(self._oprot)
2361 
    self._oprot.writeMessageEnd()
2362 
    self._oprot.trans.flush()
2363 
 
2364 
  def recv_getAlerts(self, ):
2365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2366 
    if mtype == TMessageType.EXCEPTION:
2367 
      x = TApplicationException()
2368 
      x.read(self._iprot)
2369 
      self._iprot.readMessageEnd()
2370 
      raise x
2371 
    result = getAlerts_result()
2372 
    result.read(self._iprot)
2373 
    self._iprot.readMessageEnd()
3431 rajveer 2374 
    if result.success is not None:
3064 chandransh 2375 
      return result.success
2376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2377 
 
4444 rajveer 2378 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2379 
    """
2380 
    Parameters:
2381 
     - type
4444 rajveer 2382 
     - warehouseId
4394 rajveer 2383 
     - description
3064 chandransh 2384 
    """
4444 rajveer 2385 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2386 
    self.recv_addAlert()
3064 chandransh 2387 
 
4444 rajveer 2388 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2389 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2390 
    args = addAlert_args()
3064 chandransh 2391 
    args.type = type
4444 rajveer 2392 
    args.warehouseId = warehouseId
4394 rajveer 2393 
    args.description = description
3064 chandransh 2394 
    args.write(self._oprot)
2395 
    self._oprot.writeMessageEnd()
2396 
    self._oprot.trans.flush()
2397 
 
4394 rajveer 2398 
  def recv_addAlert(self, ):
3064 chandransh 2399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2400 
    if mtype == TMessageType.EXCEPTION:
2401 
      x = TApplicationException()
2402 
      x.read(self._iprot)
2403 
      self._iprot.readMessageEnd()
2404 
      raise x
4394 rajveer 2405 
    result = addAlert_result()
3064 chandransh 2406 
    result.read(self._iprot)
2407 
    self._iprot.readMessageEnd()
2408 
    return
2409 
 
4444 rajveer 2410 
  def markAlertsAsSeen(self, warehouseId):
2411 
    """
2412 
    Parameters:
2413 
     - warehouseId
2414 
    """
2415 
    self.send_markAlertsAsSeen(warehouseId)
2416 
    self.recv_markAlertsAsSeen()
2417 
 
2418 
  def send_markAlertsAsSeen(self, warehouseId):
2419 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2420 
    args = markAlertsAsSeen_args()
2421 
    args.warehouseId = warehouseId
2422 
    args.write(self._oprot)
2423 
    self._oprot.writeMessageEnd()
2424 
    self._oprot.trans.flush()
2425 
 
2426 
  def recv_markAlertsAsSeen(self, ):
2427 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2428 
    if mtype == TMessageType.EXCEPTION:
2429 
      x = TApplicationException()
2430 
      x.read(self._iprot)
2431 
      self._iprot.readMessageEnd()
2432 
      raise x
2433 
    result = markAlertsAsSeen_result()
2434 
    result.read(self._iprot)
2435 
    self._iprot.readMessageEnd()
2436 
    return
2437 
 
3064 chandransh 2438 
  def getValidOrderCount(self, ):
2439 
    """
2440 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2441 
    """
2442 
    self.send_getValidOrderCount()
2443 
    return self.recv_getValidOrderCount()
2444 
 
2445 
  def send_getValidOrderCount(self, ):
2446 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2447 
    args = getValidOrderCount_args()
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_getValidOrderCount(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = getValidOrderCount_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.success is not None:
3064 chandransh 2463 
      return result.success
2464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2465 
 
2466 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2467 
    """
2468 
    Returns the number of distinct customers who have done successful transactions
2469 
    """
2470 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2471 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2472 
 
2473 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2474 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2475 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2476 
    args.write(self._oprot)
2477 
    self._oprot.writeMessageEnd()
2478 
    self._oprot.trans.flush()
2479 
 
2480 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2482 
    if mtype == TMessageType.EXCEPTION:
2483 
      x = TApplicationException()
2484 
      x.read(self._iprot)
2485 
      self._iprot.readMessageEnd()
2486 
      raise x
2487 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2488 
    result.read(self._iprot)
2489 
    self._iprot.readMessageEnd()
3431 rajveer 2490 
    if result.success is not None:
3064 chandransh 2491 
      return result.success
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2493 
 
2494 
  def getValidOrdersAmountRange(self, ):
2495 
    """
2496 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2497 
    List contains two values, first minimum amount and second maximum amount.
2498 
    """
2499 
    self.send_getValidOrdersAmountRange()
2500 
    return self.recv_getValidOrdersAmountRange()
2501 
 
2502 
  def send_getValidOrdersAmountRange(self, ):
2503 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2504 
    args = getValidOrdersAmountRange_args()
2505 
    args.write(self._oprot)
2506 
    self._oprot.writeMessageEnd()
2507 
    self._oprot.trans.flush()
2508 
 
2509 
  def recv_getValidOrdersAmountRange(self, ):
2510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2511 
    if mtype == TMessageType.EXCEPTION:
2512 
      x = TApplicationException()
2513 
      x.read(self._iprot)
2514 
      self._iprot.readMessageEnd()
2515 
      raise x
2516 
    result = getValidOrdersAmountRange_result()
2517 
    result.read(self._iprot)
2518 
    self._iprot.readMessageEnd()
3431 rajveer 2519 
    if result.success is not None:
3064 chandransh 2520 
      return result.success
2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2522 
 
5874 rajveer 2523 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2524 
    """
2525 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2526 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2527 
 
3064 chandransh 2528 
    Parameters:
2529 
     - limit
5874 rajveer 2530 
     - onlyStore
3064 chandransh 2531 
    """
5874 rajveer 2532 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2533 
    return self.recv_getValidOrders()
2534 
 
5874 rajveer 2535 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2536 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2537 
    args = getValidOrders_args()
2538 
    args.limit = limit
5874 rajveer 2539 
    args.onlyStore = onlyStore
3064 chandransh 2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
2544 
  def recv_getValidOrders(self, ):
2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
2551 
    result = getValidOrders_result()
2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
3431 rajveer 2554 
    if result.success is not None:
3064 chandransh 2555 
      return result.success
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2557 
 
1220 chandransh 2558 
  def batchOrders(self, warehouseId):
2559 
    """
2560 
    Create a batch of all the pending orders for the given warehouse.
2561 
    The returned list is orderd by created_timestamp.
2562 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2563 
 
1220 chandransh 2564 
    Parameters:
2565 
     - warehouseId
2566 
    """
2567 
    self.send_batchOrders(warehouseId)
2568 
    return self.recv_batchOrders()
2569 
 
2570 
  def send_batchOrders(self, warehouseId):
2571 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2572 
    args = batchOrders_args()
2573 
    args.warehouseId = warehouseId
2574 
    args.write(self._oprot)
2575 
    self._oprot.writeMessageEnd()
2576 
    self._oprot.trans.flush()
2577 
 
2578 
  def recv_batchOrders(self, ):
2579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2580 
    if mtype == TMessageType.EXCEPTION:
2581 
      x = TApplicationException()
2582 
      x.read(self._iprot)
2583 
      self._iprot.readMessageEnd()
2584 
      raise x
2585 
    result = batchOrders_result()
2586 
    result.read(self._iprot)
2587 
    self._iprot.readMessageEnd()
3431 rajveer 2588 
    if result.success is not None:
1220 chandransh 2589 
      return result.success
3431 rajveer 2590 
    if result.ex is not None:
1220 chandransh 2591 
      raise result.ex
2592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2593 
 
1208 chandransh 2594 
  def markOrderAsOutOfStock(self, orderId):
2595 
    """
2596 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2597 
 
1208 chandransh 2598 
    Parameters:
2599 
     - orderId
2600 
    """
2601 
    self.send_markOrderAsOutOfStock(orderId)
2602 
    return self.recv_markOrderAsOutOfStock()
2603 
 
2604 
  def send_markOrderAsOutOfStock(self, orderId):
2605 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2606 
    args = markOrderAsOutOfStock_args()
2607 
    args.orderId = orderId
2608 
    args.write(self._oprot)
2609 
    self._oprot.writeMessageEnd()
2610 
    self._oprot.trans.flush()
2611 
 
2612 
  def recv_markOrderAsOutOfStock(self, ):
2613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2614 
    if mtype == TMessageType.EXCEPTION:
2615 
      x = TApplicationException()
2616 
      x.read(self._iprot)
2617 
      self._iprot.readMessageEnd()
2618 
      raise x
2619 
    result = markOrderAsOutOfStock_result()
2620 
    result.read(self._iprot)
2621 
    self._iprot.readMessageEnd()
3431 rajveer 2622 
    if result.success is not None:
1208 chandransh 2623 
      return result.success
3431 rajveer 2624 
    if result.ex is not None:
1208 chandransh 2625 
      raise result.ex
2626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2627 
 
3064 chandransh 2628 
  def verifyOrder(self, orderId):
759 chandransh 2629 
    """
3064 chandransh 2630 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2631 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2632 
    used for all other orders as well.
2633 
    Throws an exception if no such order exists.
3431 rajveer 2634 
 
759 chandransh 2635 
    Parameters:
3064 chandransh 2636 
     - orderId
759 chandransh 2637 
    """
3064 chandransh 2638 
    self.send_verifyOrder(orderId)
2639 
    return self.recv_verifyOrder()
759 chandransh 2640 
 
3064 chandransh 2641 
  def send_verifyOrder(self, orderId):
2642 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2643 
    args = verifyOrder_args()
2644 
    args.orderId = orderId
759 chandransh 2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
3064 chandransh 2649 
  def recv_verifyOrder(self, ):
759 chandransh 2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
3064 chandransh 2656 
    result = verifyOrder_result()
759 chandransh 2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
3431 rajveer 2659 
    if result.success is not None:
759 chandransh 2660 
      return result.success
3431 rajveer 2661 
    if result.ex is not None:
759 chandransh 2662 
      raise result.ex
3064 chandransh 2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2664 
 
3064 chandransh 2665 
  def acceptOrder(self, orderId):
1113 chandransh 2666 
    """
3064 chandransh 2667 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2668 
    given order is not a COD order, it also captures the payment if the same has
2669 
    not been captured.
2670 
    Throws an exception if no such order exists.
3431 rajveer 2671 
 
1113 chandransh 2672 
    Parameters:
3064 chandransh 2673 
     - orderId
1113 chandransh 2674 
    """
3064 chandransh 2675 
    self.send_acceptOrder(orderId)
2676 
    return self.recv_acceptOrder()
1113 chandransh 2677 
 
3064 chandransh 2678 
  def send_acceptOrder(self, orderId):
2679 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2680 
    args = acceptOrder_args()
2681 
    args.orderId = orderId
1113 chandransh 2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
3064 chandransh 2686 
  def recv_acceptOrder(self, ):
1113 chandransh 2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
3064 chandransh 2693 
    result = acceptOrder_result()
1113 chandransh 2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
3431 rajveer 2696 
    if result.success is not None:
1113 chandransh 2697 
      return result.success
3431 rajveer 2698 
    if result.ex is not None:
1113 chandransh 2699 
      raise result.ex
3064 chandransh 2700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2701 
 
5110 mandeep.dh 2702 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2703 
    """
3064 chandransh 2704 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2705 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2706 
    the IMEI no. if a -1 is supplied.
2707 
    Also, it generates an invoice number for the order, marks the order as
2708 
    BILLED and sets the billing timestamp.
2709 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2710 
 
1135 chandransh 2711 
    Parameters:
3064 chandransh 2712 
     - orderId
2713 
     - invoice_number
4658 mandeep.dh 2714 
     - serialNumber
4283 anupam.sin 2715 
     - itemNumber
3064 chandransh 2716 
     - billed_by
4264 rajveer 2717 
     - jacketNumber
4283 anupam.sin 2718 
     - billingType
5110 mandeep.dh 2719 
     - fulfilmentWarehouseId
4763 rajveer 2720 
     - authorize
1135 chandransh 2721 
    """
5110 mandeep.dh 2722 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2723 
    return self.recv_addBillingDetails()
1135 chandransh 2724 
 
5110 mandeep.dh 2725 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2726 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2727 
    args = addBillingDetails_args()
2728 
    args.orderId = orderId
2729 
    args.invoice_number = invoice_number
4658 mandeep.dh 2730 
    args.serialNumber = serialNumber
4283 anupam.sin 2731 
    args.itemNumber = itemNumber
3064 chandransh 2732 
    args.billed_by = billed_by
4264 rajveer 2733 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2734 
    args.billingType = billingType
5110 mandeep.dh 2735 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2736 
    args.authorize = authorize
1135 chandransh 2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
3064 chandransh 2741 
  def recv_addBillingDetails(self, ):
1135 chandransh 2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
3064 chandransh 2748 
    result = addBillingDetails_result()
1135 chandransh 2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
3431 rajveer 2751 
    if result.success is not None:
3064 chandransh 2752 
      return result.success
3431 rajveer 2753 
    if result.ex is not None:
1135 chandransh 2754 
      raise result.ex
3064 chandransh 2755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2756 
 
6756 amar.kumar 2757 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2758 
    """
2759 
    Add the invoice number to the order.
2760 
 
2761 
    Parameters:
2762 
     - orderId
2763 
     - invoiceNumber
4763 rajveer 2764 
     - color
6756 amar.kumar 2765 
     - serialNumber
2766 
     - itemNumber
4579 rajveer 2767 
    """
6756 amar.kumar 2768 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2769 
    self.recv_addInvoiceNumber()
2770 
 
6756 amar.kumar 2771 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2772 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2773 
    args = addInvoiceNumber_args()
2774 
    args.orderId = orderId
2775 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2776 
    args.color = color
6756 amar.kumar 2777 
    args.serialNumber = serialNumber
2778 
    args.itemNumber = itemNumber
4579 rajveer 2779 
    args.write(self._oprot)
2780 
    self._oprot.writeMessageEnd()
2781 
    self._oprot.trans.flush()
2782 
 
2783 
  def recv_addInvoiceNumber(self, ):
2784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2785 
    if mtype == TMessageType.EXCEPTION:
2786 
      x = TApplicationException()
2787 
      x.read(self._iprot)
2788 
      self._iprot.readMessageEnd()
2789 
      raise x
2790 
    result = addInvoiceNumber_result()
2791 
    result.read(self._iprot)
2792 
    self._iprot.readMessageEnd()
2793 
    if result.ex is not None:
2794 
      raise result.ex
2795 
    return
2796 
 
4910 phani.kuma 2797 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2798 
    """
3064 chandransh 2799 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2800 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2801 
 
1408 ankur.sing 2802 
    Parameters:
3064 chandransh 2803 
     - warehouseId
1408 ankur.sing 2804 
     - providerId
3064 chandransh 2805 
     - cod
4910 phani.kuma 2806 
     - orderIds
1408 ankur.sing 2807 
    """
4910 phani.kuma 2808 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2809 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2810 
 
4910 phani.kuma 2811 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2812 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2813 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2814 
    args.warehouseId = warehouseId
1408 ankur.sing 2815 
    args.providerId = providerId
3064 chandransh 2816 
    args.cod = cod
4910 phani.kuma 2817 
    args.orderIds = orderIds
1408 ankur.sing 2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
4910 phani.kuma 2822 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
4910 phani.kuma 2829 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
3431 rajveer 2832 
    if result.success is not None:
1408 ankur.sing 2833 
      return result.success
3431 rajveer 2834 
    if result.ex is not None:
3064 chandransh 2835 
      raise result.ex
4910 phani.kuma 2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2837 
 
5713 rajveer 2838 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2839 
    """
2840 
    Parameters:
2841 
     - providerId
2842 
     - orderIds
5713 rajveer 2843 
     - awbs
5676 rajveer 2844 
    """
5713 rajveer 2845 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2846 
    return self.recv_markOrdersAsReturnedFromStore()
2847 
 
5713 rajveer 2848 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2849 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2850 
    args = markOrdersAsReturnedFromStore_args()
2851 
    args.providerId = providerId
2852 
    args.orderIds = orderIds
5713 rajveer 2853 
    args.awbs = awbs
5676 rajveer 2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2858 
  def recv_markOrdersAsReturnedFromStore(self, ):
2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2865 
    result = markOrdersAsReturnedFromStore_result()
2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    if result.success is not None:
2869 
      return result.success
2870 
    if result.ex is not None:
2871 
      raise result.ex
2872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2873 
 
4910 phani.kuma 2874 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2875 
    """
4910 phani.kuma 2876 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2877 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2878 
 
2879 
    Parameters:
2880 
     - providerId
4910 phani.kuma 2881 
     - pickupDetails
4410 rajveer 2882 
    """
4910 phani.kuma 2883 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2884 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2885 
 
4910 phani.kuma 2886 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2887 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2888 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2889 
    args.providerId = providerId
4910 phani.kuma 2890 
    args.pickupDetails = pickupDetails
4410 rajveer 2891 
    args.write(self._oprot)
2892 
    self._oprot.writeMessageEnd()
2893 
    self._oprot.trans.flush()
2894 
 
4910 phani.kuma 2895 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2897 
    if mtype == TMessageType.EXCEPTION:
2898 
      x = TApplicationException()
2899 
      x.read(self._iprot)
2900 
      self._iprot.readMessageEnd()
2901 
      raise x
4910 phani.kuma 2902 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2903 
    result.read(self._iprot)
2904 
    self._iprot.readMessageEnd()
2905 
    if result.ex is not None:
2906 
      raise result.ex
4910 phani.kuma 2907 
    return
4410 rajveer 2908 
 
4910 phani.kuma 2909 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2910 
    """
3064 chandransh 2911 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2912 
 
94 ashish 2913 
    Parameters:
3064 chandransh 2914 
     - providerId
304 ashish 2915 
    """
4910 phani.kuma 2916 
    self.send_getOrdersNotPickedUp(providerId)
2917 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2918 
 
4910 phani.kuma 2919 
  def send_getOrdersNotPickedUp(self, providerId):
2920 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2921 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2922 
    args.providerId = providerId
304 ashish 2923 
    args.write(self._oprot)
2924 
    self._oprot.writeMessageEnd()
2925 
    self._oprot.trans.flush()
2926 
 
4910 phani.kuma 2927 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2929 
    if mtype == TMessageType.EXCEPTION:
2930 
      x = TApplicationException()
2931 
      x.read(self._iprot)
2932 
      self._iprot.readMessageEnd()
2933 
      raise x
4910 phani.kuma 2934 
    result = getOrdersNotPickedUp_result()
304 ashish 2935 
    result.read(self._iprot)
2936 
    self._iprot.readMessageEnd()
3431 rajveer 2937 
    if result.success is not None:
304 ashish 2938 
      return result.success
4910 phani.kuma 2939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2940 
 
3064 chandransh 2941 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2942 
    """
3064 chandransh 2943 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2944 
    the name of the receiver.
2945 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2946 
 
304 ashish 2947 
    Parameters:
3064 chandransh 2948 
     - providerId
2949 
     - deliveredOrders
304 ashish 2950 
    """
3064 chandransh 2951 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2952 
    self.recv_markOrdersAsDelivered()
304 ashish 2953 
 
3064 chandransh 2954 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2955 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2956 
    args = markOrdersAsDelivered_args()
2957 
    args.providerId = providerId
2958 
    args.deliveredOrders = deliveredOrders
304 ashish 2959 
    args.write(self._oprot)
2960 
    self._oprot.writeMessageEnd()
2961 
    self._oprot.trans.flush()
2962 
 
3064 chandransh 2963 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2965 
    if mtype == TMessageType.EXCEPTION:
2966 
      x = TApplicationException()
2967 
      x.read(self._iprot)
2968 
      self._iprot.readMessageEnd()
2969 
      raise x
3064 chandransh 2970 
    result = markOrdersAsDelivered_result()
304 ashish 2971 
    result.read(self._iprot)
2972 
    self._iprot.readMessageEnd()
3431 rajveer 2973 
    if result.ex is not None:
3064 chandransh 2974 
      raise result.ex
304 ashish 2975 
    return
2976 
 
4910 phani.kuma 2977 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2978 
    """
4910 phani.kuma 2979 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2980 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2981 
 
3064 chandransh 2982 
    Parameters:
2983 
     - providerId
2984 
     - returnedOrders
1596 ankur.sing 2985 
    """
4910 phani.kuma 2986 
    self.send_markAsRTOrders(providerId, returnedOrders)
2987 
    self.recv_markAsRTOrders()
304 ashish 2988 
 
4910 phani.kuma 2989 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2990 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2991 
    args = markAsRTOrders_args()
3064 chandransh 2992 
    args.providerId = providerId
2993 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2994 
    args.write(self._oprot)
2995 
    self._oprot.writeMessageEnd()
2996 
    self._oprot.trans.flush()
2997 
 
4910 phani.kuma 2998 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3000 
    if mtype == TMessageType.EXCEPTION:
3001 
      x = TApplicationException()
3002 
      x.read(self._iprot)
3003 
      self._iprot.readMessageEnd()
3004 
      raise x
4910 phani.kuma 3005 
    result = markAsRTOrders_result()
1596 ankur.sing 3006 
    result.read(self._iprot)
3007 
    self._iprot.readMessageEnd()
3431 rajveer 3008 
    if result.ex is not None:
3064 chandransh 3009 
      raise result.ex
3010 
    return
1596 ankur.sing 3011 
 
4910 phani.kuma 3012 
  def getRTOrders(self, providerId):
3013 
    """
3014 
    Returns a list of orders that were returned by courier.
3015 
 
3016 
    Parameters:
3017 
     - providerId
3018 
    """
3019 
    self.send_getRTOrders(providerId)
3020 
    return self.recv_getRTOrders()
3021 
 
3022 
  def send_getRTOrders(self, providerId):
3023 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3024 
    args = getRTOrders_args()
3025 
    args.providerId = providerId
3026 
    args.write(self._oprot)
3027 
    self._oprot.writeMessageEnd()
3028 
    self._oprot.trans.flush()
3029 
 
3030 
  def recv_getRTOrders(self, ):
3031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3032 
    if mtype == TMessageType.EXCEPTION:
3033 
      x = TApplicationException()
3034 
      x.read(self._iprot)
3035 
      self._iprot.readMessageEnd()
3036 
      raise x
3037 
    result = getRTOrders_result()
3038 
    result.read(self._iprot)
3039 
    self._iprot.readMessageEnd()
3040 
    if result.success is not None:
3041 
      return result.success
3042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3043 
 
3064 chandransh 3044 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3045 
    """
3064 chandransh 3046 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3047 
 
3064 chandransh 3048 
    Parameters:
3049 
     - providerId
3050 
     - undeliveredOrders
1627 ankur.sing 3051 
    """
3064 chandransh 3052 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3053 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3054 
 
3064 chandransh 3055 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3056 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3057 
    args = updateNonDeliveryReason_args()
3058 
    args.providerId = providerId
3059 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3060 
    args.write(self._oprot)
3061 
    self._oprot.writeMessageEnd()
3062 
    self._oprot.trans.flush()
3063 
 
3064 chandransh 3064 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3066 
    if mtype == TMessageType.EXCEPTION:
3067 
      x = TApplicationException()
3068 
      x.read(self._iprot)
3069 
      self._iprot.readMessageEnd()
3070 
      raise x
3064 chandransh 3071 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3072 
    result.read(self._iprot)
3073 
    self._iprot.readMessageEnd()
4910 phani.kuma 3074 
    if result.ex is not None:
3075 
      raise result.ex
3076 
    return
3077 
 
3078 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3079 
    """
3080 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3081 
 
3082 
    Parameters:
3083 
     - providerId
3084 
    """
3085 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3086 
    return self.recv_getNonDeliveredOrdersbyCourier()
3087 
 
3088 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3089 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3090 
    args = getNonDeliveredOrdersbyCourier_args()
3091 
    args.providerId = providerId
3092 
    args.write(self._oprot)
3093 
    self._oprot.writeMessageEnd()
3094 
    self._oprot.trans.flush()
3095 
 
3096 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3098 
    if mtype == TMessageType.EXCEPTION:
3099 
      x = TApplicationException()
3100 
      x.read(self._iprot)
3101 
      self._iprot.readMessageEnd()
3102 
      raise x
3103 
    result = getNonDeliveredOrdersbyCourier_result()
3104 
    result.read(self._iprot)
3105 
    self._iprot.readMessageEnd()
4581 phani.kuma 3106 
    if result.success is not None:
3107 
      return result.success
4910 phani.kuma 3108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3109 
 
3110 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3111 
    """
3112 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3113 
 
3114 
    Parameters:
3115 
     - providerId
3116 
     - local_connected_orders
3117 
    """
3118 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3119 
    self.recv_markOrdersAsLocalConnected()
3120 
 
3121 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3122 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3123 
    args = markOrdersAsLocalConnected_args()
3124 
    args.providerId = providerId
3125 
    args.local_connected_orders = local_connected_orders
3126 
    args.write(self._oprot)
3127 
    self._oprot.writeMessageEnd()
3128 
    self._oprot.trans.flush()
3129 
 
3130 
  def recv_markOrdersAsLocalConnected(self, ):
3131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3132 
    if mtype == TMessageType.EXCEPTION:
3133 
      x = TApplicationException()
3134 
      x.read(self._iprot)
3135 
      self._iprot.readMessageEnd()
3136 
      raise x
3137 
    result = markOrdersAsLocalConnected_result()
3138 
    result.read(self._iprot)
3139 
    self._iprot.readMessageEnd()
3431 rajveer 3140 
    if result.ex is not None:
3064 chandransh 3141 
      raise result.ex
4910 phani.kuma 3142 
    return
1627 ankur.sing 3143 
 
4910 phani.kuma 3144 
  def getOrdersNotLocalConnected(self, providerId):
3145 
    """
3146 
    Returns a list of orders that were picked up or shipped but pending local connection.
3147 
 
3148 
    Parameters:
3149 
     - providerId
3150 
    """
3151 
    self.send_getOrdersNotLocalConnected(providerId)
3152 
    return self.recv_getOrdersNotLocalConnected()
3153 
 
3154 
  def send_getOrdersNotLocalConnected(self, providerId):
3155 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3156 
    args = getOrdersNotLocalConnected_args()
3157 
    args.providerId = providerId
3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3162 
  def recv_getOrdersNotLocalConnected(self, ):
3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3169 
    result = getOrdersNotLocalConnected_result()
3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3172 
    if result.success is not None:
3173 
      return result.success
3174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3175 
 
3176 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3177 
    """
3178 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3179 
 
3180 
    Parameters:
3181 
     - providerId
3182 
     - destination_city_reached_orders
3183 
    """
3184 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3185 
    self.recv_markOrdersAsDestinationCityReached()
3186 
 
3187 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3188 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3189 
    args = markOrdersAsDestinationCityReached_args()
3190 
    args.providerId = providerId
3191 
    args.destination_city_reached_orders = destination_city_reached_orders
3192 
    args.write(self._oprot)
3193 
    self._oprot.writeMessageEnd()
3194 
    self._oprot.trans.flush()
3195 
 
3196 
  def recv_markOrdersAsDestinationCityReached(self, ):
3197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3198 
    if mtype == TMessageType.EXCEPTION:
3199 
      x = TApplicationException()
3200 
      x.read(self._iprot)
3201 
      self._iprot.readMessageEnd()
3202 
      raise x
3203 
    result = markOrdersAsDestinationCityReached_result()
3204 
    result.read(self._iprot)
3205 
    self._iprot.readMessageEnd()
3206 
    if result.ex is not None:
3207 
      raise result.ex
3208 
    return
3209 
 
3210 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3211 
    """
3212 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3213 
 
3214 
    Parameters:
3215 
     - providerId
3216 
     - first_atdl_orders
3217 
    """
3218 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3219 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3220 
 
3221 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3222 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3223 
    args = markOrdersAsFirstDeliveryAttempted_args()
3224 
    args.providerId = providerId
3225 
    args.first_atdl_orders = first_atdl_orders
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = markOrdersAsFirstDeliveryAttempted_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.ex is not None:
3241 
      raise result.ex
3242 
    return
3243 
 
3064 chandransh 3244 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3245 
    """
3064 chandransh 3246 
    Returns the list of orders whose delivery time has passed but have not been
3247 
    delivered yet for the given provider and warehouse. To get a complete list of
3248 
    undelivered orders, pass them as -1.
3249 
    Returns an empty list if no such orders exist.
3431 rajveer 3250 
 
1886 ankur.sing 3251 
    Parameters:
3064 chandransh 3252 
     - providerId
3253 
     - warehouseId
1886 ankur.sing 3254 
    """
3064 chandransh 3255 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3256 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3257 
 
3064 chandransh 3258 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3259 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3260 
    args = getUndeliveredOrders_args()
3261 
    args.providerId = providerId
3262 
    args.warehouseId = warehouseId
1886 ankur.sing 3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
3064 chandransh 3267 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
3064 chandransh 3274 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
3431 rajveer 3277 
    if result.success is not None:
1886 ankur.sing 3278 
      return result.success
3064 chandransh 3279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3280 
 
4783 phani.kuma 3281 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3282 
    """
3283 
    Returns the list of orders whose expected delivery date has passed but have not been
3284 
    delivered yet.
3285 
    Returns an empty list if no such orders exist.
3286 
    """
3287 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3288 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3289 
 
3290 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3291 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3292 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3293 
    args.write(self._oprot)
3294 
    self._oprot.writeMessageEnd()
3295 
    self._oprot.trans.flush()
3296 
 
3297 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3299 
    if mtype == TMessageType.EXCEPTION:
3300 
      x = TApplicationException()
3301 
      x.read(self._iprot)
3302 
      self._iprot.readMessageEnd()
3303 
      raise x
3304 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3305 
    result.read(self._iprot)
3306 
    self._iprot.readMessageEnd()
3307 
    if result.success is not None:
3308 
      return result.success
3309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3310 
 
2536 chandransh 3311 
  def toggleDOAFlag(self, orderId):
3312 
    """
3313 
    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.
3314 
    Returns the final flag status.
3315 
    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 3316 
 
2536 chandransh 3317 
    Parameters:
3318 
     - orderId
3319 
    """
3320 
    self.send_toggleDOAFlag(orderId)
3321 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3322 
 
2536 chandransh 3323 
  def send_toggleDOAFlag(self, orderId):
3324 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3325 
    args = toggleDOAFlag_args()
3326 
    args.orderId = orderId
3327 
    args.write(self._oprot)
3328 
    self._oprot.writeMessageEnd()
3329 
    self._oprot.trans.flush()
3330 
 
3331 
  def recv_toggleDOAFlag(self, ):
3332 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3333 
    if mtype == TMessageType.EXCEPTION:
3334 
      x = TApplicationException()
3335 
      x.read(self._iprot)
3336 
      self._iprot.readMessageEnd()
3337 
      raise x
3338 
    result = toggleDOAFlag_result()
3339 
    result.read(self._iprot)
3340 
    self._iprot.readMessageEnd()
3431 rajveer 3341 
    if result.success is not None:
2536 chandransh 3342 
      return result.success
3431 rajveer 3343 
    if result.ex is not None:
2536 chandransh 3344 
      raise result.ex
3345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3346 
 
4712 rajveer 3347 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3348 
    """
3349 
    Parameters:
3350 
     - orderId
3351 
     - deliveryTimestamp
3352 
     - receiver
3353 
    """
3354 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3355 
    self.recv_markOrderAsDelivered()
3356 
 
3357 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3358 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3359 
    args = markOrderAsDelivered_args()
3360 
    args.orderId = orderId
3361 
    args.deliveryTimestamp = deliveryTimestamp
3362 
    args.receiver = receiver
3363 
    args.write(self._oprot)
3364 
    self._oprot.writeMessageEnd()
3365 
    self._oprot.trans.flush()
3366 
 
3367 
  def recv_markOrderAsDelivered(self, ):
3368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3369 
    if mtype == TMessageType.EXCEPTION:
3370 
      x = TApplicationException()
3371 
      x.read(self._iprot)
3372 
      self._iprot.readMessageEnd()
3373 
      raise x
3374 
    result = markOrderAsDelivered_result()
3375 
    result.read(self._iprot)
3376 
    self._iprot.readMessageEnd()
3377 
    if result.ex is not None:
3378 
      raise result.ex
3379 
    return
3380 
 
5553 rajveer 3381 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3382 
    """
3383 
    Parameters:
3384 
     - orderId
3385 
     - deliveryTimestamp
3386 
    """
3387 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3388 
    self.recv_markOrderAsReceivedAtStore()
3389 
 
3390 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3391 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3392 
    args = markOrderAsReceivedAtStore_args()
3393 
    args.orderId = orderId
3394 
    args.deliveryTimestamp = deliveryTimestamp
3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3399 
  def recv_markOrderAsReceivedAtStore(self, ):
3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3406 
    result = markOrderAsReceivedAtStore_result()
3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
3409 
    if result.ex is not None:
3410 
      raise result.ex
3411 
    return
3412 
 
4454 rajveer 3413 
  def markOrderDoaRequestReceived(self, orderId):
3414 
    """
3415 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3416 
 
3417 
    Parameters:
3418 
     - orderId
3419 
    """
3420 
    self.send_markOrderDoaRequestReceived(orderId)
3421 
    return self.recv_markOrderDoaRequestReceived()
3422 
 
3423 
  def send_markOrderDoaRequestReceived(self, orderId):
3424 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3425 
    args = markOrderDoaRequestReceived_args()
3426 
    args.orderId = orderId
3427 
    args.write(self._oprot)
3428 
    self._oprot.writeMessageEnd()
3429 
    self._oprot.trans.flush()
3430 
 
3431 
  def recv_markOrderDoaRequestReceived(self, ):
3432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3433 
    if mtype == TMessageType.EXCEPTION:
3434 
      x = TApplicationException()
3435 
      x.read(self._iprot)
3436 
      self._iprot.readMessageEnd()
3437 
      raise x
3438 
    result = markOrderDoaRequestReceived_result()
3439 
    result.read(self._iprot)
3440 
    self._iprot.readMessageEnd()
3441 
    if result.success is not None:
3442 
      return result.success
3443 
    if result.ex is not None:
3444 
      raise result.ex
3445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3446 
 
3447 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3448 
    """
3449 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3450 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3451 
 
3452 
    Parameters:
3453 
     - orderId
3454 
     - isAuthorized
3455 
    """
3456 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3457 
    return self.recv_markOrderDoaRequestAuthorized()
3458 
 
3459 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3460 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3461 
    args = markOrderDoaRequestAuthorized_args()
3462 
    args.orderId = orderId
3463 
    args.isAuthorized = isAuthorized
3464 
    args.write(self._oprot)
3465 
    self._oprot.writeMessageEnd()
3466 
    self._oprot.trans.flush()
3467 
 
3468 
  def recv_markOrderDoaRequestAuthorized(self, ):
3469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3470 
    if mtype == TMessageType.EXCEPTION:
3471 
      x = TApplicationException()
3472 
      x.read(self._iprot)
3473 
      self._iprot.readMessageEnd()
3474 
      raise x
3475 
    result = markOrderDoaRequestAuthorized_result()
3476 
    result.read(self._iprot)
3477 
    self._iprot.readMessageEnd()
3478 
    if result.success is not None:
3479 
      return result.success
3480 
    if result.ex is not None:
3481 
      raise result.ex
3482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3483 
 
4488 rajveer 3484 
  def markOrderReturnRequestReceived(self, orderId):
3485 
    """
3486 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3487 
 
3488 
    Parameters:
3489 
     - orderId
3490 
    """
3491 
    self.send_markOrderReturnRequestReceived(orderId)
3492 
    return self.recv_markOrderReturnRequestReceived()
3493 
 
3494 
  def send_markOrderReturnRequestReceived(self, orderId):
3495 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3496 
    args = markOrderReturnRequestReceived_args()
3497 
    args.orderId = orderId
3498 
    args.write(self._oprot)
3499 
    self._oprot.writeMessageEnd()
3500 
    self._oprot.trans.flush()
3501 
 
3502 
  def recv_markOrderReturnRequestReceived(self, ):
3503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3504 
    if mtype == TMessageType.EXCEPTION:
3505 
      x = TApplicationException()
3506 
      x.read(self._iprot)
3507 
      self._iprot.readMessageEnd()
3508 
      raise x
3509 
    result = markOrderReturnRequestReceived_result()
3510 
    result.read(self._iprot)
3511 
    self._iprot.readMessageEnd()
3512 
    if result.success is not None:
3513 
      return result.success
3514 
    if result.ex is not None:
3515 
      raise result.ex
3516 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3517 
 
3518 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3519 
    """
3520 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3521 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3522 
 
3523 
    Parameters:
3524 
     - orderId
3525 
     - isAuthorized
3526 
    """
3527 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3528 
    return self.recv_markOrderReturnRequestAuthorized()
3529 
 
3530 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3531 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3532 
    args = markOrderReturnRequestAuthorized_args()
3533 
    args.orderId = orderId
3534 
    args.isAuthorized = isAuthorized
3535 
    args.write(self._oprot)
3536 
    self._oprot.writeMessageEnd()
3537 
    self._oprot.trans.flush()
3538 
 
3539 
  def recv_markOrderReturnRequestAuthorized(self, ):
3540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3541 
    if mtype == TMessageType.EXCEPTION:
3542 
      x = TApplicationException()
3543 
      x.read(self._iprot)
3544 
      self._iprot.readMessageEnd()
3545 
      raise x
3546 
    result = markOrderReturnRequestAuthorized_result()
3547 
    result.read(self._iprot)
3548 
    self._iprot.readMessageEnd()
3549 
    if result.success is not None:
3550 
      return result.success
3551 
    if result.ex is not None:
3552 
      raise result.ex
3553 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3554 
 
4579 rajveer 3555 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3556 
    """
3557 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3558 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3559 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3560 
    For any other status, it returns false.
3561 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3562 
 
2536 chandransh 3563 
    Parameters:
3564 
     - orderId
4579 rajveer 3565 
     - providerId
2536 chandransh 3566 
    """
4579 rajveer 3567 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3568 
    return self.recv_requestPickupNumber()
3569 
 
4579 rajveer 3570 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3571 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3572 
    args = requestPickupNumber_args()
3573 
    args.orderId = orderId
4579 rajveer 3574 
    args.providerId = providerId
2536 chandransh 3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_requestPickupNumber(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = requestPickupNumber_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
3431 rajveer 3589 
    if result.success is not None:
2536 chandransh 3590 
      return result.success
3431 rajveer 3591 
    if result.ex is not None:
2536 chandransh 3592 
      raise result.ex
3593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3594 
 
4602 rajveer 3595 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3596 
    """
4452 rajveer 3597 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3598 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3599 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3600 
    	3. Returns true
2591 chandransh 3601 
    If the order is in any other status, it returns false.
2536 chandransh 3602 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3603 
 
2536 chandransh 3604 
    Parameters:
3605 
     - orderId
3606 
     - pickupNumber
4602 rajveer 3607 
     - providerId
2536 chandransh 3608 
    """
4602 rajveer 3609 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3610 
    return self.recv_authorizePickup()
3611 
 
4602 rajveer 3612 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3613 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3614 
    args = authorizePickup_args()
3615 
    args.orderId = orderId
3616 
    args.pickupNumber = pickupNumber
4602 rajveer 3617 
    args.providerId = providerId
2536 chandransh 3618 
    args.write(self._oprot)
3619 
    self._oprot.writeMessageEnd()
3620 
    self._oprot.trans.flush()
3621 
 
3622 
  def recv_authorizePickup(self, ):
3623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3624 
    if mtype == TMessageType.EXCEPTION:
3625 
      x = TApplicationException()
3626 
      x.read(self._iprot)
3627 
      self._iprot.readMessageEnd()
3628 
      raise x
3629 
    result = authorizePickup_result()
3630 
    result.read(self._iprot)
3631 
    self._iprot.readMessageEnd()
3431 rajveer 3632 
    if result.success is not None:
2536 chandransh 3633 
      return result.success
3431 rajveer 3634 
    if result.ex is not None:
2536 chandransh 3635 
      raise result.ex
3636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3637 
 
2764 chandransh 3638 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3639 
    """
3640 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3641 
 
2764 chandransh 3642 
    Parameters:
3643 
     - providerId
3644 
     - pickupDetails
3645 
    """
3646 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3647 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3648 
 
3649 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3650 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3651 
    args = markDoasAsPickedUp_args()
3652 
    args.providerId = providerId
3653 
    args.pickupDetails = pickupDetails
3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_markDoasAsPickedUp(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = markDoasAsPickedUp_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
4910 phani.kuma 3668 
    return
3669 
 
3670 
  def getDoasNotPickedUp(self, providerId):
3671 
    """
3672 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3673 
 
3674 
    Parameters:
3675 
     - providerId
3676 
    """
3677 
    self.send_getDoasNotPickedUp(providerId)
3678 
    return self.recv_getDoasNotPickedUp()
3679 
 
3680 
  def send_getDoasNotPickedUp(self, providerId):
3681 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3682 
    args = getDoasNotPickedUp_args()
3683 
    args.providerId = providerId
3684 
    args.write(self._oprot)
3685 
    self._oprot.writeMessageEnd()
3686 
    self._oprot.trans.flush()
3687 
 
3688 
  def recv_getDoasNotPickedUp(self, ):
3689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3690 
    if mtype == TMessageType.EXCEPTION:
3691 
      x = TApplicationException()
3692 
      x.read(self._iprot)
3693 
      self._iprot.readMessageEnd()
3694 
      raise x
3695 
    result = getDoasNotPickedUp_result()
3696 
    result.read(self._iprot)
3697 
    self._iprot.readMessageEnd()
3431 rajveer 3698 
    if result.success is not None:
2764 chandransh 3699 
      return result.success
4910 phani.kuma 3700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3701 
 
4741 phani.kuma 3702 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3703 
    """
3704 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3705 
 
3706 
    Parameters:
3707 
     - providerId
3708 
     - pickupDetails
3709 
    """
3710 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3711 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3712 
 
3713 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3714 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3715 
    args = markReturnOrdersAsPickedUp_args()
3716 
    args.providerId = providerId
3717 
    args.pickupDetails = pickupDetails
3718 
    args.write(self._oprot)
3719 
    self._oprot.writeMessageEnd()
3720 
    self._oprot.trans.flush()
3721 
 
3722 
  def recv_markReturnOrdersAsPickedUp(self, ):
3723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3724 
    if mtype == TMessageType.EXCEPTION:
3725 
      x = TApplicationException()
3726 
      x.read(self._iprot)
3727 
      self._iprot.readMessageEnd()
3728 
      raise x
3729 
    result = markReturnOrdersAsPickedUp_result()
3730 
    result.read(self._iprot)
3731 
    self._iprot.readMessageEnd()
4910 phani.kuma 3732 
    return
3733 
 
3734 
  def getReturnOrdersNotPickedUp(self, providerId):
3735 
    """
3736 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3737 
 
3738 
    Parameters:
3739 
     - providerId
3740 
    """
3741 
    self.send_getReturnOrdersNotPickedUp(providerId)
3742 
    return self.recv_getReturnOrdersNotPickedUp()
3743 
 
3744 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3745 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3746 
    args = getReturnOrdersNotPickedUp_args()
3747 
    args.providerId = providerId
3748 
    args.write(self._oprot)
3749 
    self._oprot.writeMessageEnd()
3750 
    self._oprot.trans.flush()
3751 
 
3752 
  def recv_getReturnOrdersNotPickedUp(self, ):
3753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3754 
    if mtype == TMessageType.EXCEPTION:
3755 
      x = TApplicationException()
3756 
      x.read(self._iprot)
3757 
      self._iprot.readMessageEnd()
3758 
      raise x
3759 
    result = getReturnOrdersNotPickedUp_result()
3760 
    result.read(self._iprot)
3761 
    self._iprot.readMessageEnd()
4741 phani.kuma 3762 
    if result.success is not None:
3763 
      return result.success
4910 phani.kuma 3764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3765 
 
4479 rajveer 3766 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3767 
    """
4452 rajveer 3768 
    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 3769 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3770 
    If the order is in any other state, it returns false.
3771 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3772 
 
2591 chandransh 3773 
    Parameters:
3774 
     - orderId
4479 rajveer 3775 
     - receiveCondition
2591 chandransh 3776 
    """
4479 rajveer 3777 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3778 
    return self.recv_receiveReturn()
2536 chandransh 3779 
 
4479 rajveer 3780 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3781 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3782 
    args = receiveReturn_args()
2591 chandransh 3783 
    args.orderId = orderId
4479 rajveer 3784 
    args.receiveCondition = receiveCondition
2591 chandransh 3785 
    args.write(self._oprot)
3786 
    self._oprot.writeMessageEnd()
3787 
    self._oprot.trans.flush()
3788 
 
2616 chandransh 3789 
  def recv_receiveReturn(self, ):
2591 chandransh 3790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3791 
    if mtype == TMessageType.EXCEPTION:
3792 
      x = TApplicationException()
3793 
      x.read(self._iprot)
3794 
      self._iprot.readMessageEnd()
3795 
      raise x
2616 chandransh 3796 
    result = receiveReturn_result()
2591 chandransh 3797 
    result.read(self._iprot)
3798 
    self._iprot.readMessageEnd()
3431 rajveer 3799 
    if result.success is not None:
2591 chandransh 3800 
      return result.success
3431 rajveer 3801 
    if result.ex is not None:
2591 chandransh 3802 
      raise result.ex
2616 chandransh 3803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3804 
 
3805 
  def validateDoa(self, orderId, isValid):
3806 
    """
4452 rajveer 3807 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3808 
    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 3809 
    If the order is in any other state, it returns false.
3810 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3811 
 
2591 chandransh 3812 
    Parameters:
3813 
     - orderId
3814 
     - isValid
3815 
    """
3816 
    self.send_validateDoa(orderId, isValid)
3817 
    return self.recv_validateDoa()
3818 
 
3819 
  def send_validateDoa(self, orderId, isValid):
3820 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3821 
    args = validateDoa_args()
3822 
    args.orderId = orderId
3823 
    args.isValid = isValid
3824 
    args.write(self._oprot)
3825 
    self._oprot.writeMessageEnd()
3826 
    self._oprot.trans.flush()
3827 
 
3828 
  def recv_validateDoa(self, ):
3829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3830 
    if mtype == TMessageType.EXCEPTION:
3831 
      x = TApplicationException()
3832 
      x.read(self._iprot)
3833 
      self._iprot.readMessageEnd()
3834 
      raise x
3835 
    result = validateDoa_result()
3836 
    result.read(self._iprot)
3837 
    self._iprot.readMessageEnd()
3431 rajveer 3838 
    if result.success is not None:
2591 chandransh 3839 
      return result.success
3431 rajveer 3840 
    if result.ex is not None:
2591 chandransh 3841 
      raise result.ex
3842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3843 
 
4495 rajveer 3844 
  def validateReturnProduct(self, orderId, isUsable):
3845 
    """
3846 
    Parameters:
3847 
     - orderId
3848 
     - isUsable
3849 
    """
3850 
    self.send_validateReturnProduct(orderId, isUsable)
3851 
    return self.recv_validateReturnProduct()
3852 
 
3853 
  def send_validateReturnProduct(self, orderId, isUsable):
3854 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3855 
    args = validateReturnProduct_args()
3856 
    args.orderId = orderId
3857 
    args.isUsable = isUsable
3858 
    args.write(self._oprot)
3859 
    self._oprot.writeMessageEnd()
3860 
    self._oprot.trans.flush()
3861 
 
3862 
  def recv_validateReturnProduct(self, ):
3863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3864 
    if mtype == TMessageType.EXCEPTION:
3865 
      x = TApplicationException()
3866 
      x.read(self._iprot)
3867 
      self._iprot.readMessageEnd()
3868 
      raise x
3869 
    result = validateReturnProduct_result()
3870 
    result.read(self._iprot)
3871 
    self._iprot.readMessageEnd()
3872 
    if result.success is not None:
3873 
      return result.success
3874 
    if result.ex is not None:
3875 
      raise result.ex
3876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3877 
 
2616 chandransh 3878 
  def reshipOrder(self, orderId):
3879 
    """
4484 rajveer 3880 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3881 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3882 
    	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 3883 
 
3884 
    If the order is in DOA_CERT_VALID state, it does the following:
3885 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3886 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3887 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3888 
 
2616 chandransh 3889 
    Returns the id of the newly created order.
3431 rajveer 3890 
 
2616 chandransh 3891 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3892 
 
2616 chandransh 3893 
    Parameters:
3894 
     - orderId
3895 
    """
3896 
    self.send_reshipOrder(orderId)
3897 
    return self.recv_reshipOrder()
2591 chandransh 3898 
 
2616 chandransh 3899 
  def send_reshipOrder(self, orderId):
3900 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3901 
    args = reshipOrder_args()
3902 
    args.orderId = orderId
3903 
    args.write(self._oprot)
3904 
    self._oprot.writeMessageEnd()
3905 
    self._oprot.trans.flush()
3906 
 
3907 
  def recv_reshipOrder(self, ):
3908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3909 
    if mtype == TMessageType.EXCEPTION:
3910 
      x = TApplicationException()
3911 
      x.read(self._iprot)
3912 
      self._iprot.readMessageEnd()
3913 
      raise x
3914 
    result = reshipOrder_result()
3915 
    result.read(self._iprot)
3916 
    self._iprot.readMessageEnd()
3431 rajveer 3917 
    if result.success is not None:
2616 chandransh 3918 
      return result.success
3431 rajveer 3919 
    if result.ex is not None:
2616 chandransh 3920 
      raise result.ex
3921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3922 
 
3226 chandransh 3923 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3924 
    """
4484 rajveer 3925 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3926 
    	1. Creates a refund request for batch processing.
3927 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3928 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3929 
 
2616 chandransh 3930 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3931 
    	1. Creates a refund request for batch processing.
3226 chandransh 3932 
    	2. Cancels the reservation of the item in the warehouse.
3933 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3934 
 
3226 chandransh 3935 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3936 
    	1. Cancels the reservation of the item in the warehouse.
3937 
    	2. Marks the current order as CANCELED.
3938 
 
3939 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3940 
 
2616 chandransh 3941 
    Returns True if it is successful, False otherwise.
3431 rajveer 3942 
 
2616 chandransh 3943 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3944 
 
2616 chandransh 3945 
    Parameters:
3946 
     - orderId
3226 chandransh 3947 
     - refundedBy
3948 
     - reason
2616 chandransh 3949 
    """
3226 chandransh 3950 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3951 
    return self.recv_refundOrder()
3952 
 
3226 chandransh 3953 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3954 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3955 
    args = refundOrder_args()
3956 
    args.orderId = orderId
3226 chandransh 3957 
    args.refundedBy = refundedBy
3958 
    args.reason = reason
2616 chandransh 3959 
    args.write(self._oprot)
3960 
    self._oprot.writeMessageEnd()
3961 
    self._oprot.trans.flush()
3962 
 
3963 
  def recv_refundOrder(self, ):
3964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3965 
    if mtype == TMessageType.EXCEPTION:
3966 
      x = TApplicationException()
3967 
      x.read(self._iprot)
3968 
      self._iprot.readMessageEnd()
3969 
      raise x
3970 
    result = refundOrder_result()
3971 
    result.read(self._iprot)
3972 
    self._iprot.readMessageEnd()
3431 rajveer 3973 
    if result.success is not None:
2616 chandransh 3974 
      return result.success
3431 rajveer 3975 
    if result.ex is not None:
2616 chandransh 3976 
      raise result.ex
3977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3978 
 
2690 chandransh 3979 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3980 
    """
3981 
    Get all return orders created between the from and to dates for the given warehouse.
3982 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3983 
 
2690 chandransh 3984 
    Parameters:
3985 
     - warehouseId
3986 
     - fromDate
3987 
     - toDate
3988 
    """
3989 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3990 
    return self.recv_getReturnOrders()
2616 chandransh 3991 
 
2690 chandransh 3992 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3993 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3994 
    args = getReturnOrders_args()
3995 
    args.warehouseId = warehouseId
3996 
    args.fromDate = fromDate
3997 
    args.toDate = toDate
3998 
    args.write(self._oprot)
3999 
    self._oprot.writeMessageEnd()
4000 
    self._oprot.trans.flush()
4001 
 
4002 
  def recv_getReturnOrders(self, ):
4003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4004 
    if mtype == TMessageType.EXCEPTION:
4005 
      x = TApplicationException()
4006 
      x.read(self._iprot)
4007 
      self._iprot.readMessageEnd()
4008 
      raise x
4009 
    result = getReturnOrders_result()
4010 
    result.read(self._iprot)
4011 
    self._iprot.readMessageEnd()
3431 rajveer 4012 
    if result.success is not None:
2690 chandransh 4013 
      return result.success
4014 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4015 
 
5481 phani.kuma 4016 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4017 
    """
4018 
    Get all return orders created between the from and to dates.
4019 
 
4020 
    Parameters:
4021 
     - onlyNotProcessed
4022 
     - fromDate
4023 
     - toDate
4024 
    """
4025 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4026 
    return self.recv_getAllReturnOrders()
4027 
 
4028 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4029 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4030 
    args = getAllReturnOrders_args()
4031 
    args.onlyNotProcessed = onlyNotProcessed
4032 
    args.fromDate = fromDate
4033 
    args.toDate = toDate
4034 
    args.write(self._oprot)
4035 
    self._oprot.writeMessageEnd()
4036 
    self._oprot.trans.flush()
4037 
 
4038 
  def recv_getAllReturnOrders(self, ):
4039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4040 
    if mtype == TMessageType.EXCEPTION:
4041 
      x = TApplicationException()
4042 
      x.read(self._iprot)
4043 
      self._iprot.readMessageEnd()
4044 
      raise x
4045 
    result = getAllReturnOrders_result()
4046 
    result.read(self._iprot)
4047 
    self._iprot.readMessageEnd()
4048 
    if result.success is not None:
4049 
      return result.success
4050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4051 
 
2700 chandransh 4052 
  def getReturnOrder(self, id):
4053 
    """
4054 
    Returns the ReturnOrder corresponding to the given id.
4055 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4056 
 
2700 chandransh 4057 
    Parameters:
4058 
     - id
4059 
    """
4060 
    self.send_getReturnOrder(id)
4061 
    return self.recv_getReturnOrder()
4062 
 
4063 
  def send_getReturnOrder(self, id):
4064 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4065 
    args = getReturnOrder_args()
4066 
    args.id = id
4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_getReturnOrder(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = getReturnOrder_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
3431 rajveer 4081 
    if result.success is not None:
2700 chandransh 4082 
      return result.success
3431 rajveer 4083 
    if result.ex is not None:
2700 chandransh 4084 
      raise result.ex
4085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4086 
 
2690 chandransh 4087 
  def processReturn(self, returnOrderId):
4088 
    """
4089 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4090 
 
2690 chandransh 4091 
    Parameters:
4092 
     - returnOrderId
4093 
    """
4094 
    self.send_processReturn(returnOrderId)
4095 
    self.recv_processReturn()
4096 
 
4097 
  def send_processReturn(self, returnOrderId):
4098 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4099 
    args = processReturn_args()
4100 
    args.returnOrderId = returnOrderId
4101 
    args.write(self._oprot)
4102 
    self._oprot.writeMessageEnd()
4103 
    self._oprot.trans.flush()
4104 
 
4105 
  def recv_processReturn(self, ):
4106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4107 
    if mtype == TMessageType.EXCEPTION:
4108 
      x = TApplicationException()
4109 
      x.read(self._iprot)
4110 
      self._iprot.readMessageEnd()
4111 
      raise x
4112 
    result = processReturn_result()
4113 
    result.read(self._iprot)
4114 
    self._iprot.readMessageEnd()
3431 rajveer 4115 
    if result.ex is not None:
2690 chandransh 4116 
      raise result.ex
4117 
    return
4118 
 
3451 chandransh 4119 
  def updateWeight(self, orderId, weight):
4120 
    """
4121 
    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 4122 
 
3451 chandransh 4123 
    Parameters:
4124 
     - orderId
4125 
     - weight
4126 
    """
4127 
    self.send_updateWeight(orderId, weight)
4128 
    return self.recv_updateWeight()
4129 
 
4130 
  def send_updateWeight(self, orderId, weight):
4131 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4132 
    args = updateWeight_args()
4133 
    args.orderId = orderId
4134 
    args.weight = weight
4135 
    args.write(self._oprot)
4136 
    self._oprot.writeMessageEnd()
4137 
    self._oprot.trans.flush()
4138 
 
4139 
  def recv_updateWeight(self, ):
4140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4141 
    if mtype == TMessageType.EXCEPTION:
4142 
      x = TApplicationException()
4143 
      x.read(self._iprot)
4144 
      self._iprot.readMessageEnd()
4145 
      raise x
4146 
    result = updateWeight_result()
4147 
    result.read(self._iprot)
4148 
    self._iprot.readMessageEnd()
4149 
    if result.success is not None:
4150 
      return result.success
4151 
    if result.ex is not None:
4152 
      raise result.ex
4153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4154 
 
3469 chandransh 4155 
  def changeItem(self, orderId, itemId):
4156 
    """
4157 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4158 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4159 
 
3469 chandransh 4160 
    Parameters:
4161 
     - orderId
4162 
     - itemId
4163 
    """
4164 
    self.send_changeItem(orderId, itemId)
4165 
    return self.recv_changeItem()
4166 
 
4167 
  def send_changeItem(self, orderId, itemId):
4168 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4169 
    args = changeItem_args()
4170 
    args.orderId = orderId
4171 
    args.itemId = itemId
4172 
    args.write(self._oprot)
4173 
    self._oprot.writeMessageEnd()
4174 
    self._oprot.trans.flush()
4175 
 
4176 
  def recv_changeItem(self, ):
4177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4178 
    if mtype == TMessageType.EXCEPTION:
4179 
      x = TApplicationException()
4180 
      x.read(self._iprot)
4181 
      self._iprot.readMessageEnd()
4182 
      raise x
4183 
    result = changeItem_result()
4184 
    result.read(self._iprot)
4185 
    self._iprot.readMessageEnd()
4186 
    if result.success is not None:
4187 
      return result.success
4188 
    if result.ex is not None:
4189 
      raise result.ex
4190 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4191 
 
4192 
  def shiftToWarehouse(self, orderId, warehouseId):
4193 
    """
4194 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4195 
 
4196 
    Parameters:
4197 
     - orderId
4198 
     - warehouseId
4199 
    """
4200 
    self.send_shiftToWarehouse(orderId, warehouseId)
4201 
    return self.recv_shiftToWarehouse()
4202 
 
4203 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4204 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4205 
    args = shiftToWarehouse_args()
4206 
    args.orderId = orderId
4207 
    args.warehouseId = warehouseId
4208 
    args.write(self._oprot)
4209 
    self._oprot.writeMessageEnd()
4210 
    self._oprot.trans.flush()
4211 
 
4212 
  def recv_shiftToWarehouse(self, ):
4213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4214 
    if mtype == TMessageType.EXCEPTION:
4215 
      x = TApplicationException()
4216 
      x.read(self._iprot)
4217 
      self._iprot.readMessageEnd()
4218 
      raise x
4219 
    result = shiftToWarehouse_result()
4220 
    result.read(self._iprot)
4221 
    self._iprot.readMessageEnd()
4222 
    if result.success is not None:
4223 
      return result.success
4224 
    if result.ex is not None:
4225 
      raise result.ex
4226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4227 
 
4647 rajveer 4228 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4229 
    """
4230 
    Adds the given delay reason to the given order.
3986 chandransh 4231 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4232 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4233 
 
3553 chandransh 4234 
    Parameters:
4235 
     - orderId
4236 
     - delayReason
3986 chandransh 4237 
     - furtherDelay
4647 rajveer 4238 
     - delayReasonText
3553 chandransh 4239 
    """
4647 rajveer 4240 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4241 
    return self.recv_addDelayReason()
4242 
 
4647 rajveer 4243 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4244 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4245 
    args = addDelayReason_args()
4246 
    args.orderId = orderId
4247 
    args.delayReason = delayReason
3986 chandransh 4248 
    args.furtherDelay = furtherDelay
4647 rajveer 4249 
    args.delayReasonText = delayReasonText
3553 chandransh 4250 
    args.write(self._oprot)
4251 
    self._oprot.writeMessageEnd()
4252 
    self._oprot.trans.flush()
4253 
 
4254 
  def recv_addDelayReason(self, ):
4255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4256 
    if mtype == TMessageType.EXCEPTION:
4257 
      x = TApplicationException()
4258 
      x.read(self._iprot)
4259 
      self._iprot.readMessageEnd()
4260 
      raise x
4261 
    result = addDelayReason_result()
4262 
    result.read(self._iprot)
4263 
    self._iprot.readMessageEnd()
4264 
    if result.success is not None:
4265 
      return result.success
4266 
    if result.ex is not None:
4267 
      raise result.ex
4268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4269 
 
3956 chandransh 4270 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4271 
    """
4272 
    Marks the COD orders with given AWB nos. as having been processed.
4273 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4274 
 
3956 chandransh 4275 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4276 
    1. There is no order corresponding to an AWB number.
4277 
    2. The captured amount for a payment exceeds the total payment.
4278 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4279 
 
4280 
    Parameters:
4281 
     - collectedAmountMap
4282 
     - xferBy
4283 
     - xferTxnId
4284 
     - xferDate
4285 
    """
4286 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4287 
    return self.recv_reconcileCodCollection()
4288 
 
4289 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4290 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4291 
    args = reconcileCodCollection_args()
4292 
    args.collectedAmountMap = collectedAmountMap
4293 
    args.xferBy = xferBy
4294 
    args.xferTxnId = xferTxnId
4295 
    args.xferDate = xferDate
4296 
    args.write(self._oprot)
4297 
    self._oprot.writeMessageEnd()
4298 
    self._oprot.trans.flush()
4299 
 
4300 
  def recv_reconcileCodCollection(self, ):
4301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4302 
    if mtype == TMessageType.EXCEPTION:
4303 
      x = TApplicationException()
4304 
      x.read(self._iprot)
4305 
      self._iprot.readMessageEnd()
4306 
      raise x
4307 
    result = reconcileCodCollection_result()
4308 
    result.read(self._iprot)
4309 
    self._iprot.readMessageEnd()
4310 
    if result.success is not None:
4311 
      return result.success
4312 
    if result.ex is not None:
4313 
      raise result.ex
4314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4315 
 
4008 mandeep.dh 4316 
  def getTransactionsRequiringExtraProcessing(self, category):
4317 
    """
4065 mandeep.dh 4318 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4319 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4320 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4321 
 
4008 mandeep.dh 4322 
    Parameters:
4323 
     - category
4324 
    """
4325 
    self.send_getTransactionsRequiringExtraProcessing(category)
4326 
    return self.recv_getTransactionsRequiringExtraProcessing()
4327 
 
4328 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4329 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4330 
    args = getTransactionsRequiringExtraProcessing_args()
4331 
    args.category = category
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = getTransactionsRequiringExtraProcessing_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.success is not None:
4347 
      return result.success
4348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4349 
 
4350 
  def markTransactionAsProcessed(self, transactionId, category):
4351 
    """
4352 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4353 
    It essentially deletes the transaction id record for a particular
4354 
    processing type category (if present) from DB.
4355 
    This is currently used by CRM application.
4008 mandeep.dh 4356 
 
4357 
    Parameters:
4358 
     - transactionId
4359 
     - category
4360 
    """
4361 
    self.send_markTransactionAsProcessed(transactionId, category)
4362 
    self.recv_markTransactionAsProcessed()
4363 
 
4364 
  def send_markTransactionAsProcessed(self, transactionId, category):
4365 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4366 
    args = markTransactionAsProcessed_args()
4367 
    args.transactionId = transactionId
4368 
    args.category = category
4369 
    args.write(self._oprot)
4370 
    self._oprot.writeMessageEnd()
4371 
    self._oprot.trans.flush()
4372 
 
4373 
  def recv_markTransactionAsProcessed(self, ):
4374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4375 
    if mtype == TMessageType.EXCEPTION:
4376 
      x = TApplicationException()
4377 
      x.read(self._iprot)
4378 
      self._iprot.readMessageEnd()
4379 
      raise x
4380 
    result = markTransactionAsProcessed_result()
4381 
    result.read(self._iprot)
4382 
    self._iprot.readMessageEnd()
4383 
    return
4384 
 
4018 chandransh 4385 
  def getItemWiseRiskyOrdersCount(self, ):
4386 
    """
4387 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4388 
    is defined as one whose shipping date is about to expire.
4389 
    """
4390 
    self.send_getItemWiseRiskyOrdersCount()
4391 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4392 
 
4018 chandransh 4393 
  def send_getItemWiseRiskyOrdersCount(self, ):
4394 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4395 
    args = getItemWiseRiskyOrdersCount_args()
4396 
    args.write(self._oprot)
4397 
    self._oprot.writeMessageEnd()
4398 
    self._oprot.trans.flush()
4399 
 
4400 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4402 
    if mtype == TMessageType.EXCEPTION:
4403 
      x = TApplicationException()
4404 
      x.read(self._iprot)
4405 
      self._iprot.readMessageEnd()
4406 
      raise x
4407 
    result = getItemWiseRiskyOrdersCount_result()
4408 
    result.read(self._iprot)
4409 
    self._iprot.readMessageEnd()
4410 
    if result.success is not None:
4411 
      return result.success
4412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4413 
 
4295 varun.gupt 4414 
  def getOrdersForItemIds(self, itemIds):
4415 
    """
4416 
    Returns a list of all orders which have items with given id
4417 
 
4418 
    Parameters:
4419 
     - itemIds
4420 
    """
4421 
    self.send_getOrdersForItemIds(itemIds)
4422 
    return self.recv_getOrdersForItemIds()
4423 
 
4424 
  def send_getOrdersForItemIds(self, itemIds):
4425 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4426 
    args = getOrdersForItemIds_args()
4427 
    args.itemIds = itemIds
4428 
    args.write(self._oprot)
4429 
    self._oprot.writeMessageEnd()
4430 
    self._oprot.trans.flush()
4431 
 
4432 
  def recv_getOrdersForItemIds(self, ):
4433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4434 
    if mtype == TMessageType.EXCEPTION:
4435 
      x = TApplicationException()
4436 
      x.read(self._iprot)
4437 
      self._iprot.readMessageEnd()
4438 
      raise x
4439 
    result = getOrdersForItemIds_result()
4440 
    result.read(self._iprot)
4441 
    self._iprot.readMessageEnd()
4442 
    if result.success is not None:
4443 
      return result.success
4444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4445 
 
4247 rajveer 4446 
  def markOrderCancellationRequestReceived(self, orderId):
4447 
    """
4448 
    Mark order as cancellation request received. If customer sends request of cancellation of
4449 
    a particular order, this method will be called. It will just change status of the order
4450 
    depending on its current status. It also records the previous status, so that we can move
4451 
    back to that status if cancellation request is denied.
4018 chandransh 4452 
 
4247 rajveer 4453 
    Parameters:
4454 
     - orderId
4455 
    """
4456 
    self.send_markOrderCancellationRequestReceived(orderId)
4457 
    self.recv_markOrderCancellationRequestReceived()
4458 
 
4459 
  def send_markOrderCancellationRequestReceived(self, orderId):
4460 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4461 
    args = markOrderCancellationRequestReceived_args()
4462 
    args.orderId = orderId
4463 
    args.write(self._oprot)
4464 
    self._oprot.writeMessageEnd()
4465 
    self._oprot.trans.flush()
4466 
 
4467 
  def recv_markOrderCancellationRequestReceived(self, ):
4468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4469 
    if mtype == TMessageType.EXCEPTION:
4470 
      x = TApplicationException()
4471 
      x.read(self._iprot)
4472 
      self._iprot.readMessageEnd()
4473 
      raise x
4474 
    result = markOrderCancellationRequestReceived_result()
4475 
    result.read(self._iprot)
4476 
    self._iprot.readMessageEnd()
4477 
    if result.ex is not None:
4478 
      raise result.ex
4479 
    return
4480 
 
4481 
  def markOrderCancellationRequestConfirmed(self, orderId):
4482 
    """
4483 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4484 
    cancellation request confirmed. After this OM will be able to cancel the order.
4485 
 
4486 
    Parameters:
4487 
     - orderId
4488 
    """
4489 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4490 
    self.recv_markOrderCancellationRequestConfirmed()
4491 
 
4492 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4493 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4494 
    args = markOrderCancellationRequestConfirmed_args()
4495 
    args.orderId = orderId
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = markOrderCancellationRequestConfirmed_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.ex is not None:
4511 
      raise result.ex
4512 
    return
4513 
 
4514 
  def markOrderCancellationRequestDenied(self, orderId):
4515 
    """
4516 
    If we decide to not to cancel order, we will move the order ro previous status.
4517 
 
4518 
    Parameters:
4519 
     - orderId
4520 
    """
4521 
    self.send_markOrderCancellationRequestDenied(orderId)
4522 
    self.recv_markOrderCancellationRequestDenied()
4523 
 
4524 
  def send_markOrderCancellationRequestDenied(self, orderId):
4525 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4526 
    args = markOrderCancellationRequestDenied_args()
4527 
    args.orderId = orderId
4528 
    args.write(self._oprot)
4529 
    self._oprot.writeMessageEnd()
4530 
    self._oprot.trans.flush()
4531 
 
4532 
  def recv_markOrderCancellationRequestDenied(self, ):
4533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4534 
    if mtype == TMessageType.EXCEPTION:
4535 
      x = TApplicationException()
4536 
      x.read(self._iprot)
4537 
      self._iprot.readMessageEnd()
4538 
      raise x
4539 
    result = markOrderCancellationRequestDenied_result()
4540 
    result.read(self._iprot)
4541 
    self._iprot.readMessageEnd()
4542 
    if result.ex is not None:
4543 
      raise result.ex
4544 
    return
4545 
 
4258 rajveer 4546 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4547 
    """
4258 rajveer 4548 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4549 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4550 
 
4551 
    Parameters:
4258 rajveer 4552 
     - transactionId
4247 rajveer 4553 
    """
4258 rajveer 4554 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4555 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4556 
 
4258 rajveer 4557 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4558 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4559 
    args = markTransactionAsPaymentFlagRemoved_args()
4560 
    args.transactionId = transactionId
4247 rajveer 4561 
    args.write(self._oprot)
4562 
    self._oprot.writeMessageEnd()
4563 
    self._oprot.trans.flush()
4564 
 
4258 rajveer 4565 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4567 
    if mtype == TMessageType.EXCEPTION:
4568 
      x = TApplicationException()
4569 
      x.read(self._iprot)
4570 
      self._iprot.readMessageEnd()
4571 
      raise x
4258 rajveer 4572 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4573 
    result.read(self._iprot)
4574 
    self._iprot.readMessageEnd()
4575 
    if result.ex is not None:
4576 
      raise result.ex
4577 
    return
4578 
 
4259 anupam.sin 4579 
  def refundTransaction(self, transactionId, refundedBy, reason):
4580 
    """
4581 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4582 
    need to be cancelled
4247 rajveer 4583 
 
4259 anupam.sin 4584 
    Parameters:
4585 
     - transactionId
4586 
     - refundedBy
4587 
     - reason
4588 
    """
4589 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4590 
    self.recv_refundTransaction()
4591 
 
4592 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4593 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4594 
    args = refundTransaction_args()
4595 
    args.transactionId = transactionId
4596 
    args.refundedBy = refundedBy
4597 
    args.reason = reason
4598 
    args.write(self._oprot)
4599 
    self._oprot.writeMessageEnd()
4600 
    self._oprot.trans.flush()
4601 
 
4602 
  def recv_refundTransaction(self, ):
4603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4604 
    if mtype == TMessageType.EXCEPTION:
4605 
      x = TApplicationException()
4606 
      x.read(self._iprot)
4607 
      self._iprot.readMessageEnd()
4608 
      raise x
4609 
    result = refundTransaction_result()
4610 
    result.read(self._iprot)
4611 
    self._iprot.readMessageEnd()
4612 
    if result.ex is not None:
4613 
      raise result.ex
4614 
    return
4615 
 
4324 mandeep.dh 4616 
  def updateShipmentAddress(self, orderId, addressId):
4617 
    """
4618 
    Updates shipment address of an order. Delivery and shipping date estimates
4619 
    etc. are also updated here.
4620 
 
4621 
    Throws TransactionServiceException in case address change is not
4622 
    possible due to certain reasons such as new pincode in address is
4623 
    not serviceable etc.
4624 
 
4625 
    Parameters:
4626 
     - orderId
4627 
     - addressId
4628 
    """
4629 
    self.send_updateShipmentAddress(orderId, addressId)
4630 
    self.recv_updateShipmentAddress()
4631 
 
4632 
  def send_updateShipmentAddress(self, orderId, addressId):
4633 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4634 
    args = updateShipmentAddress_args()
4635 
    args.orderId = orderId
4636 
    args.addressId = addressId
4637 
    args.write(self._oprot)
4638 
    self._oprot.writeMessageEnd()
4639 
    self._oprot.trans.flush()
4640 
 
4641 
  def recv_updateShipmentAddress(self, ):
4642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4643 
    if mtype == TMessageType.EXCEPTION:
4644 
      x = TApplicationException()
4645 
      x.read(self._iprot)
4646 
      self._iprot.readMessageEnd()
4647 
      raise x
4648 
    result = updateShipmentAddress_result()
4649 
    result.read(self._iprot)
4650 
    self._iprot.readMessageEnd()
4651 
    if result.ex is not None:
4652 
      raise result.ex
4653 
    return
4654 
 
4285 rajveer 4655 
  def acceptOrdersForItemId(self, itemId, inventory):
4656 
    """
4657 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4658 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4659 
 
4285 rajveer 4660 
    Parameters:
4661 
     - itemId
4662 
     - inventory
4663 
    """
4664 
    self.send_acceptOrdersForItemId(itemId, inventory)
4665 
    return self.recv_acceptOrdersForItemId()
4666 
 
4667 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4668 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4669 
    args = acceptOrdersForItemId_args()
4670 
    args.itemId = itemId
4671 
    args.inventory = inventory
4672 
    args.write(self._oprot)
4673 
    self._oprot.writeMessageEnd()
4674 
    self._oprot.trans.flush()
4675 
 
4676 
  def recv_acceptOrdersForItemId(self, ):
4677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4678 
    if mtype == TMessageType.EXCEPTION:
4679 
      x = TApplicationException()
4680 
      x.read(self._iprot)
4681 
      self._iprot.readMessageEnd()
4682 
      raise x
4683 
    result = acceptOrdersForItemId_result()
4684 
    result.read(self._iprot)
4685 
    self._iprot.readMessageEnd()
4686 
    if result.success is not None:
4687 
      return result.success
4688 
    if result.ex is not None:
4689 
      raise result.ex
4690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4691 
 
4369 rajveer 4692 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4693 
    """
4694 
    Parameters:
4695 
     - vendorId
4696 
     - itemId
4697 
     - quantity
4698 
     - estimate
4369 rajveer 4699 
     - isReminder
4303 rajveer 4700 
    """
4369 rajveer 4701 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4702 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4703 
 
4369 rajveer 4704 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4705 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4706 
    args = markOrdersAsPORaised_args()
4707 
    args.vendorId = vendorId
4708 
    args.itemId = itemId
4709 
    args.quantity = quantity
4710 
    args.estimate = estimate
4369 rajveer 4711 
    args.isReminder = isReminder
4303 rajveer 4712 
    args.write(self._oprot)
4713 
    self._oprot.writeMessageEnd()
4714 
    self._oprot.trans.flush()
4715 
 
4716 
  def recv_markOrdersAsPORaised(self, ):
4717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4718 
    if mtype == TMessageType.EXCEPTION:
4719 
      x = TApplicationException()
4720 
      x.read(self._iprot)
4721 
      self._iprot.readMessageEnd()
4722 
      raise x
4723 
    result = markOrdersAsPORaised_result()
4724 
    result.read(self._iprot)
4725 
    self._iprot.readMessageEnd()
4726 
    if result.ex is not None:
4727 
      raise result.ex
4728 
    return
4729 
 
4369 rajveer 4730 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4731 
    """
4732 
    Parameters:
4733 
     - vendorId
4734 
     - itemId
4735 
     - quantity
4736 
     - estimate
4369 rajveer 4737 
     - isReminder
4303 rajveer 4738 
    """
4369 rajveer 4739 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4740 
    self.recv_markOrdersAsReversalInitiated()
4741 
 
4369 rajveer 4742 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4743 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4744 
    args = markOrdersAsReversalInitiated_args()
4745 
    args.vendorId = vendorId
4746 
    args.itemId = itemId
4747 
    args.quantity = quantity
4748 
    args.estimate = estimate
4369 rajveer 4749 
    args.isReminder = isReminder
4303 rajveer 4750 
    args.write(self._oprot)
4751 
    self._oprot.writeMessageEnd()
4752 
    self._oprot.trans.flush()
4753 
 
4754 
  def recv_markOrdersAsReversalInitiated(self, ):
4755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4756 
    if mtype == TMessageType.EXCEPTION:
4757 
      x = TApplicationException()
4758 
      x.read(self._iprot)
4759 
      self._iprot.readMessageEnd()
4760 
      raise x
4761 
    result = markOrdersAsReversalInitiated_result()
4762 
    result.read(self._iprot)
4763 
    self._iprot.readMessageEnd()
4764 
    if result.ex is not None:
4765 
      raise result.ex
4766 
    return
4767 
 
4369 rajveer 4768 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4769 
    """
4770 
    Parameters:
4771 
     - vendorId
4772 
     - itemId
4773 
     - quantity
4774 
     - estimate
4369 rajveer 4775 
     - isReminder
4303 rajveer 4776 
    """
4369 rajveer 4777 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4778 
    self.recv_markOrdersAsNotAvailabke()
4779 
 
4369 rajveer 4780 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4781 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4782 
    args = markOrdersAsNotAvailabke_args()
4783 
    args.vendorId = vendorId
4784 
    args.itemId = itemId
4785 
    args.quantity = quantity
4786 
    args.estimate = estimate
4369 rajveer 4787 
    args.isReminder = isReminder
4303 rajveer 4788 
    args.write(self._oprot)
4789 
    self._oprot.writeMessageEnd()
4790 
    self._oprot.trans.flush()
4791 
 
4792 
  def recv_markOrdersAsNotAvailabke(self, ):
4793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4794 
    if mtype == TMessageType.EXCEPTION:
4795 
      x = TApplicationException()
4796 
      x.read(self._iprot)
4797 
      self._iprot.readMessageEnd()
4798 
      raise x
4799 
    result = markOrdersAsNotAvailabke_result()
4800 
    result.read(self._iprot)
4801 
    self._iprot.readMessageEnd()
4802 
    if result.ex is not None:
4803 
      raise result.ex
4804 
    return
4805 
 
4369 rajveer 4806 
  def markOrdersAsTimeout(self, vendorId):
4807 
    """
4808 
    Parameters:
4809 
     - vendorId
4810 
    """
4811 
    self.send_markOrdersAsTimeout(vendorId)
4812 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4813 
 
4369 rajveer 4814 
  def send_markOrdersAsTimeout(self, vendorId):
4815 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4816 
    args = markOrdersAsTimeout_args()
4817 
    args.vendorId = vendorId
4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_markOrdersAsTimeout(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = markOrdersAsTimeout_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.success is not None:
4833 
      return result.success
4834 
    if result.ex is not None:
4835 
      raise result.ex
4836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4837 
 
4662 rajveer 4838 
  def markOrderAsLostInTransit(self, orderId):
4839 
    """
4840 
    Mark order as LOST_IN_TRANSIT
4841 
 
4842 
    Parameters:
4843 
     - orderId
4844 
    """
4845 
    self.send_markOrderAsLostInTransit(orderId)
4846 
    return self.recv_markOrderAsLostInTransit()
4847 
 
4848 
  def send_markOrderAsLostInTransit(self, orderId):
4849 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4850 
    args = markOrderAsLostInTransit_args()
4851 
    args.orderId = orderId
4852 
    args.write(self._oprot)
4853 
    self._oprot.writeMessageEnd()
4854 
    self._oprot.trans.flush()
4855 
 
4856 
  def recv_markOrderAsLostInTransit(self, ):
4857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4858 
    if mtype == TMessageType.EXCEPTION:
4859 
      x = TApplicationException()
4860 
      x.read(self._iprot)
4861 
      self._iprot.readMessageEnd()
4862 
      raise x
4863 
    result = markOrderAsLostInTransit_result()
4864 
    result.read(self._iprot)
4865 
    self._iprot.readMessageEnd()
4866 
    if result.success is not None:
4867 
      return result.success
4868 
    if result.ex is not None:
4869 
      raise result.ex
4870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4871 
 
4386 anupam.sin 4872 
  def getOrderForAwb(self, awb):
4873 
    """
4874 
    Returns the order corresponding to an AWB number
4369 rajveer 4875 
 
4386 anupam.sin 4876 
    Parameters:
4877 
     - awb
4878 
    """
4879 
    self.send_getOrderForAwb(awb)
4880 
    return self.recv_getOrderForAwb()
4881 
 
4882 
  def send_getOrderForAwb(self, awb):
4883 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4884 
    args = getOrderForAwb_args()
4885 
    args.awb = awb
4886 
    args.write(self._oprot)
4887 
    self._oprot.writeMessageEnd()
4888 
    self._oprot.trans.flush()
4889 
 
4890 
  def recv_getOrderForAwb(self, ):
4891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4892 
    if mtype == TMessageType.EXCEPTION:
4893 
      x = TApplicationException()
4894 
      x.read(self._iprot)
4895 
      self._iprot.readMessageEnd()
4896 
      raise x
4897 
    result = getOrderForAwb_result()
4898 
    result.read(self._iprot)
4899 
    self._iprot.readMessageEnd()
4900 
    if result.success is not None:
4901 
      return result.success
4902 
    if result.ex is not None:
4903 
      raise result.ex
4904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4905 
 
4910 phani.kuma 4906 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4907 
    """
4910 phani.kuma 4908 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4909 
 
4506 phani.kuma 4910 
    Parameters:
4911 
     - logistics_provider_id
4910 phani.kuma 4912 
     - order_status_list
4506 phani.kuma 4913 
    """
4910 phani.kuma 4914 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4915 
    return self.recv_getOrdersForProviderForStatus()
4916 
 
4910 phani.kuma 4917 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4918 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4919 
    args = getOrdersForProviderForStatus_args()
4920 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4921 
    args.order_status_list = order_status_list
4506 phani.kuma 4922 
    args.write(self._oprot)
4923 
    self._oprot.writeMessageEnd()
4924 
    self._oprot.trans.flush()
4925 
 
4926 
  def recv_getOrdersForProviderForStatus(self, ):
4927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4928 
    if mtype == TMessageType.EXCEPTION:
4929 
      x = TApplicationException()
4930 
      x.read(self._iprot)
4931 
      self._iprot.readMessageEnd()
4932 
      raise x
4933 
    result = getOrdersForProviderForStatus_result()
4934 
    result.read(self._iprot)
4935 
    self._iprot.readMessageEnd()
4936 
    if result.success is not None:
4937 
      return result.success
4938 
    if result.ex is not None:
4939 
      raise result.ex
4940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4941 
 
4600 varun.gupt 4942 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4943 
    """
4944 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4945 
 
4600 varun.gupt 4946 
    Parameters:
4947 
     - vendorId
4948 
     - billingDateFrom
4949 
     - billingDateTo
4950 
    """
4951 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4952 
    return self.recv_getBilledOrdersForVendor()
4953 
 
4954 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4955 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4956 
    args = getBilledOrdersForVendor_args()
4957 
    args.vendorId = vendorId
4958 
    args.billingDateFrom = billingDateFrom
4959 
    args.billingDateTo = billingDateTo
4960 
    args.write(self._oprot)
4961 
    self._oprot.writeMessageEnd()
4962 
    self._oprot.trans.flush()
4963 
 
4964 
  def recv_getBilledOrdersForVendor(self, ):
4965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4966 
    if mtype == TMessageType.EXCEPTION:
4967 
      x = TApplicationException()
4968 
      x.read(self._iprot)
4969 
      self._iprot.readMessageEnd()
4970 
      raise x
4971 
    result = getBilledOrdersForVendor_result()
4972 
    result.read(self._iprot)
4973 
    self._iprot.readMessageEnd()
4974 
    if result.success is not None:
4975 
      return result.success
4976 
    if result.ex is not None:
4977 
      raise result.ex
4978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4979 
 
4607 rajveer 4980 
  def getSlippedSippingDateOrders(self, ):
4981 
    self.send_getSlippedSippingDateOrders()
4982 
    return self.recv_getSlippedSippingDateOrders()
4983 
 
4984 
  def send_getSlippedSippingDateOrders(self, ):
4985 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4986 
    args = getSlippedSippingDateOrders_args()
4987 
    args.write(self._oprot)
4988 
    self._oprot.writeMessageEnd()
4989 
    self._oprot.trans.flush()
4990 
 
4991 
  def recv_getSlippedSippingDateOrders(self, ):
4992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4993 
    if mtype == TMessageType.EXCEPTION:
4994 
      x = TApplicationException()
4995 
      x.read(self._iprot)
4996 
      self._iprot.readMessageEnd()
4997 
      raise x
4998 
    result = getSlippedSippingDateOrders_result()
4999 
    result.read(self._iprot)
5000 
    self._iprot.readMessageEnd()
5001 
    if result.success is not None:
5002 
      return result.success
5003 
    if result.ex is not None:
5004 
      raise result.ex
5005 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5006 
 
4709 rajveer 5007 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5008 
    """
5009 
    Parameters:
5010 
     - cancelDateFrom
5011 
     - cancelDateTo
5012 
    """
5013 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5014 
    return self.recv_getCancelledOrders()
5015 
 
5016 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5017 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5018 
    args = getCancelledOrders_args()
5019 
    args.cancelDateFrom = cancelDateFrom
5020 
    args.cancelDateTo = cancelDateTo
5021 
    args.write(self._oprot)
5022 
    self._oprot.writeMessageEnd()
5023 
    self._oprot.trans.flush()
5024 
 
5025 
  def recv_getCancelledOrders(self, ):
5026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5027 
    if mtype == TMessageType.EXCEPTION:
5028 
      x = TApplicationException()
5029 
      x.read(self._iprot)
5030 
      self._iprot.readMessageEnd()
5031 
      raise x
5032 
    result = getCancelledOrders_result()
5033 
    result.read(self._iprot)
5034 
    self._iprot.readMessageEnd()
5035 
    if result.success is not None:
5036 
      return result.success
5037 
    if result.ex is not None:
5038 
      raise result.ex
5039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5040 
 
4600 varun.gupt 5041 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5042 
    """
5043 
    Parameters:
5044 
     - mapAWBAndAmount
5045 
    """
5046 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5047 
    self.recv_saveBluedartSettlements()
5048 
 
5049 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5050 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5051 
    args = saveBluedartSettlements_args()
5052 
    args.mapAWBAndAmount = mapAWBAndAmount
5053 
    args.write(self._oprot)
5054 
    self._oprot.writeMessageEnd()
5055 
    self._oprot.trans.flush()
5056 
 
5057 
  def recv_saveBluedartSettlements(self, ):
5058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5059 
    if mtype == TMessageType.EXCEPTION:
5060 
      x = TApplicationException()
5061 
      x.read(self._iprot)
5062 
      self._iprot.readMessageEnd()
5063 
      raise x
5064 
    result = saveBluedartSettlements_result()
5065 
    result.read(self._iprot)
5066 
    self._iprot.readMessageEnd()
5067 
    if result.ex is not None:
5068 
      raise result.ex
5069 
    return
5070 
 
4905 varun.gupt 5071 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5072 
    """
5073 
    Parameters:
5074 
     - settlementDate
5075 
     - paymentGatewayId
4905 varun.gupt 5076 
     - referenceId
4600 varun.gupt 5077 
     - serviceTax
5078 
     - otherCharges
5079 
     - netCollection
5080 
    """
4905 varun.gupt 5081 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5082 
    self.recv_savePaymentSettlements()
5083 
 
4905 varun.gupt 5084 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5085 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5086 
    args = savePaymentSettlements_args()
5087 
    args.settlementDate = settlementDate
5088 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5089 
    args.referenceId = referenceId
4600 varun.gupt 5090 
    args.serviceTax = serviceTax
5091 
    args.otherCharges = otherCharges
5092 
    args.netCollection = netCollection
5093 
    args.write(self._oprot)
5094 
    self._oprot.writeMessageEnd()
5095 
    self._oprot.trans.flush()
5096 
 
5097 
  def recv_savePaymentSettlements(self, ):
5098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5099 
    if mtype == TMessageType.EXCEPTION:
5100 
      x = TApplicationException()
5101 
      x.read(self._iprot)
5102 
      self._iprot.readMessageEnd()
5103 
      raise x
5104 
    result = savePaymentSettlements_result()
5105 
    result.read(self._iprot)
5106 
    self._iprot.readMessageEnd()
5107 
    if result.ex is not None:
5108 
      raise result.ex
5109 
    return
5110 
 
5111 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5112 
    """
5113 
    Parameters:
5114 
     - settlementId
5115 
     - settlementDate
5116 
     - transactionDateFrom
5117 
     - transactionDateTo
5118 
     - amount
5119 
    """
5120 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5121 
    self.recv_saveEBSSettlementSummary()
5122 
 
5123 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5124 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5125 
    args = saveEBSSettlementSummary_args()
5126 
    args.settlementId = settlementId
5127 
    args.settlementDate = settlementDate
5128 
    args.transactionDateFrom = transactionDateFrom
5129 
    args.transactionDateTo = transactionDateTo
5130 
    args.amount = amount
5131 
    args.write(self._oprot)
5132 
    self._oprot.writeMessageEnd()
5133 
    self._oprot.trans.flush()
5134 
 
5135 
  def recv_saveEBSSettlementSummary(self, ):
5136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5137 
    if mtype == TMessageType.EXCEPTION:
5138 
      x = TApplicationException()
5139 
      x.read(self._iprot)
5140 
      self._iprot.readMessageEnd()
5141 
      raise x
5142 
    result = saveEBSSettlementSummary_result()
5143 
    result.read(self._iprot)
5144 
    self._iprot.readMessageEnd()
5145 
    if result.ex is not None:
5146 
      raise result.ex
5147 
    return
5148 
 
5386 phani.kuma 5149 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5150 
    """
5151 
    Parameters:
5189 varun.gupt 5152 
     - referenceId
5153 
     - isRefund
4600 varun.gupt 5154 
    """
5386 phani.kuma 5155 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5156 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5157 
 
5386 phani.kuma 5158 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5159 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5160 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5161 
    args.referenceId = referenceId
5162 
    args.isRefund = isRefund
4600 varun.gupt 5163 
    args.write(self._oprot)
5164 
    self._oprot.writeMessageEnd()
5165 
    self._oprot.trans.flush()
5166 
 
5386 phani.kuma 5167 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5169 
    if mtype == TMessageType.EXCEPTION:
5170 
      x = TApplicationException()
5171 
      x.read(self._iprot)
5172 
      self._iprot.readMessageEnd()
5173 
      raise x
5386 phani.kuma 5174 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5175 
    result.read(self._iprot)
5176 
    self._iprot.readMessageEnd()
5177 
    if result.success is not None:
5178 
      return result.success
5179 
    if result.ex is not None:
5180 
      raise result.ex
5386 phani.kuma 5181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5182 
 
5386 phani.kuma 5183 
  def getSettlementForCod(self, orderId, isRefund):
5184 
    """
5185 
    Parameters:
5186 
     - orderId
5187 
     - isRefund
5188 
    """
5189 
    self.send_getSettlementForCod(orderId, isRefund)
5190 
    return self.recv_getSettlementForCod()
5191 
 
5192 
  def send_getSettlementForCod(self, orderId, isRefund):
5193 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5194 
    args = getSettlementForCod_args()
5195 
    args.orderId = orderId
5196 
    args.isRefund = isRefund
5197 
    args.write(self._oprot)
5198 
    self._oprot.writeMessageEnd()
5199 
    self._oprot.trans.flush()
5200 
 
5201 
  def recv_getSettlementForCod(self, ):
5202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5203 
    if mtype == TMessageType.EXCEPTION:
5204 
      x = TApplicationException()
5205 
      x.read(self._iprot)
5206 
      self._iprot.readMessageEnd()
5207 
      raise x
5208 
    result = getSettlementForCod_result()
5209 
    result.read(self._iprot)
5210 
    self._iprot.readMessageEnd()
5211 
    if result.success is not None:
5212 
      return result.success
5213 
    if result.ex is not None:
5214 
      raise result.ex
5215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5216 
 
4600 varun.gupt 5217 
  def getEBSSettlementSummaries(self, ):
5218 
    self.send_getEBSSettlementSummaries()
5219 
    return self.recv_getEBSSettlementSummaries()
5220 
 
5221 
  def send_getEBSSettlementSummaries(self, ):
5222 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5223 
    args = getEBSSettlementSummaries_args()
5224 
    args.write(self._oprot)
5225 
    self._oprot.writeMessageEnd()
5226 
    self._oprot.trans.flush()
5227 
 
5228 
  def recv_getEBSSettlementSummaries(self, ):
5229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5230 
    if mtype == TMessageType.EXCEPTION:
5231 
      x = TApplicationException()
5232 
      x.read(self._iprot)
5233 
      self._iprot.readMessageEnd()
5234 
      raise x
5235 
    result = getEBSSettlementSummaries_result()
5236 
    result.read(self._iprot)
5237 
    self._iprot.readMessageEnd()
5238 
    if result.success is not None:
5239 
      return result.success
5240 
    if result.ex is not None:
5241 
      raise result.ex
5242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5243 
 
5244 
  def markEBSSettlementUploaded(self, settlementId):
5245 
    """
5246 
    Parameters:
5247 
     - settlementId
5248 
    """
5249 
    self.send_markEBSSettlementUploaded(settlementId)
5250 
    self.recv_markEBSSettlementUploaded()
5251 
 
5252 
  def send_markEBSSettlementUploaded(self, settlementId):
5253 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5254 
    args = markEBSSettlementUploaded_args()
5255 
    args.settlementId = settlementId
5256 
    args.write(self._oprot)
5257 
    self._oprot.writeMessageEnd()
5258 
    self._oprot.trans.flush()
5259 
 
5260 
  def recv_markEBSSettlementUploaded(self, ):
5261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5262 
    if mtype == TMessageType.EXCEPTION:
5263 
      x = TApplicationException()
5264 
      x.read(self._iprot)
5265 
      self._iprot.readMessageEnd()
5266 
      raise x
5267 
    result = markEBSSettlementUploaded_result()
5268 
    result.read(self._iprot)
5269 
    self._iprot.readMessageEnd()
5270 
    if result.ex is not None:
5271 
      raise result.ex
5272 
    return
5273 
 
5274 
  def getEBSSettlementDate(self, settlementId):
5275 
    """
5276 
    Parameters:
5277 
     - settlementId
5278 
    """
5279 
    self.send_getEBSSettlementDate(settlementId)
5280 
    return self.recv_getEBSSettlementDate()
5281 
 
5282 
  def send_getEBSSettlementDate(self, settlementId):
5283 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5284 
    args = getEBSSettlementDate_args()
5285 
    args.settlementId = settlementId
5286 
    args.write(self._oprot)
5287 
    self._oprot.writeMessageEnd()
5288 
    self._oprot.trans.flush()
5289 
 
5290 
  def recv_getEBSSettlementDate(self, ):
5291 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5292 
    if mtype == TMessageType.EXCEPTION:
5293 
      x = TApplicationException()
5294 
      x.read(self._iprot)
5295 
      self._iprot.readMessageEnd()
5296 
      raise x
5297 
    result = getEBSSettlementDate_result()
5298 
    result.read(self._iprot)
5299 
    self._iprot.readMessageEnd()
5300 
    if result.success is not None:
5301 
      return result.success
5302 
    if result.ex is not None:
5303 
      raise result.ex
5304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5305 
 
4715 varun.gupt 5306 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5307 
    """
5308 
    Parameters:
5309 
     - settlementDateFrom
5310 
     - settlementDateTo
5311 
     - isRefund
5312 
    """
5313 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5314 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5315 
 
4715 varun.gupt 5316 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5317 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5318 
    args = getSettlementsByDate_args()
5319 
    args.settlementDateFrom = settlementDateFrom
5320 
    args.settlementDateTo = settlementDateTo
5321 
    args.isRefund = isRefund
5322 
    args.write(self._oprot)
5323 
    self._oprot.writeMessageEnd()
5324 
    self._oprot.trans.flush()
5325 
 
5326 
  def recv_getSettlementsByDate(self, ):
5327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5328 
    if mtype == TMessageType.EXCEPTION:
5329 
      x = TApplicationException()
5330 
      x.read(self._iprot)
5331 
      self._iprot.readMessageEnd()
5332 
      raise x
5333 
    result = getSettlementsByDate_result()
5334 
    result.read(self._iprot)
5335 
    self._iprot.readMessageEnd()
5336 
    if result.success is not None:
5337 
      return result.success
5338 
    if result.ex is not None:
5339 
      raise result.ex
5340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5341 
 
5342 
  def getReshippedOrderIds(self, orderIds):
5343 
    """
5344 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5345 
 
5346 
    Parameters:
5347 
     - orderIds
5348 
    """
5349 
    self.send_getReshippedOrderIds(orderIds)
5350 
    return self.recv_getReshippedOrderIds()
5351 
 
5352 
  def send_getReshippedOrderIds(self, orderIds):
5353 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5354 
    args = getReshippedOrderIds_args()
5355 
    args.orderIds = orderIds
5356 
    args.write(self._oprot)
5357 
    self._oprot.writeMessageEnd()
5358 
    self._oprot.trans.flush()
5359 
 
5360 
  def recv_getReshippedOrderIds(self, ):
5361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5362 
    if mtype == TMessageType.EXCEPTION:
5363 
      x = TApplicationException()
5364 
      x.read(self._iprot)
5365 
      self._iprot.readMessageEnd()
5366 
      raise x
5367 
    result = getReshippedOrderIds_result()
5368 
    result.read(self._iprot)
5369 
    self._iprot.readMessageEnd()
5370 
    if result.success is not None:
5371 
      return result.success
5372 
    if result.ex is not None:
5373 
      raise result.ex
5374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5375 
 
5481 phani.kuma 5376 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5377 
    """
5378 
    Parameters:
5379 
     - vendorId
5481 phani.kuma 5380 
     - onlyVendorNotPaid
5381 
     - billingDateFrom
5382 
     - billingDateTo
4875 varun.gupt 5383 
    """
5481 phani.kuma 5384 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5385 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5386 
 
5481 phani.kuma 5387 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5388 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5389 
    args = getBilledOrders_args()
4875 varun.gupt 5390 
    args.vendorId = vendorId
5481 phani.kuma 5391 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5392 
    args.billingDateFrom = billingDateFrom
5393 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5394 
    args.write(self._oprot)
5395 
    self._oprot.writeMessageEnd()
5396 
    self._oprot.trans.flush()
5397 
 
5481 phani.kuma 5398 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5400 
    if mtype == TMessageType.EXCEPTION:
5401 
      x = TApplicationException()
5402 
      x.read(self._iprot)
5403 
      self._iprot.readMessageEnd()
5404 
      raise x
5481 phani.kuma 5405 
    result = getBilledOrders_result()
4875 varun.gupt 5406 
    result.read(self._iprot)
5407 
    self._iprot.readMessageEnd()
5408 
    if result.success is not None:
5409 
      return result.success
5410 
    if result.ex is not None:
5411 
      raise result.ex
5481 phani.kuma 5412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5413 
 
5031 varun.gupt 5414 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5415 
    """
5416 
    Parameters:
5417 
     - startDate
5418 
     - endDate
5419 
    """
5420 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5421 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5422 
 
5031 varun.gupt 5423 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5424 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5425 
    args = getStatusDistributionOfOrders_args()
5426 
    args.startDate = startDate
5427 
    args.endDate = endDate
5428 
    args.write(self._oprot)
5429 
    self._oprot.writeMessageEnd()
5430 
    self._oprot.trans.flush()
5431 
 
5432 
  def recv_getStatusDistributionOfOrders(self, ):
5433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5434 
    if mtype == TMessageType.EXCEPTION:
5435 
      x = TApplicationException()
5436 
      x.read(self._iprot)
5437 
      self._iprot.readMessageEnd()
5438 
      raise x
5439 
    result = getStatusDistributionOfOrders_result()
5440 
    result.read(self._iprot)
5441 
    self._iprot.readMessageEnd()
5442 
    if result.success is not None:
5443 
      return result.success
5444 
    if result.ex is not None:
5445 
      raise result.ex
5446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5447 
 
5067 varun.gupt 5448 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5449 
    """
5450 
    Parameters:
5451 
     - status
5452 
     - startDatetime
5453 
     - endDatetime
5454 
    """
5455 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5456 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5457 
 
5067 varun.gupt 5458 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5459 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5460 
    args = getOrderIdsForStatus_args()
5461 
    args.status = status
5462 
    args.startDatetime = startDatetime
5463 
    args.endDatetime = endDatetime
5464 
    args.write(self._oprot)
5465 
    self._oprot.writeMessageEnd()
5466 
    self._oprot.trans.flush()
5467 
 
5468 
  def recv_getOrderIdsForStatus(self, ):
5469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5470 
    if mtype == TMessageType.EXCEPTION:
5471 
      x = TApplicationException()
5472 
      x.read(self._iprot)
5473 
      self._iprot.readMessageEnd()
5474 
      raise x
5475 
    result = getOrderIdsForStatus_result()
5476 
    result.read(self._iprot)
5477 
    self._iprot.readMessageEnd()
5478 
    if result.success is not None:
5479 
      return result.success
5480 
    if result.ex is not None:
5481 
      raise result.ex
5482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5483 
 
5348 anupam.sin 5484 
  def updateCODAgent(self, agent, orderId):
5485 
    """
5486 
    Updates the agent who handled the COD verification call
5487 
 
5488 
    Parameters:
5489 
     - agent
5490 
     - orderId
5491 
    """
5492 
    self.send_updateCODAgent(agent, orderId)
5493 
    self.recv_updateCODAgent()
5494 
 
5495 
  def send_updateCODAgent(self, agent, orderId):
5496 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5497 
    args = updateCODAgent_args()
5498 
    args.agent = agent
5499 
    args.orderId = orderId
5500 
    args.write(self._oprot)
5501 
    self._oprot.writeMessageEnd()
5502 
    self._oprot.trans.flush()
5503 
 
5504 
  def recv_updateCODAgent(self, ):
5505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5506 
    if mtype == TMessageType.EXCEPTION:
5507 
      x = TApplicationException()
5508 
      x.read(self._iprot)
5509 
      self._iprot.readMessageEnd()
5510 
      raise x
5511 
    result = updateCODAgent_result()
5512 
    result.read(self._iprot)
5513 
    self._iprot.readMessageEnd()
5514 
    if result.ex is not None:
5515 
      raise result.ex
5516 
    return
5517 
 
5099 varun.gupt 5518 
  def updateOrderAsPaidToVendor(self, orderId):
5519 
    """
5520 
    Parameters:
5521 
     - orderId
5522 
    """
5523 
    self.send_updateOrderAsPaidToVendor(orderId)
5524 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5525 
 
5099 varun.gupt 5526 
  def send_updateOrderAsPaidToVendor(self, orderId):
5527 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5528 
    args = updateOrderAsPaidToVendor_args()
5529 
    args.orderId = orderId
5530 
    args.write(self._oprot)
5531 
    self._oprot.writeMessageEnd()
5532 
    self._oprot.trans.flush()
5533 
 
5534 
  def recv_updateOrderAsPaidToVendor(self, ):
5535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5536 
    if mtype == TMessageType.EXCEPTION:
5537 
      x = TApplicationException()
5538 
      x.read(self._iprot)
5539 
      self._iprot.readMessageEnd()
5540 
      raise x
5541 
    result = updateOrderAsPaidToVendor_result()
5542 
    result.read(self._iprot)
5543 
    self._iprot.readMessageEnd()
5544 
    if result.ex is not None:
5545 
      raise result.ex
5546 
    return
5547 
 
5386 phani.kuma 5548 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5549 
    """
5550 
    Parameters:
5551 
     - orderId
5552 
    """
5553 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5554 
    self.recv_updateOrderOnlyAsPaidToVendor()
5555 
 
5556 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5557 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5558 
    args = updateOrderOnlyAsPaidToVendor_args()
5559 
    args.orderId = orderId
5560 
    args.write(self._oprot)
5561 
    self._oprot.writeMessageEnd()
5562 
    self._oprot.trans.flush()
5563 
 
5564 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5565 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5566 
    if mtype == TMessageType.EXCEPTION:
5567 
      x = TApplicationException()
5568 
      x.read(self._iprot)
5569 
      self._iprot.readMessageEnd()
5570 
      raise x
5571 
    result = updateOrderOnlyAsPaidToVendor_result()
5572 
    result.read(self._iprot)
5573 
    self._iprot.readMessageEnd()
5574 
    if result.ex is not None:
5575 
      raise result.ex
5576 
    return
5577 
 
5208 varun.gupt 5578 
  def getRefundedOrdersMarkedPaid(self, ):
5579 
    self.send_getRefundedOrdersMarkedPaid()
5580 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5581 
 
5208 varun.gupt 5582 
  def send_getRefundedOrdersMarkedPaid(self, ):
5583 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5584 
    args = getRefundedOrdersMarkedPaid_args()
5585 
    args.write(self._oprot)
5586 
    self._oprot.writeMessageEnd()
5587 
    self._oprot.trans.flush()
5588 
 
5589 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5591 
    if mtype == TMessageType.EXCEPTION:
5592 
      x = TApplicationException()
5593 
      x.read(self._iprot)
5594 
      self._iprot.readMessageEnd()
5595 
      raise x
5596 
    result = getRefundedOrdersMarkedPaid_result()
5597 
    result.read(self._iprot)
5598 
    self._iprot.readMessageEnd()
5599 
    if result.success is not None:
5600 
      return result.success
5601 
    if result.ex is not None:
5602 
      raise result.ex
5603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5604 
 
5447 anupam.sin 5605 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5606 
    """
5607 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5608 
 
5447 anupam.sin 5609 
 
5610 
    Parameters:
5611 
     - minOrderId
5612 
     - maxOrderId
5613 
    """
5614 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5615 
    return self.recv_getAllVerificationAgents()
5616 
 
5617 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5618 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5619 
    args = getAllVerificationAgents_args()
5620 
    args.minOrderId = minOrderId
5621 
    args.maxOrderId = maxOrderId
5622 
    args.write(self._oprot)
5623 
    self._oprot.writeMessageEnd()
5624 
    self._oprot.trans.flush()
5625 
 
5626 
  def recv_getAllVerificationAgents(self, ):
5627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5628 
    if mtype == TMessageType.EXCEPTION:
5629 
      x = TApplicationException()
5630 
      x.read(self._iprot)
5631 
      self._iprot.readMessageEnd()
5632 
      raise x
5633 
    result = getAllVerificationAgents_result()
5634 
    result.read(self._iprot)
5635 
    self._iprot.readMessageEnd()
5636 
    if result.success is not None:
5637 
      return result.success
5638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5639 
 
5527 anupam.sin 5640 
  def getAllAttributesForOrderId(self, orderId):
5641 
    """
5642 
    gets all attributes for a given orderId
5447 anupam.sin 5643 
 
5527 anupam.sin 5644 
    Parameters:
5645 
     - orderId
5646 
    """
5647 
    self.send_getAllAttributesForOrderId(orderId)
5648 
    return self.recv_getAllAttributesForOrderId()
5649 
 
5650 
  def send_getAllAttributesForOrderId(self, orderId):
5651 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5652 
    args = getAllAttributesForOrderId_args()
5653 
    args.orderId = orderId
5654 
    args.write(self._oprot)
5655 
    self._oprot.writeMessageEnd()
5656 
    self._oprot.trans.flush()
5657 
 
5658 
  def recv_getAllAttributesForOrderId(self, ):
5659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5660 
    if mtype == TMessageType.EXCEPTION:
5661 
      x = TApplicationException()
5662 
      x.read(self._iprot)
5663 
      self._iprot.readMessageEnd()
5664 
      raise x
5665 
    result = getAllAttributesForOrderId_result()
5666 
    result.read(self._iprot)
5667 
    self._iprot.readMessageEnd()
5668 
    if result.success is not None:
5669 
      return result.success
5670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5671 
 
5676 rajveer 5672 
  def setOrderAttributes(self, orderId, attributes):
5673 
    """
5674 
    sets attributes for an order
5675 
 
5676 
    Parameters:
5677 
     - orderId
5678 
     - attributes
5679 
    """
5680 
    self.send_setOrderAttributes(orderId, attributes)
5681 
    self.recv_setOrderAttributes()
5682 
 
5683 
  def send_setOrderAttributes(self, orderId, attributes):
5684 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5685 
    args = setOrderAttributes_args()
5686 
    args.orderId = orderId
5687 
    args.attributes = attributes
5688 
    args.write(self._oprot)
5689 
    self._oprot.writeMessageEnd()
5690 
    self._oprot.trans.flush()
5691 
 
5692 
  def recv_setOrderAttributes(self, ):
5693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5694 
    if mtype == TMessageType.EXCEPTION:
5695 
      x = TApplicationException()
5696 
      x.read(self._iprot)
5697 
      self._iprot.readMessageEnd()
5698 
      raise x
5699 
    result = setOrderAttributes_result()
5700 
    result.read(self._iprot)
5701 
    self._iprot.readMessageEnd()
5702 
    return
5703 
 
5527 anupam.sin 5704 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5705 
    """
5706 
    sets attributes for all orders in a transaction
5707 
 
5708 
    Parameters:
5709 
     - transactionId
5710 
     - attribute
5711 
    """
5712 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5713 
    self.recv_setOrderAttributeForTransaction()
5714 
 
5715 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5716 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5717 
    args = setOrderAttributeForTransaction_args()
5718 
    args.transactionId = transactionId
5719 
    args.attribute = attribute
5720 
    args.write(self._oprot)
5721 
    self._oprot.writeMessageEnd()
5722 
    self._oprot.trans.flush()
5723 
 
5724 
  def recv_setOrderAttributeForTransaction(self, ):
5725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5726 
    if mtype == TMessageType.EXCEPTION:
5727 
      x = TApplicationException()
5728 
      x.read(self._iprot)
5729 
      self._iprot.readMessageEnd()
5730 
      raise x
5731 
    result = setOrderAttributeForTransaction_result()
5732 
    result.read(self._iprot)
5733 
    self._iprot.readMessageEnd()
5734 
    return
5735 
 
5553 rajveer 5736 
  def getReceivePendingOrders(self, storeId):
5737 
    """
5738 
    Parameters:
5739 
     - storeId
5740 
    """
5741 
    self.send_getReceivePendingOrders(storeId)
5742 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5743 
 
5553 rajveer 5744 
  def send_getReceivePendingOrders(self, storeId):
5745 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5746 
    args = getReceivePendingOrders_args()
5747 
    args.storeId = storeId
5748 
    args.write(self._oprot)
5749 
    self._oprot.writeMessageEnd()
5750 
    self._oprot.trans.flush()
5751 
 
5752 
  def recv_getReceivePendingOrders(self, ):
5753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5754 
    if mtype == TMessageType.EXCEPTION:
5755 
      x = TApplicationException()
5756 
      x.read(self._iprot)
5757 
      self._iprot.readMessageEnd()
5758 
      raise x
5759 
    result = getReceivePendingOrders_result()
5760 
    result.read(self._iprot)
5761 
    self._iprot.readMessageEnd()
5762 
    if result.success is not None:
5763 
      return result.success
5764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5765 
 
5766 
  def getReceivedAtStoreOrders(self, storeId):
5767 
    """
5768 
    Parameters:
5769 
     - storeId
5770 
    """
5771 
    self.send_getReceivedAtStoreOrders(storeId)
5772 
    return self.recv_getReceivedAtStoreOrders()
5773 
 
5774 
  def send_getReceivedAtStoreOrders(self, storeId):
5775 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5776 
    args = getReceivedAtStoreOrders_args()
5777 
    args.storeId = storeId
5778 
    args.write(self._oprot)
5779 
    self._oprot.writeMessageEnd()
5780 
    self._oprot.trans.flush()
5781 
 
5782 
  def recv_getReceivedAtStoreOrders(self, ):
5783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5784 
    if mtype == TMessageType.EXCEPTION:
5785 
      x = TApplicationException()
5786 
      x.read(self._iprot)
5787 
      self._iprot.readMessageEnd()
5788 
      raise x
5789 
    result = getReceivedAtStoreOrders_result()
5790 
    result.read(self._iprot)
5791 
    self._iprot.readMessageEnd()
5792 
    if result.success is not None:
5793 
      return result.success
5794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5795 
 
5713 rajveer 5796 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5797 
    """
5798 
    Parameters:
5799 
     - storeId
5800 
     - fromDate
5801 
     - toDate
5802 
     - onlyCod
5803 
    """
5804 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5805 
    return self.recv_getOrdersCollectionAtStore()
5806 
 
5807 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5808 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5809 
    args = getOrdersCollectionAtStore_args()
5810 
    args.storeId = storeId
5811 
    args.fromDate = fromDate
5812 
    args.toDate = toDate
5813 
    args.onlyCod = onlyCod
5814 
    args.write(self._oprot)
5815 
    self._oprot.writeMessageEnd()
5816 
    self._oprot.trans.flush()
5817 
 
5818 
  def recv_getOrdersCollectionAtStore(self, ):
5819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5820 
    if mtype == TMessageType.EXCEPTION:
5821 
      x = TApplicationException()
5822 
      x.read(self._iprot)
5823 
      self._iprot.readMessageEnd()
5824 
      raise x
5825 
    result = getOrdersCollectionAtStore_result()
5826 
    result.read(self._iprot)
5827 
    self._iprot.readMessageEnd()
5828 
    if result.success is not None:
5829 
      return result.success
5830 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5831 
 
5833 rajveer 5832 
  def getOrderAttributeValue(self, orderId, attributeName):
5833 
    """
5834 
    Parameters:
5835 
     - orderId
5836 
     - attributeName
5837 
    """
5838 
    self.send_getOrderAttributeValue(orderId, attributeName)
5839 
    return self.recv_getOrderAttributeValue()
5840 
 
5841 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5842 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5843 
    args = getOrderAttributeValue_args()
5844 
    args.orderId = orderId
5845 
    args.attributeName = attributeName
5846 
    args.write(self._oprot)
5847 
    self._oprot.writeMessageEnd()
5848 
    self._oprot.trans.flush()
5849 
 
5850 
  def recv_getOrderAttributeValue(self, ):
5851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5852 
    if mtype == TMessageType.EXCEPTION:
5853 
      x = TApplicationException()
5854 
      x.read(self._iprot)
5855 
      self._iprot.readMessageEnd()
5856 
      raise x
5857 
    result = getOrderAttributeValue_result()
5858 
    result.read(self._iprot)
5859 
    self._iprot.readMessageEnd()
5860 
    if result.success is not None:
5861 
      return result.success
5862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5863 
 
6019 rajveer 5864 
  def changeJacketNumber(self, orderId, jacketNumber):
5865 
    """
5866 
    Parameters:
5867 
     - orderId
5868 
     - jacketNumber
5869 
    """
5870 
    self.send_changeJacketNumber(orderId, jacketNumber)
5871 
    return self.recv_changeJacketNumber()
5872 
 
5873 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5874 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5875 
    args = changeJacketNumber_args()
5876 
    args.orderId = orderId
5877 
    args.jacketNumber = jacketNumber
5878 
    args.write(self._oprot)
5879 
    self._oprot.writeMessageEnd()
5880 
    self._oprot.trans.flush()
5881 
 
5882 
  def recv_changeJacketNumber(self, ):
5883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5884 
    if mtype == TMessageType.EXCEPTION:
5885 
      x = TApplicationException()
5886 
      x.read(self._iprot)
5887 
      self._iprot.readMessageEnd()
5888 
      raise x
5889 
    result = changeJacketNumber_result()
5890 
    result.read(self._iprot)
5891 
    self._iprot.readMessageEnd()
5892 
    if result.success is not None:
5893 
      return result.success
5894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5895 
 
5896 
  def markOrderAsRtoInTransit(self, orderId):
5897 
    """
5898 
    Parameters:
5899 
     - orderId
5900 
    """
5901 
    self.send_markOrderAsRtoInTransit(orderId)
5902 
    return self.recv_markOrderAsRtoInTransit()
5903 
 
5904 
  def send_markOrderAsRtoInTransit(self, orderId):
5905 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5906 
    args = markOrderAsRtoInTransit_args()
5907 
    args.orderId = orderId
5908 
    args.write(self._oprot)
5909 
    self._oprot.writeMessageEnd()
5910 
    self._oprot.trans.flush()
5911 
 
5912 
  def recv_markOrderAsRtoInTransit(self, ):
5913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5914 
    if mtype == TMessageType.EXCEPTION:
5915 
      x = TApplicationException()
5916 
      x.read(self._iprot)
5917 
      self._iprot.readMessageEnd()
5918 
      raise x
5919 
    result = markOrderAsRtoInTransit_result()
5920 
    result.read(self._iprot)
5921 
    self._iprot.readMessageEnd()
5922 
    if result.success is not None:
5923 
      return result.success
5924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5925 
 
5593 mandeep.dh 5926 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5927 
    """
5928 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5929 
    invoked while scanning IN of items.
5553 rajveer 5930 
 
5593 mandeep.dh 5931 
    Parameters:
5932 
     - itemId
5933 
     - quantity
5934 
     - fulfilmentWarehouseId
5935 
     - billingWarehouseId
5936 
    """
5937 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5938 
    self.recv_acceptOrderForItem()
5939 
 
5940 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5941 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5942 
    args = acceptOrderForItem_args()
5943 
    args.itemId = itemId
5944 
    args.quantity = quantity
5945 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5946 
    args.billingWarehouseId = billingWarehouseId
5947 
    args.write(self._oprot)
5948 
    self._oprot.writeMessageEnd()
5949 
    self._oprot.trans.flush()
5950 
 
5951 
  def recv_acceptOrderForItem(self, ):
5952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5953 
    if mtype == TMessageType.EXCEPTION:
5954 
      x = TApplicationException()
5955 
      x.read(self._iprot)
5956 
      self._iprot.readMessageEnd()
5957 
      raise x
5958 
    result = acceptOrderForItem_result()
5959 
    result.read(self._iprot)
5960 
    self._iprot.readMessageEnd()
5961 
    return
5962 
 
6000 mandeep.dh 5963 
  def createRechargeOrder(self, rechargeOrder):
5964 
    """
5965 
    Parameters:
5966 
     - rechargeOrder
5967 
    """
5968 
    self.send_createRechargeOrder(rechargeOrder)
5969 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5970 
 
6000 mandeep.dh 5971 
  def send_createRechargeOrder(self, rechargeOrder):
5972 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5973 
    args = createRechargeOrder_args()
5974 
    args.rechargeOrder = rechargeOrder
5975 
    args.write(self._oprot)
5976 
    self._oprot.writeMessageEnd()
5977 
    self._oprot.trans.flush()
5978 
 
5979 
  def recv_createRechargeOrder(self, ):
5980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5981 
    if mtype == TMessageType.EXCEPTION:
5982 
      x = TApplicationException()
5983 
      x.read(self._iprot)
5984 
      self._iprot.readMessageEnd()
5985 
      raise x
5986 
    result = createRechargeOrder_result()
5987 
    result.read(self._iprot)
5988 
    self._iprot.readMessageEnd()
5989 
    if result.success is not None:
5990 
      return result.success
5991 
    if result.ex is not None:
5992 
      raise result.ex
5993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5994 
 
6031 rajveer 5995 
  def getRechargeOrder(self, rechargeRrderId):
5996 
    """
5997 
    Parameters:
5998 
     - rechargeRrderId
5999 
    """
6000 
    self.send_getRechargeOrder(rechargeRrderId)
6001 
    return self.recv_getRechargeOrder()
6002 
 
6003 
  def send_getRechargeOrder(self, rechargeRrderId):
6004 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6005 
    args = getRechargeOrder_args()
6006 
    args.rechargeRrderId = rechargeRrderId
6007 
    args.write(self._oprot)
6008 
    self._oprot.writeMessageEnd()
6009 
    self._oprot.trans.flush()
6010 
 
6011 
  def recv_getRechargeOrder(self, ):
6012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6013 
    if mtype == TMessageType.EXCEPTION:
6014 
      x = TApplicationException()
6015 
      x.read(self._iprot)
6016 
      self._iprot.readMessageEnd()
6017 
      raise x
6018 
    result = getRechargeOrder_result()
6019 
    result.read(self._iprot)
6020 
    self._iprot.readMessageEnd()
6021 
    if result.success is not None:
6022 
      return result.success
6023 
    if result.ex is not None:
6024 
      raise result.ex
6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6026 
 
6027 
  def getRechargeOrders(self, userId):
6028 
    """
6029 
    Parameters:
6030 
     - userId
6031 
    """
6032 
    self.send_getRechargeOrders(userId)
6033 
    return self.recv_getRechargeOrders()
6034 
 
6035 
  def send_getRechargeOrders(self, userId):
6036 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6037 
    args = getRechargeOrders_args()
6038 
    args.userId = userId
6039 
    args.write(self._oprot)
6040 
    self._oprot.writeMessageEnd()
6041 
    self._oprot.trans.flush()
6042 
 
6043 
  def recv_getRechargeOrders(self, ):
6044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6045 
    if mtype == TMessageType.EXCEPTION:
6046 
      x = TApplicationException()
6047 
      x.read(self._iprot)
6048 
      self._iprot.readMessageEnd()
6049 
      raise x
6050 
    result = getRechargeOrders_result()
6051 
    result.read(self._iprot)
6052 
    self._iprot.readMessageEnd()
6053 
    if result.success is not None:
6054 
      return result.success
6055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6056 
 
6000 mandeep.dh 6057 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6058 
    """
6059 
    Parameters:
6060 
     - rechargeOrderId
6061 
     - rechargeOrderStatus
6062 
    """
6063 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6064 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6065 
 
6066 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6067 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6068 
    args = updateRechargeOrderStatus_args()
6069 
    args.rechargeOrderId = rechargeOrderId
6070 
    args.rechargeOrderStatus = rechargeOrderStatus
6071 
    args.write(self._oprot)
6072 
    self._oprot.writeMessageEnd()
6073 
    self._oprot.trans.flush()
6074 
 
6075 
  def recv_updateRechargeOrderStatus(self, ):
6076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6077 
    if mtype == TMessageType.EXCEPTION:
6078 
      x = TApplicationException()
6079 
      x.read(self._iprot)
6080 
      self._iprot.readMessageEnd()
6081 
      raise x
6082 
    result = updateRechargeOrderStatus_result()
6083 
    result.read(self._iprot)
6084 
    self._iprot.readMessageEnd()
6031 rajveer 6085 
    if result.success is not None:
6086 
      return result.success
6000 mandeep.dh 6087 
    if result.ex is not None:
6088 
      raise result.ex
6031 rajveer 6089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6090 
 
6031 rajveer 6091 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6092 
    """
6093 
    Parameters:
6031 rajveer 6094 
     - rechargeOrderId
6000 mandeep.dh 6095 
    """
6031 rajveer 6096 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6097 
    return self.recv_activateRechargeTxn()
6098 
 
6031 rajveer 6099 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6100 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6101 
    args = activateRechargeTxn_args()
6031 rajveer 6102 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6103 
    args.write(self._oprot)
6104 
    self._oprot.writeMessageEnd()
6105 
    self._oprot.trans.flush()
6106 
 
6107 
  def recv_activateRechargeTxn(self, ):
6108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6109 
    if mtype == TMessageType.EXCEPTION:
6110 
      x = TApplicationException()
6111 
      x.read(self._iprot)
6112 
      self._iprot.readMessageEnd()
6113 
      raise x
6114 
    result = activateRechargeTxn_result()
6115 
    result.read(self._iprot)
6116 
    self._iprot.readMessageEnd()
6117 
    if result.success is not None:
6118 
      return result.success
6119 
    if result.ex is not None:
6120 
      raise result.ex
6121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6122 
 
6031 rajveer 6123 
  def getUserWallet(self, userId):
6000 mandeep.dh 6124 
    """
6125 
    Parameters:
6031 rajveer 6126 
     - userId
6000 mandeep.dh 6127 
    """
6031 rajveer 6128 
    self.send_getUserWallet(userId)
6129 
    return self.recv_getUserWallet()
6000 mandeep.dh 6130 
 
6031 rajveer 6131 
  def send_getUserWallet(self, userId):
6132 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6133 
    args = getUserWallet_args()
6134 
    args.userId = userId
6000 mandeep.dh 6135 
    args.write(self._oprot)
6136 
    self._oprot.writeMessageEnd()
6137 
    self._oprot.trans.flush()
6138 
 
6031 rajveer 6139 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6141 
    if mtype == TMessageType.EXCEPTION:
6142 
      x = TApplicationException()
6143 
      x.read(self._iprot)
6144 
      self._iprot.readMessageEnd()
6145 
      raise x
6031 rajveer 6146 
    result = getUserWallet_result()
6000 mandeep.dh 6147 
    result.read(self._iprot)
6148 
    self._iprot.readMessageEnd()
6149 
    if result.success is not None:
6150 
      return result.success
6031 rajveer 6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6152 
 
6031 rajveer 6153 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6154 
    """
6155 
    Parameters:
6031 rajveer 6156 
     - userId
6000 mandeep.dh 6157 
    """
6031 rajveer 6158 
    self.send_getUserWalletHistory(userId)
6159 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6160 
 
6031 rajveer 6161 
  def send_getUserWalletHistory(self, userId):
6162 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6163 
    args = getUserWalletHistory_args()
6164 
    args.userId = userId
6000 mandeep.dh 6165 
    args.write(self._oprot)
6166 
    self._oprot.writeMessageEnd()
6167 
    self._oprot.trans.flush()
6168 
 
6031 rajveer 6169 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6171 
    if mtype == TMessageType.EXCEPTION:
6172 
      x = TApplicationException()
6173 
      x.read(self._iprot)
6174 
      self._iprot.readMessageEnd()
6175 
      raise x
6031 rajveer 6176 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6177 
    result.read(self._iprot)
6178 
    self._iprot.readMessageEnd()
6179 
    if result.success is not None:
6180 
      return result.success
6031 rajveer 6181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6182 
 
6050 anupam.sin 6183 
  def getRechargeOrdersForTransaction(self, txnId):
6184 
    """
6185 
    Returns a recharge order for a given transactionId
6186 
 
6187 
    Parameters:
6188 
     - txnId
6189 
    """
6190 
    self.send_getRechargeOrdersForTransaction(txnId)
6191 
    return self.recv_getRechargeOrdersForTransaction()
6192 
 
6193 
  def send_getRechargeOrdersForTransaction(self, txnId):
6194 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6195 
    args = getRechargeOrdersForTransaction_args()
6196 
    args.txnId = txnId
6197 
    args.write(self._oprot)
6198 
    self._oprot.writeMessageEnd()
6199 
    self._oprot.trans.flush()
6200 
 
6201 
  def recv_getRechargeOrdersForTransaction(self, ):
6202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6203 
    if mtype == TMessageType.EXCEPTION:
6204 
      x = TApplicationException()
6205 
      x.read(self._iprot)
6206 
      self._iprot.readMessageEnd()
6207 
      raise x
6208 
    result = getRechargeOrdersForTransaction_result()
6209 
    result.read(self._iprot)
6210 
    self._iprot.readMessageEnd()
6211 
    if result.success is not None:
6212 
      return result.success
6213 
    if result.ex is not None:
6214 
      raise result.ex
6215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6216 
 
6206 rajveer 6217 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6218 
    """
6219 
    Parameters:
6220 
     - rechargeType
6206 rajveer 6221 
     - onlyActive
6048 rajveer 6222 
    """
6206 rajveer 6223 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6224 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6225 
 
6206 rajveer 6226 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6227 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6228 
    args = getServiceProviders_args()
6229 
    args.rechargeType = rechargeType
6206 rajveer 6230 
    args.onlyActive = onlyActive
6048 rajveer 6231 
    args.write(self._oprot)
6232 
    self._oprot.writeMessageEnd()
6233 
    self._oprot.trans.flush()
6234 
 
6235 
  def recv_getServiceProviders(self, ):
6236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6237 
    if mtype == TMessageType.EXCEPTION:
6238 
      x = TApplicationException()
6239 
      x.read(self._iprot)
6240 
      self._iprot.readMessageEnd()
6241 
      raise x
6242 
    result = getServiceProviders_result()
6243 
    result.read(self._iprot)
6244 
    self._iprot.readMessageEnd()
6245 
    if result.success is not None:
6246 
      return result.success
6247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6248 
 
6049 rajveer 6249 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6250 
    """
6251 
    Parameters:
6049 rajveer 6252 
     - rechargeType
6048 rajveer 6253 
     - deviceNumber
6254 
    """
6049 rajveer 6255 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6256 
    return self.recv_getServiceProviderForDevice()
6257 
 
6049 rajveer 6258 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6259 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6260 
    args = getServiceProviderForDevice_args()
6049 rajveer 6261 
    args.rechargeType = rechargeType
6048 rajveer 6262 
    args.deviceNumber = deviceNumber
6263 
    args.write(self._oprot)
6264 
    self._oprot.writeMessageEnd()
6265 
    self._oprot.trans.flush()
6266 
 
6267 
  def recv_getServiceProviderForDevice(self, ):
6268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6269 
    if mtype == TMessageType.EXCEPTION:
6270 
      x = TApplicationException()
6271 
      x.read(self._iprot)
6272 
      self._iprot.readMessageEnd()
6273 
      raise x
6274 
    result = getServiceProviderForDevice_result()
6275 
    result.read(self._iprot)
6276 
    self._iprot.readMessageEnd()
6277 
    if result.success is not None:
6278 
      return result.success
6279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6280 
 
6591 anupam.sin 6281 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6282 
    """
6283 
    Parameters:
6284 
     - rechargeType
6285 
     - deviceNumber
6307 anupam.sin 6286 
     - userSelectedProviderId
6591 anupam.sin 6287 
     - clientAddress
6269 rajveer 6288 
    """
6591 anupam.sin 6289 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6290 
    return self.recv_validateRecharge()
6291 
 
6591 anupam.sin 6292 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6293 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6294 
    args = validateRecharge_args()
6295 
    args.rechargeType = rechargeType
6296 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6297 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6298 
    args.clientAddress = clientAddress
6269 rajveer 6299 
    args.write(self._oprot)
6300 
    self._oprot.writeMessageEnd()
6301 
    self._oprot.trans.flush()
6302 
 
6303 
  def recv_validateRecharge(self, ):
6304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6305 
    if mtype == TMessageType.EXCEPTION:
6306 
      x = TApplicationException()
6307 
      x.read(self._iprot)
6308 
      self._iprot.readMessageEnd()
6309 
      raise x
6310 
    result = validateRecharge_result()
6311 
    result.read(self._iprot)
6312 
    self._iprot.readMessageEnd()
6313 
    if result.success is not None:
6314 
      return result.success
6315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6316 
 
6094 rajveer 6317 
  def getRechargeOrdersForDevice(self, deviceNumber):
6318 
    """
6319 
    Parameters:
6320 
     - deviceNumber
6321 
    """
6322 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6323 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6324 
 
6094 rajveer 6325 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6326 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6327 
    args = getRechargeOrdersForDevice_args()
6328 
    args.deviceNumber = deviceNumber
6329 
    args.write(self._oprot)
6330 
    self._oprot.writeMessageEnd()
6331 
    self._oprot.trans.flush()
6332 
 
6333 
  def recv_getRechargeOrdersForDevice(self, ):
6334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6335 
    if mtype == TMessageType.EXCEPTION:
6336 
      x = TApplicationException()
6337 
      x.read(self._iprot)
6338 
      self._iprot.readMessageEnd()
6339 
      raise x
6340 
    result = getRechargeOrdersForDevice_result()
6341 
    result.read(self._iprot)
6342 
    self._iprot.readMessageEnd()
6343 
    if result.success is not None:
6344 
      return result.success
6345 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6346 
 
6347 
  def addAmountToWallet(self, userId, orderId, amount):
6348 
    """
6349 
    Parameters:
6350 
     - userId
6351 
     - orderId
6352 
     - amount
6353 
    """
6354 
    self.send_addAmountToWallet(userId, orderId, amount)
6355 
    self.recv_addAmountToWallet()
6356 
 
6357 
  def send_addAmountToWallet(self, userId, orderId, amount):
6358 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6359 
    args = addAmountToWallet_args()
6360 
    args.userId = userId
6361 
    args.orderId = orderId
6362 
    args.amount = amount
6363 
    args.write(self._oprot)
6364 
    self._oprot.writeMessageEnd()
6365 
    self._oprot.trans.flush()
6366 
 
6367 
  def recv_addAmountToWallet(self, ):
6368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6369 
    if mtype == TMessageType.EXCEPTION:
6370 
      x = TApplicationException()
6371 
      x.read(self._iprot)
6372 
      self._iprot.readMessageEnd()
6373 
      raise x
6374 
    result = addAmountToWallet_result()
6375 
    result.read(self._iprot)
6376 
    self._iprot.readMessageEnd()
6377 
    return
6378 
 
6188 rajveer 6379 
  def getRechargeStatistics(self, ):
6380 
    self.send_getRechargeStatistics()
6381 
    return self.recv_getRechargeStatistics()
6382 
 
6383 
  def send_getRechargeStatistics(self, ):
6384 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6385 
    args = getRechargeStatistics_args()
6386 
    args.write(self._oprot)
6387 
    self._oprot.writeMessageEnd()
6388 
    self._oprot.trans.flush()
6389 
 
6390 
  def recv_getRechargeStatistics(self, ):
6391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6392 
    if mtype == TMessageType.EXCEPTION:
6393 
      x = TApplicationException()
6394 
      x.read(self._iprot)
6395 
      self._iprot.readMessageEnd()
6396 
      raise x
6397 
    result = getRechargeStatistics_result()
6398 
    result.read(self._iprot)
6399 
    self._iprot.readMessageEnd()
6400 
    if result.success is not None:
6401 
      return result.success
6402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6403 
 
6154 rajveer 6404 
  def getRechargeOrdersForStatus(self, status):
6405 
    """
6406 
    Parameters:
6407 
     - status
6408 
    """
6409 
    self.send_getRechargeOrdersForStatus(status)
6410 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6411 
 
6154 rajveer 6412 
  def send_getRechargeOrdersForStatus(self, status):
6413 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6414 
    args = getRechargeOrdersForStatus_args()
6415 
    args.status = status
6416 
    args.write(self._oprot)
6417 
    self._oprot.writeMessageEnd()
6418 
    self._oprot.trans.flush()
6419 
 
6420 
  def recv_getRechargeOrdersForStatus(self, ):
6421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6422 
    if mtype == TMessageType.EXCEPTION:
6423 
      x = TApplicationException()
6424 
      x.read(self._iprot)
6425 
      self._iprot.readMessageEnd()
6426 
      raise x
6427 
    result = getRechargeOrdersForStatus_result()
6428 
    result.read(self._iprot)
6429 
    self._iprot.readMessageEnd()
6430 
    if result.success is not None:
6431 
      return result.success
6432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6433 
 
6159 rajveer 6434 
  def getPlansForOperator(self, operatorId):
6435 
    """
6436 
    Parameters:
6437 
     - operatorId
6438 
    """
6439 
    self.send_getPlansForOperator(operatorId)
6440 
    return self.recv_getPlansForOperator()
6154 rajveer 6441 
 
6159 rajveer 6442 
  def send_getPlansForOperator(self, operatorId):
6443 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6444 
    args = getPlansForOperator_args()
6445 
    args.operatorId = operatorId
6446 
    args.write(self._oprot)
6447 
    self._oprot.writeMessageEnd()
6448 
    self._oprot.trans.flush()
6449 
 
6450 
  def recv_getPlansForOperator(self, ):
6451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6452 
    if mtype == TMessageType.EXCEPTION:
6453 
      x = TApplicationException()
6454 
      x.read(self._iprot)
6455 
      self._iprot.readMessageEnd()
6456 
      raise x
6457 
    result = getPlansForOperator_result()
6458 
    result.read(self._iprot)
6459 
    self._iprot.readMessageEnd()
6460 
    if result.success is not None:
6461 
      return result.success
6462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6463 
 
6307 anupam.sin 6464 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6465 
    """
6466 
    Returns denominations for a given operator and circle
6159 rajveer 6467 
 
6289 anupam.sin 6468 
    Parameters:
6469 
     - operatorId
6307 anupam.sin 6470 
     - circleCode
6289 anupam.sin 6471 
     - denominationType
6472 
    """
6307 anupam.sin 6473 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6474 
    return self.recv_getRechargeDenominations()
6475 
 
6307 anupam.sin 6476 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6477 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6478 
    args = getRechargeDenominations_args()
6479 
    args.operatorId = operatorId
6307 anupam.sin 6480 
    args.circleCode = circleCode
6289 anupam.sin 6481 
    args.denominationType = denominationType
6482 
    args.write(self._oprot)
6483 
    self._oprot.writeMessageEnd()
6484 
    self._oprot.trans.flush()
6485 
 
6486 
  def recv_getRechargeDenominations(self, ):
6487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6488 
    if mtype == TMessageType.EXCEPTION:
6489 
      x = TApplicationException()
6490 
      x.read(self._iprot)
6491 
      self._iprot.readMessageEnd()
6492 
      raise x
6493 
    result = getRechargeDenominations_result()
6494 
    result.read(self._iprot)
6495 
    self._iprot.readMessageEnd()
6496 
    if result.success is not None:
6497 
      return result.success
6498 
    if result.ex is not None:
6499 
      raise result.ex
6500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6501 
 
6371 rajveer 6502 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6503 
    """
6504 
    Parameters:
6505 
     - operatorId
6506 
     - circleId
6507 
     - isAvailable
6508 
    """
6509 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6510 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6511 
 
6371 rajveer 6512 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6513 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6514 
    args = updateAvailabilityStatus_args()
6515 
    args.operatorId = operatorId
6516 
    args.circleId = circleId
6517 
    args.isAvailable = isAvailable
6518 
    args.write(self._oprot)
6519 
    self._oprot.writeMessageEnd()
6520 
    self._oprot.trans.flush()
6521 
 
6522 
  def recv_updateAvailabilityStatus(self, ):
6523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6524 
    if mtype == TMessageType.EXCEPTION:
6525 
      x = TApplicationException()
6526 
      x.read(self._iprot)
6527 
      self._iprot.readMessageEnd()
6528 
      raise x
6529 
    result = updateAvailabilityStatus_result()
6530 
    result.read(self._iprot)
6531 
    self._iprot.readMessageEnd()
6532 
    return
6533 
 
6389 rajveer 6534 
  def getAvailableEmiSchemes(self, ):
6535 
    self.send_getAvailableEmiSchemes()
6536 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6537 
 
6389 rajveer 6538 
  def send_getAvailableEmiSchemes(self, ):
6539 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6540 
    args = getAvailableEmiSchemes_args()
6541 
    args.write(self._oprot)
6542 
    self._oprot.writeMessageEnd()
6543 
    self._oprot.trans.flush()
6544 
 
6545 
  def recv_getAvailableEmiSchemes(self, ):
6546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6547 
    if mtype == TMessageType.EXCEPTION:
6548 
      x = TApplicationException()
6549 
      x.read(self._iprot)
6550 
      self._iprot.readMessageEnd()
6551 
      raise x
6552 
    result = getAvailableEmiSchemes_result()
6553 
    result.read(self._iprot)
6554 
    self._iprot.readMessageEnd()
6555 
    if result.success is not None:
6556 
      return result.success
6557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6558 
 
6559 
  def getMiscCharges(self, transactionId):
6560 
    """
6561 
    Parameters:
6562 
     - transactionId
6563 
    """
6564 
    self.send_getMiscCharges(transactionId)
6565 
    return self.recv_getMiscCharges()
6566 
 
6567 
  def send_getMiscCharges(self, transactionId):
6568 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6569 
    args = getMiscCharges_args()
6570 
    args.transactionId = transactionId
6571 
    args.write(self._oprot)
6572 
    self._oprot.writeMessageEnd()
6573 
    self._oprot.trans.flush()
6574 
 
6575 
  def recv_getMiscCharges(self, ):
6576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6577 
    if mtype == TMessageType.EXCEPTION:
6578 
      x = TApplicationException()
6579 
      x.read(self._iprot)
6580 
      self._iprot.readMessageEnd()
6581 
      raise x
6582 
    result = getMiscCharges_result()
6583 
    result.read(self._iprot)
6584 
    self._iprot.readMessageEnd()
6585 
    if result.success is not None:
6586 
      return result.success
6587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6588 
 
6507 anupam.sin 6589 
  def refundRechargeOrder(self, rechargeOrderId):
6590 
    """
6591 
    Parameters:
6592 
     - rechargeOrderId
6593 
    """
6594 
    self.send_refundRechargeOrder(rechargeOrderId)
6595 
    return self.recv_refundRechargeOrder()
6389 rajveer 6596 
 
6507 anupam.sin 6597 
  def send_refundRechargeOrder(self, rechargeOrderId):
6598 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6599 
    args = refundRechargeOrder_args()
6600 
    args.rechargeOrderId = rechargeOrderId
6601 
    args.write(self._oprot)
6602 
    self._oprot.writeMessageEnd()
6603 
    self._oprot.trans.flush()
6604 
 
6605 
  def recv_refundRechargeOrder(self, ):
6606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6607 
    if mtype == TMessageType.EXCEPTION:
6608 
      x = TApplicationException()
6609 
      x.read(self._iprot)
6610 
      self._iprot.readMessageEnd()
6611 
      raise x
6612 
    result = refundRechargeOrder_result()
6613 
    result.read(self._iprot)
6614 
    self._iprot.readMessageEnd()
6615 
    if result.success is not None:
6616 
      return result.success
6617 
    if result.ex is not None:
6618 
      raise result.ex
6619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6620 
 
6821 amar.kumar 6621 
  def getPhysicalOrders(self, fromDate, toDate):
6622 
    """
6623 
    Parameters:
6624 
     - fromDate
6625 
     - toDate
6626 
    """
6627 
    self.send_getPhysicalOrders(fromDate, toDate)
6628 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6629 
 
6821 amar.kumar 6630 
  def send_getPhysicalOrders(self, fromDate, toDate):
6631 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6632 
    args = getPhysicalOrders_args()
6633 
    args.fromDate = fromDate
6634 
    args.toDate = toDate
6635 
    args.write(self._oprot)
6636 
    self._oprot.writeMessageEnd()
6637 
    self._oprot.trans.flush()
6638 
 
6639 
  def recv_getPhysicalOrders(self, ):
6640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6641 
    if mtype == TMessageType.EXCEPTION:
6642 
      x = TApplicationException()
6643 
      x.read(self._iprot)
6644 
      self._iprot.readMessageEnd()
6645 
      raise x
6646 
    result = getPhysicalOrders_result()
6647 
    result.read(self._iprot)
6648 
    self._iprot.readMessageEnd()
6649 
    if result.success is not None:
6650 
      return result.success
6651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6652 
 
6906 rajveer 6653 
  def getDocument(self, docType, docSource):
6654 
    """
6655 
    Parameters:
6656 
     - docType
6657 
     - docSource
6658 
    """
6659 
    self.send_getDocument(docType, docSource)
6660 
    return self.recv_getDocument()
6821 amar.kumar 6661 
 
6906 rajveer 6662 
  def send_getDocument(self, docType, docSource):
6663 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6664 
    args = getDocument_args()
6665 
    args.docType = docType
6666 
    args.docSource = docSource
6667 
    args.write(self._oprot)
6668 
    self._oprot.writeMessageEnd()
6669 
    self._oprot.trans.flush()
6670 
 
6671 
  def recv_getDocument(self, ):
6672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6673 
    if mtype == TMessageType.EXCEPTION:
6674 
      x = TApplicationException()
6675 
      x.read(self._iprot)
6676 
      self._iprot.readMessageEnd()
6677 
      raise x
6678 
    result = getDocument_result()
6679 
    result.read(self._iprot)
6680 
    self._iprot.readMessageEnd()
6681 
    if result.success is not None:
6682 
      return result.success
6683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6684 
 
6985 anupam.sin 6685 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6686 
    """
6687 
    Parameters:
6688 
     - orderId
6689 
     - line1
6690 
     - line2
6691 
     - city
6692 
     - state
6693 
     - pin
6694 
    """
6695 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6696 
    return self.recv_changeShippingAddress()
6906 rajveer 6697 
 
6985 anupam.sin 6698 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6699 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6700 
    args = changeShippingAddress_args()
6701 
    args.orderId = orderId
6702 
    args.line1 = line1
6703 
    args.line2 = line2
6704 
    args.city = city
6705 
    args.state = state
6706 
    args.pin = pin
6707 
    args.write(self._oprot)
6708 
    self._oprot.writeMessageEnd()
6709 
    self._oprot.trans.flush()
6710 
 
6711 
  def recv_changeShippingAddress(self, ):
6712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6713 
    if mtype == TMessageType.EXCEPTION:
6714 
      x = TApplicationException()
6715 
      x.read(self._iprot)
6716 
      self._iprot.readMessageEnd()
6717 
      raise x
6718 
    result = changeShippingAddress_result()
6719 
    result.read(self._iprot)
6720 
    self._iprot.readMessageEnd()
6721 
    if result.success is not None:
6722 
      return result.success
6723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6724 
 
7075 rajveer 6725 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6726 
    """
6727 
    Parameters:
6728 
     - orderId
7075 rajveer 6729 
     - userId
6988 rajveer 6730 
    """
7075 rajveer 6731 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6732 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6733 
 
7075 rajveer 6734 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6735 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6736 
    args = retrieveInvoice_args()
6737 
    args.orderId = orderId
7075 rajveer 6738 
    args.userId = userId
6988 rajveer 6739 
    args.write(self._oprot)
6740 
    self._oprot.writeMessageEnd()
6741 
    self._oprot.trans.flush()
6742 
 
6743 
  def recv_retrieveInvoice(self, ):
6744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6745 
    if mtype == TMessageType.EXCEPTION:
6746 
      x = TApplicationException()
6747 
      x.read(self._iprot)
6748 
      self._iprot.readMessageEnd()
6749 
      raise x
6750 
    result = retrieveInvoice_result()
6751 
    result.read(self._iprot)
6752 
    self._iprot.readMessageEnd()
6753 
    if result.success is not None:
6754 
      return result.success
6755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6756 
 
7026 rajveer 6757 
  def receiveUpdatesForRedExpress(self, awbNumber):
6758 
    """
6759 
    Parameters:
6760 
     - awbNumber
6761 
    """
6762 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6763 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6764 
 
7026 rajveer 6765 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6766 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6767 
    args = receiveUpdatesForRedExpress_args()
6768 
    args.awbNumber = awbNumber
6769 
    args.write(self._oprot)
6770 
    self._oprot.writeMessageEnd()
6771 
    self._oprot.trans.flush()
6772 
 
6773 
  def recv_receiveUpdatesForRedExpress(self, ):
6774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6775 
    if mtype == TMessageType.EXCEPTION:
6776 
      x = TApplicationException()
6777 
      x.read(self._iprot)
6778 
      self._iprot.readMessageEnd()
6779 
      raise x
6780 
    result = receiveUpdatesForRedExpress_result()
6781 
    result.read(self._iprot)
6782 
    self._iprot.readMessageEnd()
6783 
    if result.success is not None:
6784 
      return result.success
6785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6786 
 
7073 anupam.sin 6787 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6788 
    """
6789 
    Parameters:
6790 
     - thriftRechargeTransaction
6791 
    """
6792 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6793 
    return self.recv_createRechargeTransaction()
7026 rajveer 6794 
 
7073 anupam.sin 6795 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6796 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6797 
    args = createRechargeTransaction_args()
6798 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6799 
    args.write(self._oprot)
6800 
    self._oprot.writeMessageEnd()
6801 
    self._oprot.trans.flush()
6802 
 
6803 
  def recv_createRechargeTransaction(self, ):
6804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6805 
    if mtype == TMessageType.EXCEPTION:
6806 
      x = TApplicationException()
6807 
      x.read(self._iprot)
6808 
      self._iprot.readMessageEnd()
6809 
      raise x
6810 
    result = createRechargeTransaction_result()
6811 
    result.read(self._iprot)
6812 
    self._iprot.readMessageEnd()
6813 
    if result.success is not None:
6814 
      return result.success
6815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6816 
 
7085 rajveer 6817 
  def getRechargeTransactions(self, storeId):
6818 
    """
6819 
    Parameters:
6820 
     - storeId
6821 
    """
6822 
    self.send_getRechargeTransactions(storeId)
6823 
    return self.recv_getRechargeTransactions()
6824 
 
6825 
  def send_getRechargeTransactions(self, storeId):
6826 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6827 
    args = getRechargeTransactions_args()
6828 
    args.storeId = storeId
6829 
    args.write(self._oprot)
6830 
    self._oprot.writeMessageEnd()
6831 
    self._oprot.trans.flush()
6832 
 
6833 
  def recv_getRechargeTransactions(self, ):
6834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6835 
    if mtype == TMessageType.EXCEPTION:
6836 
      x = TApplicationException()
6837 
      x.read(self._iprot)
6838 
      self._iprot.readMessageEnd()
6839 
      raise x
6840 
    result = getRechargeTransactions_result()
6841 
    result.read(self._iprot)
6842 
    self._iprot.readMessageEnd()
6843 
    if result.success is not None:
6844 
      return result.success
6845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6846 
 
7080 anupam.sin 6847 
  def getRechargeTransaction(self, rechargeId):
6848 
    """
6849 
    Parameters:
6850 
     - rechargeId
6851 
    """
6852 
    self.send_getRechargeTransaction(rechargeId)
6853 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6854 
 
7080 anupam.sin 6855 
  def send_getRechargeTransaction(self, rechargeId):
6856 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6857 
    args = getRechargeTransaction_args()
6858 
    args.rechargeId = rechargeId
6859 
    args.write(self._oprot)
6860 
    self._oprot.writeMessageEnd()
6861 
    self._oprot.trans.flush()
6862 
 
6863 
  def recv_getRechargeTransaction(self, ):
6864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6865 
    if mtype == TMessageType.EXCEPTION:
6866 
      x = TApplicationException()
6867 
      x.read(self._iprot)
6868 
      self._iprot.readMessageEnd()
6869 
      raise x
6870 
    result = getRechargeTransaction_result()
6871 
    result.read(self._iprot)
6872 
    self._iprot.readMessageEnd()
6873 
    if result.success is not None:
6874 
      return result.success
6875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6876 
 
6877 
  def getFRCs(self, circleId, operatorId):
6878 
    """
6879 
    Parameters:
6880 
     - circleId
6881 
     - operatorId
6882 
    """
6883 
    self.send_getFRCs(circleId, operatorId)
6884 
    return self.recv_getFRCs()
6885 
 
6886 
  def send_getFRCs(self, circleId, operatorId):
6887 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6888 
    args = getFRCs_args()
6889 
    args.circleId = circleId
6890 
    args.operatorId = operatorId
6891 
    args.write(self._oprot)
6892 
    self._oprot.writeMessageEnd()
6893 
    self._oprot.trans.flush()
6894 
 
6895 
  def recv_getFRCs(self, ):
6896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6897 
    if mtype == TMessageType.EXCEPTION:
6898 
      x = TApplicationException()
6899 
      x.read(self._iprot)
6900 
      self._iprot.readMessageEnd()
6901 
      raise x
6902 
    result = getFRCs_result()
6903 
    result.read(self._iprot)
6904 
    self._iprot.readMessageEnd()
6905 
    if result.success is not None:
6906 
      return result.success
6907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6908 
 
6909 
 
3376 rajveer 6910 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6911 
  def __init__(self, handler):
3376 rajveer 6912 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6913 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6914 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6915 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6916 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6917 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6918 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6919 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6920 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6921 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6922 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6923 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6924 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6925 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6926 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6927 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6928 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6929 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6930 
    self._processMap["createOrder"] = Processor.process_createOrder
6931 
    self._processMap["getOrder"] = Processor.process_getOrder
6932 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6933 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6934 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6935 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6936 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6937 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6938 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6939 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6940 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6941 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6942 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6943 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6944 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6945 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6946 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6947 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6948 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6949 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6950 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6951 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6952 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6953 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6954 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6955 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6956 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6957 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6958 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6959 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6960 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6961 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6962 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6963 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6964 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6965 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6966 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6967 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6968 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6969 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6970 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6971 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6972 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6973 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6974 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6975 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6976 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6977 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6978 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6979 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6980 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6981 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6982 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6983 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6984 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6985 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6986 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6987 
    self._processMap["changeItem"] = Processor.process_changeItem
6988 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6989 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6990 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6991 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6992 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6993 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6994 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6995 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6996 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6997 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6998 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6999 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7000 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7001 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7002 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7003 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7004 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7005 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7006 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7007 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7008 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7009 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7010 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7011 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7012 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7013 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7014 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7015 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7016 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7017 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7018 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7019 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7020 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7021 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7022 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7023 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7024 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7025 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7026 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7027 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7028 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7029 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7030 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7031 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7032 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7033 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7034 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7035 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7036 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7037 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7038 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7039 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7040 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7041 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7042 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7043 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7044 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7045 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7046 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7047 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7048 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7049 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7050 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7051 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7052 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7053 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7054 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7055 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7056 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7057 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7058 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7059 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7060 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7061 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7062 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7063 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7064 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7065 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7066 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7067 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7080 anupam.sin 7068 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7069 
    self._processMap["getFRCs"] = Processor.process_getFRCs
94 ashish 7070 
 
7071 
  def process(self, iprot, oprot):
7072 
    (name, type, seqid) = iprot.readMessageBegin()
7073 
    if name not in self._processMap:
7074 
      iprot.skip(TType.STRUCT)
7075 
      iprot.readMessageEnd()
7076 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7077 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7078 
      x.write(oprot)
7079 
      oprot.writeMessageEnd()
7080 
      oprot.trans.flush()
7081 
      return
7082 
    else:
7083 
      self._processMap[name](self, seqid, iprot, oprot)
7084 
    return True
7085 
 
7086 
  def process_createTransaction(self, seqid, iprot, oprot):
7087 
    args = createTransaction_args()
7088 
    args.read(iprot)
7089 
    iprot.readMessageEnd()
7090 
    result = createTransaction_result()
7091 
    try:
132 ashish 7092 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7093 
    except TransactionServiceException, ex:
7094 
      result.ex = ex
7095 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7096 
    result.write(oprot)
7097 
    oprot.writeMessageEnd()
7098 
    oprot.trans.flush()
7099 
 
7100 
  def process_getTransaction(self, seqid, iprot, oprot):
7101 
    args = getTransaction_args()
7102 
    args.read(iprot)
7103 
    iprot.readMessageEnd()
7104 
    result = getTransaction_result()
7105 
    try:
7106 
      result.success = self._handler.getTransaction(args.id)
7107 
    except TransactionServiceException, ex:
7108 
      result.ex = ex
7109 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7110 
    result.write(oprot)
7111 
    oprot.writeMessageEnd()
7112 
    oprot.trans.flush()
7113 
 
7114 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7115 
    args = getTransactionsForCustomer_args()
7116 
    args.read(iprot)
7117 
    iprot.readMessageEnd()
7118 
    result = getTransactionsForCustomer_result()
7119 
    try:
7120 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7121 
    except TransactionServiceException, ex:
7122 
      result.ex = ex
7123 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
7127 
 
132 ashish 7128 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7129 
    args = getTransactionsForShoppingCartId_args()
7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
7132 
    result = getTransactionsForShoppingCartId_result()
7133 
    try:
7134 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7135 
    except TransactionServiceException, ex:
7136 
      result.ex = ex
7137 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
7141 
 
94 ashish 7142 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7143 
    args = getTransactionStatus_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = getTransactionStatus_result()
7147 
    try:
7148 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7149 
    except TransactionServiceException, ex:
7150 
      result.ex = ex
7151 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7152 
    result.write(oprot)
7153 
    oprot.writeMessageEnd()
7154 
    oprot.trans.flush()
7155 
 
7156 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7157 
    args = changeTransactionStatus_args()
7158 
    args.read(iprot)
7159 
    iprot.readMessageEnd()
7160 
    result = changeTransactionStatus_result()
7161 
    try:
5527 anupam.sin 7162 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7163 
    except TransactionServiceException, ex:
7164 
      result.ex = ex
7165 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7166 
    result.write(oprot)
7167 
    oprot.writeMessageEnd()
7168 
    oprot.trans.flush()
7169 
 
1398 varun.gupt 7170 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7171 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7172 
    args.read(iprot)
7173 
    iprot.readMessageEnd()
1398 varun.gupt 7174 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7175 
    try:
1398 varun.gupt 7176 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7177 
    except TransactionServiceException, ex:
7178 
      result.ex = ex
1398 varun.gupt 7179 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7180 
    result.write(oprot)
7181 
    oprot.writeMessageEnd()
7182 
    oprot.trans.flush()
7183 
 
483 rajveer 7184 
  def process_getAllOrders(self, seqid, iprot, oprot):
7185 
    args = getAllOrders_args()
94 ashish 7186 
    args.read(iprot)
7187 
    iprot.readMessageEnd()
483 rajveer 7188 
    result = getAllOrders_result()
94 ashish 7189 
    try:
4801 anupam.sin 7190 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7191 
    except TransactionServiceException, ex:
7192 
      result.ex = ex
483 rajveer 7193 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7194 
    result.write(oprot)
7195 
    oprot.writeMessageEnd()
7196 
    oprot.trans.flush()
7197 
 
4133 chandransh 7198 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7199 
    args = getOrdersInBatch_args()
7200 
    args.read(iprot)
7201 
    iprot.readMessageEnd()
7202 
    result = getOrdersInBatch_result()
7203 
    try:
7204 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7205 
    except TransactionServiceException, ex:
7206 
      result.ex = ex
7207 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7208 
    result.write(oprot)
7209 
    oprot.writeMessageEnd()
7210 
    oprot.trans.flush()
7211 
 
7212 
  def process_getOrderCount(self, seqid, iprot, oprot):
7213 
    args = getOrderCount_args()
7214 
    args.read(iprot)
7215 
    iprot.readMessageEnd()
7216 
    result = getOrderCount_result()
7217 
    try:
7218 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7219 
    except TransactionServiceException, ex:
7220 
      result.ex = ex
7221 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7222 
    result.write(oprot)
7223 
    oprot.writeMessageEnd()
7224 
    oprot.trans.flush()
7225 
 
999 varun.gupt 7226 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7227 
    args = getOrdersByBillingDate_args()
7228 
    args.read(iprot)
7229 
    iprot.readMessageEnd()
7230 
    result = getOrdersByBillingDate_result()
7231 
    try:
7232 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7233 
    except TransactionServiceException, ex:
7234 
      result.ex = ex
7235 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7236 
    result.write(oprot)
7237 
    oprot.writeMessageEnd()
7238 
    oprot.trans.flush()
7239 
 
3427 chandransh 7240 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7241 
    args = getOrdersByShippingDate_args()
7242 
    args.read(iprot)
7243 
    iprot.readMessageEnd()
7244 
    result = getOrdersByShippingDate_result()
7245 
    try:
3451 chandransh 7246 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7247 
    except TransactionServiceException, ex:
7248 
      result.ex = ex
7249 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7250 
    result.write(oprot)
7251 
    oprot.writeMessageEnd()
7252 
    oprot.trans.flush()
7253 
 
1382 varun.gupt 7254 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7255 
    args = getReturnableOrdersForCustomer_args()
7256 
    args.read(iprot)
7257 
    iprot.readMessageEnd()
7258 
    result = getReturnableOrdersForCustomer_result()
7259 
    try:
7260 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7261 
    except TransactionServiceException, ex:
7262 
      result.ex = ex
7263 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7264 
    result.write(oprot)
7265 
    oprot.writeMessageEnd()
7266 
    oprot.trans.flush()
7267 
 
7268 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7269 
    args = getCancellableOrdersForCustomer_args()
7270 
    args.read(iprot)
7271 
    iprot.readMessageEnd()
7272 
    result = getCancellableOrdersForCustomer_result()
7273 
    try:
7274 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7275 
    except TransactionServiceException, ex:
7276 
      result.ex = ex
7277 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7278 
    result.write(oprot)
7279 
    oprot.writeMessageEnd()
7280 
    oprot.trans.flush()
7281 
 
483 rajveer 7282 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7283 
    args = changeOrderStatus_args()
94 ashish 7284 
    args.read(iprot)
7285 
    iprot.readMessageEnd()
483 rajveer 7286 
    result = changeOrderStatus_result()
94 ashish 7287 
    try:
483 rajveer 7288 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7289 
    except TransactionServiceException, ex:
7290 
      result.ex = ex
483 rajveer 7291 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7292 
    result.write(oprot)
7293 
    oprot.writeMessageEnd()
7294 
    oprot.trans.flush()
7295 
 
483 rajveer 7296 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7297 
    args = getOrdersForTransaction_args()
94 ashish 7298 
    args.read(iprot)
7299 
    iprot.readMessageEnd()
483 rajveer 7300 
    result = getOrdersForTransaction_result()
94 ashish 7301 
    try:
1528 ankur.sing 7302 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7303 
    except TransactionServiceException, ex:
7304 
      result.ex = ex
483 rajveer 7305 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7306 
    result.write(oprot)
7307 
    oprot.writeMessageEnd()
7308 
    oprot.trans.flush()
7309 
 
483 rajveer 7310 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7311 
    args = getOrdersForCustomer_args()
94 ashish 7312 
    args.read(iprot)
7313 
    iprot.readMessageEnd()
483 rajveer 7314 
    result = getOrdersForCustomer_result()
94 ashish 7315 
    try:
3014 chandransh 7316 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7317 
    except TransactionServiceException, ex:
7318 
      result.ex = ex
483 rajveer 7319 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7320 
    result.write(oprot)
7321 
    oprot.writeMessageEnd()
7322 
    oprot.trans.flush()
7323 
 
483 rajveer 7324 
  def process_createOrder(self, seqid, iprot, oprot):
7325 
    args = createOrder_args()
94 ashish 7326 
    args.read(iprot)
7327 
    iprot.readMessageEnd()
483 rajveer 7328 
    result = createOrder_result()
94 ashish 7329 
    try:
483 rajveer 7330 
      result.success = self._handler.createOrder(args.order)
94 ashish 7331 
    except TransactionServiceException, ex:
7332 
      result.ex = ex
483 rajveer 7333 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7334 
    result.write(oprot)
7335 
    oprot.writeMessageEnd()
7336 
    oprot.trans.flush()
7337 
 
483 rajveer 7338 
  def process_getOrder(self, seqid, iprot, oprot):
7339 
    args = getOrder_args()
94 ashish 7340 
    args.read(iprot)
7341 
    iprot.readMessageEnd()
483 rajveer 7342 
    result = getOrder_result()
94 ashish 7343 
    try:
483 rajveer 7344 
      result.success = self._handler.getOrder(args.id)
94 ashish 7345 
    except TransactionServiceException, ex:
7346 
      result.ex = ex
483 rajveer 7347 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7348 
    result.write(oprot)
7349 
    oprot.writeMessageEnd()
7350 
    oprot.trans.flush()
7351 
 
483 rajveer 7352 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7353 
    args = getLineItemsForOrder_args()
94 ashish 7354 
    args.read(iprot)
7355 
    iprot.readMessageEnd()
483 rajveer 7356 
    result = getLineItemsForOrder_result()
94 ashish 7357 
    try:
483 rajveer 7358 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7359 
    except TransactionServiceException, ex:
7360 
      result.ex = ex
483 rajveer 7361 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7362 
    result.write(oprot)
7363 
    oprot.writeMessageEnd()
7364 
    oprot.trans.flush()
7365 
 
4999 phani.kuma 7366 
  def process_getOrderList(self, seqid, iprot, oprot):
7367 
    args = getOrderList_args()
7368 
    args.read(iprot)
7369 
    iprot.readMessageEnd()
7370 
    result = getOrderList_result()
7371 
    result.success = self._handler.getOrderList(args.order_ids)
7372 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
5386 phani.kuma 7377 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7378 
    args = getOrderListForVendor_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = getOrderListForVendor_result()
7382 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7383 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7384 
    result.write(oprot)
7385 
    oprot.writeMessageEnd()
7386 
    oprot.trans.flush()
7387 
 
1528 ankur.sing 7388 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7389 
    args = getOrderForCustomer_args()
7390 
    args.read(iprot)
7391 
    iprot.readMessageEnd()
7392 
    result = getOrderForCustomer_result()
7393 
    try:
7394 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7395 
    except TransactionServiceException, ex:
7396 
      result.ex = ex
7397 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7398 
    result.write(oprot)
7399 
    oprot.writeMessageEnd()
7400 
    oprot.trans.flush()
7401 
 
3064 chandransh 7402 
  def process_getAlerts(self, seqid, iprot, oprot):
7403 
    args = getAlerts_args()
7404 
    args.read(iprot)
7405 
    iprot.readMessageEnd()
7406 
    result = getAlerts_result()
4444 rajveer 7407 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7408 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7409 
    result.write(oprot)
7410 
    oprot.writeMessageEnd()
7411 
    oprot.trans.flush()
7412 
 
4394 rajveer 7413 
  def process_addAlert(self, seqid, iprot, oprot):
7414 
    args = addAlert_args()
3064 chandransh 7415 
    args.read(iprot)
7416 
    iprot.readMessageEnd()
4394 rajveer 7417 
    result = addAlert_result()
4444 rajveer 7418 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7419 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7420 
    result.write(oprot)
7421 
    oprot.writeMessageEnd()
7422 
    oprot.trans.flush()
7423 
 
4444 rajveer 7424 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7425 
    args = markAlertsAsSeen_args()
7426 
    args.read(iprot)
7427 
    iprot.readMessageEnd()
7428 
    result = markAlertsAsSeen_result()
7429 
    self._handler.markAlertsAsSeen(args.warehouseId)
7430 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
7434 
 
3064 chandransh 7435 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7436 
    args = getValidOrderCount_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = getValidOrderCount_result()
7440 
    result.success = self._handler.getValidOrderCount()
7441 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
7446 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7447 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
7450 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7451 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7452 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
7456 
 
7457 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7458 
    args = getValidOrdersAmountRange_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = getValidOrdersAmountRange_result()
7462 
    result.success = self._handler.getValidOrdersAmountRange()
7463 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7464 
    result.write(oprot)
7465 
    oprot.writeMessageEnd()
7466 
    oprot.trans.flush()
7467 
 
7468 
  def process_getValidOrders(self, seqid, iprot, oprot):
7469 
    args = getValidOrders_args()
7470 
    args.read(iprot)
7471 
    iprot.readMessageEnd()
7472 
    result = getValidOrders_result()
5874 rajveer 7473 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7474 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7475 
    result.write(oprot)
7476 
    oprot.writeMessageEnd()
7477 
    oprot.trans.flush()
7478 
 
1220 chandransh 7479 
  def process_batchOrders(self, seqid, iprot, oprot):
7480 
    args = batchOrders_args()
7481 
    args.read(iprot)
7482 
    iprot.readMessageEnd()
7483 
    result = batchOrders_result()
7484 
    try:
7485 
      result.success = self._handler.batchOrders(args.warehouseId)
7486 
    except TransactionServiceException, ex:
7487 
      result.ex = ex
7488 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7489 
    result.write(oprot)
7490 
    oprot.writeMessageEnd()
7491 
    oprot.trans.flush()
7492 
 
1208 chandransh 7493 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7494 
    args = markOrderAsOutOfStock_args()
7495 
    args.read(iprot)
7496 
    iprot.readMessageEnd()
7497 
    result = markOrderAsOutOfStock_result()
7498 
    try:
7499 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7500 
    except TransactionServiceException, ex:
7501 
      result.ex = ex
7502 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7506 
 
3064 chandransh 7507 
  def process_verifyOrder(self, seqid, iprot, oprot):
7508 
    args = verifyOrder_args()
759 chandransh 7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
3064 chandransh 7511 
    result = verifyOrder_result()
759 chandransh 7512 
    try:
3064 chandransh 7513 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7514 
    except TransactionServiceException, ex:
7515 
      result.ex = ex
3064 chandransh 7516 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
7520 
 
3064 chandransh 7521 
  def process_acceptOrder(self, seqid, iprot, oprot):
7522 
    args = acceptOrder_args()
1113 chandransh 7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
3064 chandransh 7525 
    result = acceptOrder_result()
1113 chandransh 7526 
    try:
3064 chandransh 7527 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
3064 chandransh 7530 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
3064 chandransh 7535 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7536 
    args = addBillingDetails_args()
1135 chandransh 7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
3064 chandransh 7539 
    result = addBillingDetails_result()
1135 chandransh 7540 
    try:
5110 mandeep.dh 7541 
      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 7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
3064 chandransh 7544 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
7548 
 
4579 rajveer 7549 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7550 
    args = addInvoiceNumber_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = addInvoiceNumber_result()
7554 
    try:
6756 amar.kumar 7555 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
4410 rajveer 7563 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7564 
    args = markOrdersAsShippedFromWarehouse_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = markOrdersAsShippedFromWarehouse_result()
7568 
    try:
4789 rajveer 7569 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
5676 rajveer 7577 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7578 
    args = markOrdersAsReturnedFromStore_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = markOrdersAsReturnedFromStore_result()
7582 
    try:
5713 rajveer 7583 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7584 
    except TransactionServiceException, ex:
7585 
      result.ex = ex
7586 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
3064 chandransh 7591 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7592 
    args = markOrdersAsPickedUp_args()
304 ashish 7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
3064 chandransh 7595 
    result = markOrdersAsPickedUp_result()
7596 
    try:
4910 phani.kuma 7597 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7598 
    except TransactionServiceException, ex:
7599 
      result.ex = ex
7600 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7601 
    result.write(oprot)
7602 
    oprot.writeMessageEnd()
7603 
    oprot.trans.flush()
94 ashish 7604 
 
4910 phani.kuma 7605 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7606 
    args = getOrdersNotPickedUp_args()
7607 
    args.read(iprot)
7608 
    iprot.readMessageEnd()
7609 
    result = getOrdersNotPickedUp_result()
7610 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7611 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7612 
    result.write(oprot)
7613 
    oprot.writeMessageEnd()
7614 
    oprot.trans.flush()
7615 
 
3064 chandransh 7616 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7617 
    args = markOrdersAsDelivered_args()
304 ashish 7618 
    args.read(iprot)
7619 
    iprot.readMessageEnd()
3064 chandransh 7620 
    result = markOrdersAsDelivered_result()
7621 
    try:
7622 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7623 
    except TransactionServiceException, ex:
7624 
      result.ex = ex
7625 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7626 
    result.write(oprot)
7627 
    oprot.writeMessageEnd()
7628 
    oprot.trans.flush()
7629 
 
4910 phani.kuma 7630 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7631 
    args = markAsRTOrders_args()
1596 ankur.sing 7632 
    args.read(iprot)
7633 
    iprot.readMessageEnd()
4910 phani.kuma 7634 
    result = markAsRTOrders_result()
3064 chandransh 7635 
    try:
4910 phani.kuma 7636 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7637 
    except TransactionServiceException, ex:
7638 
      result.ex = ex
4910 phani.kuma 7639 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7640 
    result.write(oprot)
7641 
    oprot.writeMessageEnd()
7642 
    oprot.trans.flush()
304 ashish 7643 
 
4910 phani.kuma 7644 
  def process_getRTOrders(self, seqid, iprot, oprot):
7645 
    args = getRTOrders_args()
7646 
    args.read(iprot)
7647 
    iprot.readMessageEnd()
7648 
    result = getRTOrders_result()
7649 
    result.success = self._handler.getRTOrders(args.providerId)
7650 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7651 
    result.write(oprot)
7652 
    oprot.writeMessageEnd()
7653 
    oprot.trans.flush()
7654 
 
3064 chandransh 7655 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7656 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7657 
    args.read(iprot)
7658 
    iprot.readMessageEnd()
3064 chandransh 7659 
    result = updateNonDeliveryReason_result()
7660 
    try:
4910 phani.kuma 7661 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7662 
    except TransactionServiceException, ex:
7663 
      result.ex = ex
7664 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7665 
    result.write(oprot)
7666 
    oprot.writeMessageEnd()
7667 
    oprot.trans.flush()
1596 ankur.sing 7668 
 
4910 phani.kuma 7669 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7670 
    args = getNonDeliveredOrdersbyCourier_args()
7671 
    args.read(iprot)
7672 
    iprot.readMessageEnd()
7673 
    result = getNonDeliveredOrdersbyCourier_result()
7674 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7675 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7676 
    result.write(oprot)
7677 
    oprot.writeMessageEnd()
7678 
    oprot.trans.flush()
7679 
 
7680 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7681 
    args = markOrdersAsLocalConnected_args()
7682 
    args.read(iprot)
7683 
    iprot.readMessageEnd()
7684 
    result = markOrdersAsLocalConnected_result()
7685 
    try:
7686 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7687 
    except TransactionServiceException, ex:
7688 
      result.ex = ex
7689 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7690 
    result.write(oprot)
7691 
    oprot.writeMessageEnd()
7692 
    oprot.trans.flush()
7693 
 
7694 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7695 
    args = getOrdersNotLocalConnected_args()
7696 
    args.read(iprot)
7697 
    iprot.readMessageEnd()
7698 
    result = getOrdersNotLocalConnected_result()
7699 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7700 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
7704 
 
7705 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7706 
    args = markOrdersAsDestinationCityReached_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = markOrdersAsDestinationCityReached_result()
7710 
    try:
7711 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7712 
    except TransactionServiceException, ex:
7713 
      result.ex = ex
7714 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
7719 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7720 
    args = markOrdersAsFirstDeliveryAttempted_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = markOrdersAsFirstDeliveryAttempted_result()
7724 
    try:
7725 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7726 
    except TransactionServiceException, ex:
7727 
      result.ex = ex
7728 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7729 
    result.write(oprot)
7730 
    oprot.writeMessageEnd()
7731 
    oprot.trans.flush()
7732 
 
3064 chandransh 7733 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7734 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7735 
    args.read(iprot)
7736 
    iprot.readMessageEnd()
3064 chandransh 7737 
    result = getUndeliveredOrders_result()
7738 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7739 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
7743 
 
4783 phani.kuma 7744 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7745 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7749 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7750 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7751 
    result.write(oprot)
7752 
    oprot.writeMessageEnd()
7753 
    oprot.trans.flush()
7754 
 
2536 chandransh 7755 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7756 
    args = toggleDOAFlag_args()
7757 
    args.read(iprot)
7758 
    iprot.readMessageEnd()
7759 
    result = toggleDOAFlag_result()
7760 
    try:
7761 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7762 
    except TransactionServiceException, ex:
7763 
      result.ex = ex
7764 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7765 
    result.write(oprot)
7766 
    oprot.writeMessageEnd()
7767 
    oprot.trans.flush()
1886 ankur.sing 7768 
 
4712 rajveer 7769 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7770 
    args = markOrderAsDelivered_args()
7771 
    args.read(iprot)
7772 
    iprot.readMessageEnd()
7773 
    result = markOrderAsDelivered_result()
7774 
    try:
7775 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7776 
    except TransactionServiceException, ex:
7777 
      result.ex = ex
7778 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
7782 
 
5553 rajveer 7783 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7784 
    args = markOrderAsReceivedAtStore_args()
7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
7787 
    result = markOrderAsReceivedAtStore_result()
7788 
    try:
7789 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7790 
    except TransactionServiceException, ex:
7791 
      result.ex = ex
7792 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
4454 rajveer 7797 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7798 
    args = markOrderDoaRequestReceived_args()
7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
7801 
    result = markOrderDoaRequestReceived_result()
7802 
    try:
7803 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7804 
    except TransactionServiceException, ex:
7805 
      result.ex = ex
7806 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
7810 
 
7811 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7812 
    args = markOrderDoaRequestAuthorized_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = markOrderDoaRequestAuthorized_result()
7816 
    try:
7817 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7818 
    except TransactionServiceException, ex:
7819 
      result.ex = ex
7820 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
7824 
 
4488 rajveer 7825 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7826 
    args = markOrderReturnRequestReceived_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = markOrderReturnRequestReceived_result()
7830 
    try:
7831 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7832 
    except TransactionServiceException, ex:
7833 
      result.ex = ex
7834 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
7838 
 
7839 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7840 
    args = markOrderReturnRequestAuthorized_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = markOrderReturnRequestAuthorized_result()
7844 
    try:
7845 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7846 
    except TransactionServiceException, ex:
7847 
      result.ex = ex
7848 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
7852 
 
2536 chandransh 7853 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7854 
    args = requestPickupNumber_args()
7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
7857 
    result = requestPickupNumber_result()
7858 
    try:
4579 rajveer 7859 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7860 
    except TransactionServiceException, ex:
7861 
      result.ex = ex
7862 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
7867 
  def process_authorizePickup(self, seqid, iprot, oprot):
7868 
    args = authorizePickup_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = authorizePickup_result()
7872 
    try:
4602 rajveer 7873 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7874 
    except TransactionServiceException, ex:
7875 
      result.ex = ex
7876 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
7880 
 
2764 chandransh 7881 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7882 
    args = markDoasAsPickedUp_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7886 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7887 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7888 
    result.write(oprot)
7889 
    oprot.writeMessageEnd()
7890 
    oprot.trans.flush()
7891 
 
4910 phani.kuma 7892 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7893 
    args = getDoasNotPickedUp_args()
7894 
    args.read(iprot)
7895 
    iprot.readMessageEnd()
7896 
    result = getDoasNotPickedUp_result()
7897 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7898 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7899 
    result.write(oprot)
7900 
    oprot.writeMessageEnd()
7901 
    oprot.trans.flush()
7902 
 
4741 phani.kuma 7903 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7904 
    args = markReturnOrdersAsPickedUp_args()
7905 
    args.read(iprot)
7906 
    iprot.readMessageEnd()
7907 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7908 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7909 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
7913 
 
4910 phani.kuma 7914 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7915 
    args = getReturnOrdersNotPickedUp_args()
7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
7918 
    result = getReturnOrdersNotPickedUp_result()
7919 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7920 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7921 
    result.write(oprot)
7922 
    oprot.writeMessageEnd()
7923 
    oprot.trans.flush()
7924 
 
2616 chandransh 7925 
  def process_receiveReturn(self, seqid, iprot, oprot):
7926 
    args = receiveReturn_args()
2591 chandransh 7927 
    args.read(iprot)
7928 
    iprot.readMessageEnd()
2616 chandransh 7929 
    result = receiveReturn_result()
2591 chandransh 7930 
    try:
4479 rajveer 7931 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7932 
    except TransactionServiceException, ex:
7933 
      result.ex = ex
2616 chandransh 7934 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
2536 chandransh 7938 
 
2591 chandransh 7939 
  def process_validateDoa(self, seqid, iprot, oprot):
7940 
    args = validateDoa_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = validateDoa_result()
7944 
    try:
7945 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7946 
    except TransactionServiceException, ex:
7947 
      result.ex = ex
7948 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7949 
    result.write(oprot)
7950 
    oprot.writeMessageEnd()
7951 
    oprot.trans.flush()
7952 
 
4495 rajveer 7953 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7954 
    args = validateReturnProduct_args()
7955 
    args.read(iprot)
7956 
    iprot.readMessageEnd()
7957 
    result = validateReturnProduct_result()
7958 
    try:
7959 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7960 
    except TransactionServiceException, ex:
7961 
      result.ex = ex
7962 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7963 
    result.write(oprot)
7964 
    oprot.writeMessageEnd()
7965 
    oprot.trans.flush()
7966 
 
2616 chandransh 7967 
  def process_reshipOrder(self, seqid, iprot, oprot):
7968 
    args = reshipOrder_args()
7969 
    args.read(iprot)
7970 
    iprot.readMessageEnd()
7971 
    result = reshipOrder_result()
7972 
    try:
7973 
      result.success = self._handler.reshipOrder(args.orderId)
7974 
    except TransactionServiceException, ex:
7975 
      result.ex = ex
7976 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7977 
    result.write(oprot)
7978 
    oprot.writeMessageEnd()
7979 
    oprot.trans.flush()
2591 chandransh 7980 
 
2616 chandransh 7981 
  def process_refundOrder(self, seqid, iprot, oprot):
7982 
    args = refundOrder_args()
7983 
    args.read(iprot)
7984 
    iprot.readMessageEnd()
7985 
    result = refundOrder_result()
7986 
    try:
3226 chandransh 7987 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7988 
    except TransactionServiceException, ex:
7989 
      result.ex = ex
7990 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7991 
    result.write(oprot)
7992 
    oprot.writeMessageEnd()
7993 
    oprot.trans.flush()
7994 
 
2690 chandransh 7995 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7996 
    args = getReturnOrders_args()
7997 
    args.read(iprot)
7998 
    iprot.readMessageEnd()
7999 
    result = getReturnOrders_result()
8000 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8001 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8002 
    result.write(oprot)
8003 
    oprot.writeMessageEnd()
8004 
    oprot.trans.flush()
2616 chandransh 8005 
 
5481 phani.kuma 8006 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8007 
    args = getAllReturnOrders_args()
8008 
    args.read(iprot)
8009 
    iprot.readMessageEnd()
8010 
    result = getAllReturnOrders_result()
8011 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8012 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8013 
    result.write(oprot)
8014 
    oprot.writeMessageEnd()
8015 
    oprot.trans.flush()
8016 
 
2700 chandransh 8017 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8018 
    args = getReturnOrder_args()
8019 
    args.read(iprot)
8020 
    iprot.readMessageEnd()
8021 
    result = getReturnOrder_result()
8022 
    try:
8023 
      result.success = self._handler.getReturnOrder(args.id)
8024 
    except TransactionServiceException, ex:
8025 
      result.ex = ex
8026 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8027 
    result.write(oprot)
8028 
    oprot.writeMessageEnd()
8029 
    oprot.trans.flush()
8030 
 
2690 chandransh 8031 
  def process_processReturn(self, seqid, iprot, oprot):
8032 
    args = processReturn_args()
8033 
    args.read(iprot)
8034 
    iprot.readMessageEnd()
8035 
    result = processReturn_result()
8036 
    try:
8037 
      self._handler.processReturn(args.returnOrderId)
8038 
    except TransactionServiceException, ex:
8039 
      result.ex = ex
8040 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8041 
    result.write(oprot)
8042 
    oprot.writeMessageEnd()
8043 
    oprot.trans.flush()
8044 
 
3451 chandransh 8045 
  def process_updateWeight(self, seqid, iprot, oprot):
8046 
    args = updateWeight_args()
8047 
    args.read(iprot)
8048 
    iprot.readMessageEnd()
8049 
    result = updateWeight_result()
8050 
    try:
8051 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8052 
    except TransactionServiceException, ex:
8053 
      result.ex = ex
8054 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8055 
    result.write(oprot)
8056 
    oprot.writeMessageEnd()
8057 
    oprot.trans.flush()
2819 chandransh 8058 
 
3469 chandransh 8059 
  def process_changeItem(self, seqid, iprot, oprot):
8060 
    args = changeItem_args()
8061 
    args.read(iprot)
8062 
    iprot.readMessageEnd()
8063 
    result = changeItem_result()
8064 
    try:
8065 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8066 
    except TransactionServiceException, ex:
8067 
      result.ex = ex
8068 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8069 
    result.write(oprot)
8070 
    oprot.writeMessageEnd()
8071 
    oprot.trans.flush()
3451 chandransh 8072 
 
3469 chandransh 8073 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8074 
    args = shiftToWarehouse_args()
8075 
    args.read(iprot)
8076 
    iprot.readMessageEnd()
8077 
    result = shiftToWarehouse_result()
8078 
    try:
8079 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8080 
    except TransactionServiceException, ex:
8081 
      result.ex = ex
8082 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8083 
    result.write(oprot)
8084 
    oprot.writeMessageEnd()
8085 
    oprot.trans.flush()
8086 
 
3553 chandransh 8087 
  def process_addDelayReason(self, seqid, iprot, oprot):
8088 
    args = addDelayReason_args()
8089 
    args.read(iprot)
8090 
    iprot.readMessageEnd()
8091 
    result = addDelayReason_result()
8092 
    try:
4647 rajveer 8093 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8094 
    except TransactionServiceException, ex:
8095 
      result.ex = ex
8096 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8097 
    result.write(oprot)
8098 
    oprot.writeMessageEnd()
8099 
    oprot.trans.flush()
3469 chandransh 8100 
 
3956 chandransh 8101 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8102 
    args = reconcileCodCollection_args()
8103 
    args.read(iprot)
8104 
    iprot.readMessageEnd()
8105 
    result = reconcileCodCollection_result()
8106 
    try:
8107 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8108 
    except TransactionServiceException, ex:
8109 
      result.ex = ex
8110 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8111 
    result.write(oprot)
8112 
    oprot.writeMessageEnd()
8113 
    oprot.trans.flush()
3553 chandransh 8114 
 
4008 mandeep.dh 8115 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8116 
    args = getTransactionsRequiringExtraProcessing_args()
8117 
    args.read(iprot)
8118 
    iprot.readMessageEnd()
8119 
    result = getTransactionsRequiringExtraProcessing_result()
8120 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8121 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8122 
    result.write(oprot)
8123 
    oprot.writeMessageEnd()
8124 
    oprot.trans.flush()
3956 chandransh 8125 
 
4008 mandeep.dh 8126 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8127 
    args = markTransactionAsProcessed_args()
8128 
    args.read(iprot)
8129 
    iprot.readMessageEnd()
8130 
    result = markTransactionAsProcessed_result()
8131 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8132 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8133 
    result.write(oprot)
8134 
    oprot.writeMessageEnd()
8135 
    oprot.trans.flush()
8136 
 
4018 chandransh 8137 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8138 
    args = getItemWiseRiskyOrdersCount_args()
8139 
    args.read(iprot)
8140 
    iprot.readMessageEnd()
8141 
    result = getItemWiseRiskyOrdersCount_result()
8142 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8143 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8144 
    result.write(oprot)
8145 
    oprot.writeMessageEnd()
8146 
    oprot.trans.flush()
4008 mandeep.dh 8147 
 
4295 varun.gupt 8148 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8149 
    args = getOrdersForItemIds_args()
8150 
    args.read(iprot)
8151 
    iprot.readMessageEnd()
8152 
    result = getOrdersForItemIds_result()
8153 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8154 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8155 
    result.write(oprot)
8156 
    oprot.writeMessageEnd()
8157 
    oprot.trans.flush()
8158 
 
4247 rajveer 8159 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8160 
    args = markOrderCancellationRequestReceived_args()
8161 
    args.read(iprot)
8162 
    iprot.readMessageEnd()
8163 
    result = markOrderCancellationRequestReceived_result()
8164 
    try:
8165 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8166 
    except TransactionServiceException, ex:
8167 
      result.ex = ex
8168 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8169 
    result.write(oprot)
8170 
    oprot.writeMessageEnd()
8171 
    oprot.trans.flush()
4018 chandransh 8172 
 
4247 rajveer 8173 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8174 
    args = markOrderCancellationRequestConfirmed_args()
8175 
    args.read(iprot)
8176 
    iprot.readMessageEnd()
8177 
    result = markOrderCancellationRequestConfirmed_result()
8178 
    try:
8179 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8180 
    except TransactionServiceException, ex:
8181 
      result.ex = ex
8182 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8183 
    result.write(oprot)
8184 
    oprot.writeMessageEnd()
8185 
    oprot.trans.flush()
8186 
 
8187 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8188 
    args = markOrderCancellationRequestDenied_args()
8189 
    args.read(iprot)
8190 
    iprot.readMessageEnd()
8191 
    result = markOrderCancellationRequestDenied_result()
8192 
    try:
8193 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8194 
    except TransactionServiceException, ex:
8195 
      result.ex = ex
8196 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
8200 
 
4258 rajveer 8201 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8202 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
4258 rajveer 8205 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8206 
    try:
4258 rajveer 8207 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8208 
    except TransactionServiceException, ex:
8209 
      result.ex = ex
4258 rajveer 8210 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
4259 anupam.sin 8215 
  def process_refundTransaction(self, seqid, iprot, oprot):
8216 
    args = refundTransaction_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = refundTransaction_result()
8220 
    try:
8221 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8222 
    except TransactionServiceException, ex:
8223 
      result.ex = ex
8224 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
4247 rajveer 8228 
 
4324 mandeep.dh 8229 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8230 
    args = updateShipmentAddress_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = updateShipmentAddress_result()
8234 
    try:
8235 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8236 
    except TransactionServiceException, ex:
8237 
      result.ex = ex
8238 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8239 
    result.write(oprot)
8240 
    oprot.writeMessageEnd()
8241 
    oprot.trans.flush()
8242 
 
4285 rajveer 8243 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8244 
    args = acceptOrdersForItemId_args()
8245 
    args.read(iprot)
8246 
    iprot.readMessageEnd()
8247 
    result = acceptOrdersForItemId_result()
8248 
    try:
8249 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8250 
    except TransactionServiceException, ex:
8251 
      result.ex = ex
8252 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
4259 anupam.sin 8256 
 
4303 rajveer 8257 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8258 
    args = markOrdersAsPORaised_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = markOrdersAsPORaised_result()
8262 
    try:
4369 rajveer 8263 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8264 
    except TransactionServiceException, ex:
8265 
      result.ex = ex
8266 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
4285 rajveer 8270 
 
4303 rajveer 8271 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8272 
    args = markOrdersAsReversalInitiated_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = markOrdersAsReversalInitiated_result()
8276 
    try:
4369 rajveer 8277 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8278 
    except TransactionServiceException, ex:
8279 
      result.ex = ex
8280 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8281 
    result.write(oprot)
8282 
    oprot.writeMessageEnd()
8283 
    oprot.trans.flush()
8284 
 
8285 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8286 
    args = markOrdersAsNotAvailabke_args()
8287 
    args.read(iprot)
8288 
    iprot.readMessageEnd()
8289 
    result = markOrdersAsNotAvailabke_result()
8290 
    try:
4369 rajveer 8291 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8292 
    except TransactionServiceException, ex:
8293 
      result.ex = ex
8294 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8295 
    result.write(oprot)
8296 
    oprot.writeMessageEnd()
8297 
    oprot.trans.flush()
8298 
 
4369 rajveer 8299 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8300 
    args = markOrdersAsTimeout_args()
8301 
    args.read(iprot)
8302 
    iprot.readMessageEnd()
8303 
    result = markOrdersAsTimeout_result()
8304 
    try:
8305 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8306 
    except TransactionServiceException, ex:
8307 
      result.ex = ex
8308 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8309 
    result.write(oprot)
8310 
    oprot.writeMessageEnd()
8311 
    oprot.trans.flush()
4303 rajveer 8312 
 
4662 rajveer 8313 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8314 
    args = markOrderAsLostInTransit_args()
8315 
    args.read(iprot)
8316 
    iprot.readMessageEnd()
8317 
    result = markOrderAsLostInTransit_result()
8318 
    try:
8319 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8320 
    except TransactionServiceException, ex:
8321 
      result.ex = ex
8322 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8323 
    result.write(oprot)
8324 
    oprot.writeMessageEnd()
8325 
    oprot.trans.flush()
8326 
 
4386 anupam.sin 8327 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8328 
    args = getOrderForAwb_args()
8329 
    args.read(iprot)
8330 
    iprot.readMessageEnd()
8331 
    result = getOrderForAwb_result()
8332 
    try:
8333 
      result.success = self._handler.getOrderForAwb(args.awb)
8334 
    except TransactionServiceException, ex:
8335 
      result.ex = ex
8336 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8337 
    result.write(oprot)
8338 
    oprot.writeMessageEnd()
8339 
    oprot.trans.flush()
4369 rajveer 8340 
 
4506 phani.kuma 8341 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8342 
    args = getOrdersForProviderForStatus_args()
8343 
    args.read(iprot)
8344 
    iprot.readMessageEnd()
8345 
    result = getOrdersForProviderForStatus_result()
8346 
    try:
4910 phani.kuma 8347 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8348 
    except TransactionServiceException, ex:
8349 
      result.ex = ex
8350 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8351 
    result.write(oprot)
8352 
    oprot.writeMessageEnd()
8353 
    oprot.trans.flush()
4386 anupam.sin 8354 
 
4600 varun.gupt 8355 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8356 
    args = getBilledOrdersForVendor_args()
8357 
    args.read(iprot)
8358 
    iprot.readMessageEnd()
8359 
    result = getBilledOrdersForVendor_result()
8360 
    try:
8361 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8362 
    except TransactionServiceException, ex:
8363 
      result.ex = ex
8364 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8365 
    result.write(oprot)
8366 
    oprot.writeMessageEnd()
8367 
    oprot.trans.flush()
4506 phani.kuma 8368 
 
4607 rajveer 8369 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8370 
    args = getSlippedSippingDateOrders_args()
8371 
    args.read(iprot)
8372 
    iprot.readMessageEnd()
8373 
    result = getSlippedSippingDateOrders_result()
8374 
    try:
8375 
      result.success = self._handler.getSlippedSippingDateOrders()
8376 
    except TransactionServiceException, ex:
8377 
      result.ex = ex
8378 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8379 
    result.write(oprot)
8380 
    oprot.writeMessageEnd()
8381 
    oprot.trans.flush()
8382 
 
4709 rajveer 8383 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8384 
    args = getCancelledOrders_args()
8385 
    args.read(iprot)
8386 
    iprot.readMessageEnd()
8387 
    result = getCancelledOrders_result()
8388 
    try:
8389 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8390 
    except TransactionServiceException, ex:
8391 
      result.ex = ex
8392 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
8396 
 
4600 varun.gupt 8397 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8398 
    args = saveBluedartSettlements_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = saveBluedartSettlements_result()
8402 
    try:
8403 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8404 
    except TransactionServiceException, ex:
8405 
      result.ex = ex
8406 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8407 
    result.write(oprot)
8408 
    oprot.writeMessageEnd()
8409 
    oprot.trans.flush()
8410 
 
8411 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8412 
    args = savePaymentSettlements_args()
8413 
    args.read(iprot)
8414 
    iprot.readMessageEnd()
8415 
    result = savePaymentSettlements_result()
8416 
    try:
4905 varun.gupt 8417 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8418 
    except TransactionServiceException, ex:
8419 
      result.ex = ex
8420 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8421 
    result.write(oprot)
8422 
    oprot.writeMessageEnd()
8423 
    oprot.trans.flush()
8424 
 
8425 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8426 
    args = saveEBSSettlementSummary_args()
8427 
    args.read(iprot)
8428 
    iprot.readMessageEnd()
8429 
    result = saveEBSSettlementSummary_result()
8430 
    try:
8431 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8432 
    except TransactionServiceException, ex:
8433 
      result.ex = ex
8434 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8435 
    result.write(oprot)
8436 
    oprot.writeMessageEnd()
8437 
    oprot.trans.flush()
8438 
 
5386 phani.kuma 8439 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8440 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8441 
    args.read(iprot)
8442 
    iprot.readMessageEnd()
5386 phani.kuma 8443 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8444 
    try:
5386 phani.kuma 8445 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8446 
    except TransactionServiceException, ex:
8447 
      result.ex = ex
5386 phani.kuma 8448 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8449 
    result.write(oprot)
8450 
    oprot.writeMessageEnd()
8451 
    oprot.trans.flush()
8452 
 
5386 phani.kuma 8453 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8454 
    args = getSettlementForCod_args()
8455 
    args.read(iprot)
8456 
    iprot.readMessageEnd()
8457 
    result = getSettlementForCod_result()
8458 
    try:
8459 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8460 
    except TransactionServiceException, ex:
8461 
      result.ex = ex
8462 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8463 
    result.write(oprot)
8464 
    oprot.writeMessageEnd()
8465 
    oprot.trans.flush()
8466 
 
4600 varun.gupt 8467 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8468 
    args = getEBSSettlementSummaries_args()
8469 
    args.read(iprot)
8470 
    iprot.readMessageEnd()
8471 
    result = getEBSSettlementSummaries_result()
8472 
    try:
8473 
      result.success = self._handler.getEBSSettlementSummaries()
8474 
    except TransactionServiceException, ex:
8475 
      result.ex = ex
8476 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8477 
    result.write(oprot)
8478 
    oprot.writeMessageEnd()
8479 
    oprot.trans.flush()
8480 
 
8481 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8482 
    args = markEBSSettlementUploaded_args()
8483 
    args.read(iprot)
8484 
    iprot.readMessageEnd()
8485 
    result = markEBSSettlementUploaded_result()
8486 
    try:
8487 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8488 
    except TransactionServiceException, ex:
8489 
      result.ex = ex
8490 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8491 
    result.write(oprot)
8492 
    oprot.writeMessageEnd()
8493 
    oprot.trans.flush()
8494 
 
8495 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8496 
    args = getEBSSettlementDate_args()
8497 
    args.read(iprot)
8498 
    iprot.readMessageEnd()
8499 
    result = getEBSSettlementDate_result()
8500 
    try:
8501 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8502 
    except TransactionServiceException, ex:
8503 
      result.ex = ex
8504 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8505 
    result.write(oprot)
8506 
    oprot.writeMessageEnd()
8507 
    oprot.trans.flush()
8508 
 
4715 varun.gupt 8509 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8510 
    args = getSettlementsByDate_args()
8511 
    args.read(iprot)
8512 
    iprot.readMessageEnd()
8513 
    result = getSettlementsByDate_result()
8514 
    try:
8515 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8516 
    except TransactionServiceException, ex:
8517 
      result.ex = ex
8518 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8519 
    result.write(oprot)
8520 
    oprot.writeMessageEnd()
8521 
    oprot.trans.flush()
4600 varun.gupt 8522 
 
4715 varun.gupt 8523 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8524 
    args = getReshippedOrderIds_args()
8525 
    args.read(iprot)
8526 
    iprot.readMessageEnd()
8527 
    result = getReshippedOrderIds_result()
8528 
    try:
8529 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8530 
    except TransactionServiceException, ex:
8531 
      result.ex = ex
8532 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8533 
    result.write(oprot)
8534 
    oprot.writeMessageEnd()
8535 
    oprot.trans.flush()
8536 
 
5481 phani.kuma 8537 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8538 
    args = getBilledOrders_args()
4875 varun.gupt 8539 
    args.read(iprot)
8540 
    iprot.readMessageEnd()
5481 phani.kuma 8541 
    result = getBilledOrders_result()
4875 varun.gupt 8542 
    try:
5481 phani.kuma 8543 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8544 
    except TransactionServiceException, ex:
8545 
      result.ex = ex
5481 phani.kuma 8546 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8547 
    result.write(oprot)
8548 
    oprot.writeMessageEnd()
8549 
    oprot.trans.flush()
4757 mandeep.dh 8550 
 
5031 varun.gupt 8551 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8552 
    args = getStatusDistributionOfOrders_args()
8553 
    args.read(iprot)
8554 
    iprot.readMessageEnd()
8555 
    result = getStatusDistributionOfOrders_result()
8556 
    try:
8557 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8558 
    except TransactionServiceException, ex:
8559 
      result.ex = ex
8560 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8561 
    result.write(oprot)
8562 
    oprot.writeMessageEnd()
8563 
    oprot.trans.flush()
4875 varun.gupt 8564 
 
5067 varun.gupt 8565 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8566 
    args = getOrderIdsForStatus_args()
8567 
    args.read(iprot)
8568 
    iprot.readMessageEnd()
8569 
    result = getOrderIdsForStatus_result()
8570 
    try:
8571 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8572 
    except TransactionServiceException, ex:
8573 
      result.ex = ex
8574 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8575 
    result.write(oprot)
8576 
    oprot.writeMessageEnd()
8577 
    oprot.trans.flush()
5031 varun.gupt 8578 
 
5348 anupam.sin 8579 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8580 
    args = updateCODAgent_args()
8581 
    args.read(iprot)
8582 
    iprot.readMessageEnd()
8583 
    result = updateCODAgent_result()
8584 
    try:
8585 
      self._handler.updateCODAgent(args.agent, args.orderId)
8586 
    except TransactionServiceException, ex:
8587 
      result.ex = ex
8588 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8589 
    result.write(oprot)
8590 
    oprot.writeMessageEnd()
8591 
    oprot.trans.flush()
8592 
 
5099 varun.gupt 8593 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8594 
    args = updateOrderAsPaidToVendor_args()
8595 
    args.read(iprot)
8596 
    iprot.readMessageEnd()
8597 
    result = updateOrderAsPaidToVendor_result()
8598 
    try:
8599 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8600 
    except TransactionServiceException, ex:
8601 
      result.ex = ex
8602 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8603 
    result.write(oprot)
8604 
    oprot.writeMessageEnd()
8605 
    oprot.trans.flush()
5067 varun.gupt 8606 
 
5386 phani.kuma 8607 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8608 
    args = updateOrderOnlyAsPaidToVendor_args()
8609 
    args.read(iprot)
8610 
    iprot.readMessageEnd()
8611 
    result = updateOrderOnlyAsPaidToVendor_result()
8612 
    try:
8613 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8614 
    except TransactionServiceException, ex:
8615 
      result.ex = ex
8616 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8617 
    result.write(oprot)
8618 
    oprot.writeMessageEnd()
8619 
    oprot.trans.flush()
8620 
 
5208 varun.gupt 8621 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8622 
    args = getRefundedOrdersMarkedPaid_args()
8623 
    args.read(iprot)
8624 
    iprot.readMessageEnd()
8625 
    result = getRefundedOrdersMarkedPaid_result()
8626 
    try:
8627 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8628 
    except TransactionServiceException, ex:
8629 
      result.ex = ex
8630 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8631 
    result.write(oprot)
8632 
    oprot.writeMessageEnd()
8633 
    oprot.trans.flush()
5099 varun.gupt 8634 
 
5447 anupam.sin 8635 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8636 
    args = getAllVerificationAgents_args()
8637 
    args.read(iprot)
8638 
    iprot.readMessageEnd()
8639 
    result = getAllVerificationAgents_result()
8640 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8641 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8642 
    result.write(oprot)
8643 
    oprot.writeMessageEnd()
8644 
    oprot.trans.flush()
5208 varun.gupt 8645 
 
5527 anupam.sin 8646 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8647 
    args = getAllAttributesForOrderId_args()
8648 
    args.read(iprot)
8649 
    iprot.readMessageEnd()
8650 
    result = getAllAttributesForOrderId_result()
8651 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8652 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8653 
    result.write(oprot)
8654 
    oprot.writeMessageEnd()
8655 
    oprot.trans.flush()
5447 anupam.sin 8656 
 
5676 rajveer 8657 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8658 
    args = setOrderAttributes_args()
8659 
    args.read(iprot)
8660 
    iprot.readMessageEnd()
8661 
    result = setOrderAttributes_result()
8662 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8663 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8664 
    result.write(oprot)
8665 
    oprot.writeMessageEnd()
8666 
    oprot.trans.flush()
8667 
 
5527 anupam.sin 8668 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8669 
    args = setOrderAttributeForTransaction_args()
8670 
    args.read(iprot)
8671 
    iprot.readMessageEnd()
8672 
    result = setOrderAttributeForTransaction_result()
8673 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8674 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8675 
    result.write(oprot)
8676 
    oprot.writeMessageEnd()
8677 
    oprot.trans.flush()
8678 
 
5553 rajveer 8679 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8680 
    args = getReceivePendingOrders_args()
8681 
    args.read(iprot)
8682 
    iprot.readMessageEnd()
8683 
    result = getReceivePendingOrders_result()
8684 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8685 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8686 
    result.write(oprot)
8687 
    oprot.writeMessageEnd()
8688 
    oprot.trans.flush()
5527 anupam.sin 8689 
 
5553 rajveer 8690 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8691 
    args = getReceivedAtStoreOrders_args()
8692 
    args.read(iprot)
8693 
    iprot.readMessageEnd()
8694 
    result = getReceivedAtStoreOrders_result()
8695 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8696 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8697 
    result.write(oprot)
8698 
    oprot.writeMessageEnd()
8699 
    oprot.trans.flush()
8700 
 
5713 rajveer 8701 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8702 
    args = getOrdersCollectionAtStore_args()
8703 
    args.read(iprot)
8704 
    iprot.readMessageEnd()
8705 
    result = getOrdersCollectionAtStore_result()
8706 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8707 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8708 
    result.write(oprot)
8709 
    oprot.writeMessageEnd()
8710 
    oprot.trans.flush()
8711 
 
5833 rajveer 8712 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8713 
    args = getOrderAttributeValue_args()
8714 
    args.read(iprot)
8715 
    iprot.readMessageEnd()
8716 
    result = getOrderAttributeValue_result()
8717 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8718 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8719 
    result.write(oprot)
8720 
    oprot.writeMessageEnd()
8721 
    oprot.trans.flush()
8722 
 
6019 rajveer 8723 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8724 
    args = changeJacketNumber_args()
8725 
    args.read(iprot)
8726 
    iprot.readMessageEnd()
8727 
    result = changeJacketNumber_result()
8728 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8729 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8730 
    result.write(oprot)
8731 
    oprot.writeMessageEnd()
8732 
    oprot.trans.flush()
8733 
 
8734 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8735 
    args = markOrderAsRtoInTransit_args()
8736 
    args.read(iprot)
8737 
    iprot.readMessageEnd()
8738 
    result = markOrderAsRtoInTransit_result()
8739 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8740 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8741 
    result.write(oprot)
8742 
    oprot.writeMessageEnd()
8743 
    oprot.trans.flush()
8744 
 
5593 mandeep.dh 8745 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8746 
    args = acceptOrderForItem_args()
8747 
    args.read(iprot)
8748 
    iprot.readMessageEnd()
8749 
    result = acceptOrderForItem_result()
8750 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8751 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8752 
    result.write(oprot)
8753 
    oprot.writeMessageEnd()
8754 
    oprot.trans.flush()
5553 rajveer 8755 
 
6000 mandeep.dh 8756 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8757 
    args = createRechargeOrder_args()
8758 
    args.read(iprot)
8759 
    iprot.readMessageEnd()
8760 
    result = createRechargeOrder_result()
8761 
    try:
8762 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8763 
    except TransactionServiceException, ex:
8764 
      result.ex = ex
8765 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8766 
    result.write(oprot)
8767 
    oprot.writeMessageEnd()
8768 
    oprot.trans.flush()
5593 mandeep.dh 8769 
 
6031 rajveer 8770 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8771 
    args = getRechargeOrder_args()
8772 
    args.read(iprot)
8773 
    iprot.readMessageEnd()
8774 
    result = getRechargeOrder_result()
8775 
    try:
8776 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8777 
    except TransactionServiceException, ex:
8778 
      result.ex = ex
8779 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8780 
    result.write(oprot)
8781 
    oprot.writeMessageEnd()
8782 
    oprot.trans.flush()
8783 
 
8784 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8785 
    args = getRechargeOrders_args()
8786 
    args.read(iprot)
8787 
    iprot.readMessageEnd()
8788 
    result = getRechargeOrders_result()
8789 
    result.success = self._handler.getRechargeOrders(args.userId)
8790 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8791 
    result.write(oprot)
8792 
    oprot.writeMessageEnd()
8793 
    oprot.trans.flush()
8794 
 
6000 mandeep.dh 8795 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8796 
    args = updateRechargeOrderStatus_args()
8797 
    args.read(iprot)
8798 
    iprot.readMessageEnd()
8799 
    result = updateRechargeOrderStatus_result()
8800 
    try:
6031 rajveer 8801 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8802 
    except TransactionServiceException, ex:
8803 
      result.ex = ex
8804 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8805 
    result.write(oprot)
8806 
    oprot.writeMessageEnd()
8807 
    oprot.trans.flush()
8808 
 
8809 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8810 
    args = activateRechargeTxn_args()
8811 
    args.read(iprot)
8812 
    iprot.readMessageEnd()
8813 
    result = activateRechargeTxn_result()
8814 
    try:
6031 rajveer 8815 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8816 
    except TransactionServiceException, ex:
8817 
      result.ex = ex
8818 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8819 
    result.write(oprot)
8820 
    oprot.writeMessageEnd()
8821 
    oprot.trans.flush()
8822 
 
6031 rajveer 8823 
  def process_getUserWallet(self, seqid, iprot, oprot):
8824 
    args = getUserWallet_args()
6000 mandeep.dh 8825 
    args.read(iprot)
8826 
    iprot.readMessageEnd()
6031 rajveer 8827 
    result = getUserWallet_result()
8828 
    result.success = self._handler.getUserWallet(args.userId)
8829 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8830 
    result.write(oprot)
8831 
    oprot.writeMessageEnd()
8832 
    oprot.trans.flush()
8833 
 
6031 rajveer 8834 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8835 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8836 
    args.read(iprot)
8837 
    iprot.readMessageEnd()
6031 rajveer 8838 
    result = getUserWalletHistory_result()
8839 
    result.success = self._handler.getUserWalletHistory(args.userId)
8840 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8841 
    result.write(oprot)
8842 
    oprot.writeMessageEnd()
8843 
    oprot.trans.flush()
8844 
 
6050 anupam.sin 8845 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8846 
    args = getRechargeOrdersForTransaction_args()
8847 
    args.read(iprot)
8848 
    iprot.readMessageEnd()
8849 
    result = getRechargeOrdersForTransaction_result()
8850 
    try:
8851 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8852 
    except TransactionServiceException, ex:
8853 
      result.ex = ex
8854 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8855 
    result.write(oprot)
8856 
    oprot.writeMessageEnd()
8857 
    oprot.trans.flush()
8858 
 
6048 rajveer 8859 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8860 
    args = getServiceProviders_args()
8861 
    args.read(iprot)
8862 
    iprot.readMessageEnd()
8863 
    result = getServiceProviders_result()
6206 rajveer 8864 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8865 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8866 
    result.write(oprot)
8867 
    oprot.writeMessageEnd()
8868 
    oprot.trans.flush()
6000 mandeep.dh 8869 
 
6048 rajveer 8870 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8871 
    args = getServiceProviderForDevice_args()
8872 
    args.read(iprot)
8873 
    iprot.readMessageEnd()
8874 
    result = getServiceProviderForDevice_result()
6049 rajveer 8875 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8876 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8877 
    result.write(oprot)
8878 
    oprot.writeMessageEnd()
8879 
    oprot.trans.flush()
8880 
 
6269 rajveer 8881 
  def process_validateRecharge(self, seqid, iprot, oprot):
8882 
    args = validateRecharge_args()
8883 
    args.read(iprot)
8884 
    iprot.readMessageEnd()
8885 
    result = validateRecharge_result()
6591 anupam.sin 8886 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8887 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8888 
    result.write(oprot)
8889 
    oprot.writeMessageEnd()
8890 
    oprot.trans.flush()
8891 
 
6094 rajveer 8892 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8893 
    args = getRechargeOrdersForDevice_args()
8894 
    args.read(iprot)
8895 
    iprot.readMessageEnd()
8896 
    result = getRechargeOrdersForDevice_result()
8897 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8898 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8899 
    result.write(oprot)
8900 
    oprot.writeMessageEnd()
8901 
    oprot.trans.flush()
6048 rajveer 8902 
 
6094 rajveer 8903 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8904 
    args = addAmountToWallet_args()
8905 
    args.read(iprot)
8906 
    iprot.readMessageEnd()
8907 
    result = addAmountToWallet_result()
8908 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8909 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8910 
    result.write(oprot)
8911 
    oprot.writeMessageEnd()
8912 
    oprot.trans.flush()
8913 
 
6188 rajveer 8914 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8915 
    args = getRechargeStatistics_args()
8916 
    args.read(iprot)
8917 
    iprot.readMessageEnd()
8918 
    result = getRechargeStatistics_result()
8919 
    result.success = self._handler.getRechargeStatistics()
8920 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8921 
    result.write(oprot)
8922 
    oprot.writeMessageEnd()
8923 
    oprot.trans.flush()
8924 
 
6154 rajveer 8925 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8926 
    args = getRechargeOrdersForStatus_args()
8927 
    args.read(iprot)
8928 
    iprot.readMessageEnd()
8929 
    result = getRechargeOrdersForStatus_result()
8930 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8931 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8932 
    result.write(oprot)
8933 
    oprot.writeMessageEnd()
8934 
    oprot.trans.flush()
6094 rajveer 8935 
 
6159 rajveer 8936 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8937 
    args = getPlansForOperator_args()
8938 
    args.read(iprot)
8939 
    iprot.readMessageEnd()
8940 
    result = getPlansForOperator_result()
8941 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8942 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8943 
    result.write(oprot)
8944 
    oprot.writeMessageEnd()
8945 
    oprot.trans.flush()
6154 rajveer 8946 
 
6289 anupam.sin 8947 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8948 
    args = getRechargeDenominations_args()
8949 
    args.read(iprot)
8950 
    iprot.readMessageEnd()
8951 
    result = getRechargeDenominations_result()
8952 
    try:
6307 anupam.sin 8953 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8954 
    except TransactionServiceException, ex:
8955 
      result.ex = ex
8956 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8957 
    result.write(oprot)
8958 
    oprot.writeMessageEnd()
8959 
    oprot.trans.flush()
6159 rajveer 8960 
 
6371 rajveer 8961 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8962 
    args = updateAvailabilityStatus_args()
8963 
    args.read(iprot)
8964 
    iprot.readMessageEnd()
8965 
    result = updateAvailabilityStatus_result()
8966 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8967 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8968 
    result.write(oprot)
8969 
    oprot.writeMessageEnd()
8970 
    oprot.trans.flush()
6289 anupam.sin 8971 
 
6389 rajveer 8972 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8973 
    args = getAvailableEmiSchemes_args()
8974 
    args.read(iprot)
8975 
    iprot.readMessageEnd()
8976 
    result = getAvailableEmiSchemes_result()
8977 
    result.success = self._handler.getAvailableEmiSchemes()
8978 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8979 
    result.write(oprot)
8980 
    oprot.writeMessageEnd()
8981 
    oprot.trans.flush()
6371 rajveer 8982 
 
6389 rajveer 8983 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8984 
    args = getMiscCharges_args()
8985 
    args.read(iprot)
8986 
    iprot.readMessageEnd()
8987 
    result = getMiscCharges_result()
8988 
    result.success = self._handler.getMiscCharges(args.transactionId)
8989 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8990 
    result.write(oprot)
8991 
    oprot.writeMessageEnd()
8992 
    oprot.trans.flush()
8993 
 
6507 anupam.sin 8994 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8995 
    args = refundRechargeOrder_args()
8996 
    args.read(iprot)
8997 
    iprot.readMessageEnd()
8998 
    result = refundRechargeOrder_result()
8999 
    try:
9000 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9001 
    except TransactionServiceException, ex:
9002 
      result.ex = ex
9003 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9004 
    result.write(oprot)
9005 
    oprot.writeMessageEnd()
9006 
    oprot.trans.flush()
6389 rajveer 9007 
 
6821 amar.kumar 9008 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9009 
    args = getPhysicalOrders_args()
9010 
    args.read(iprot)
9011 
    iprot.readMessageEnd()
9012 
    result = getPhysicalOrders_result()
9013 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9014 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9015 
    result.write(oprot)
9016 
    oprot.writeMessageEnd()
9017 
    oprot.trans.flush()
6507 anupam.sin 9018 
 
6906 rajveer 9019 
  def process_getDocument(self, seqid, iprot, oprot):
9020 
    args = getDocument_args()
9021 
    args.read(iprot)
9022 
    iprot.readMessageEnd()
9023 
    result = getDocument_result()
9024 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9025 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9026 
    result.write(oprot)
9027 
    oprot.writeMessageEnd()
9028 
    oprot.trans.flush()
6821 amar.kumar 9029 
 
6985 anupam.sin 9030 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9031 
    args = changeShippingAddress_args()
9032 
    args.read(iprot)
9033 
    iprot.readMessageEnd()
9034 
    result = changeShippingAddress_result()
9035 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9036 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9037 
    result.write(oprot)
9038 
    oprot.writeMessageEnd()
9039 
    oprot.trans.flush()
6906 rajveer 9040 
 
6988 rajveer 9041 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9042 
    args = retrieveInvoice_args()
9043 
    args.read(iprot)
9044 
    iprot.readMessageEnd()
9045 
    result = retrieveInvoice_result()
7075 rajveer 9046 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9047 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9048 
    result.write(oprot)
9049 
    oprot.writeMessageEnd()
9050 
    oprot.trans.flush()
6985 anupam.sin 9051 
 
7026 rajveer 9052 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9053 
    args = receiveUpdatesForRedExpress_args()
9054 
    args.read(iprot)
9055 
    iprot.readMessageEnd()
9056 
    result = receiveUpdatesForRedExpress_result()
9057 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9058 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9059 
    result.write(oprot)
9060 
    oprot.writeMessageEnd()
9061 
    oprot.trans.flush()
6988 rajveer 9062 
 
7073 anupam.sin 9063 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9064 
    args = createRechargeTransaction_args()
9065 
    args.read(iprot)
9066 
    iprot.readMessageEnd()
9067 
    result = createRechargeTransaction_result()
9068 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9069 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9070 
    result.write(oprot)
9071 
    oprot.writeMessageEnd()
9072 
    oprot.trans.flush()
7026 rajveer 9073 
 
7085 rajveer 9074 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9075 
    args = getRechargeTransactions_args()
9076 
    args.read(iprot)
9077 
    iprot.readMessageEnd()
9078 
    result = getRechargeTransactions_result()
9079 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9080 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9081 
    result.write(oprot)
9082 
    oprot.writeMessageEnd()
9083 
    oprot.trans.flush()
9084 
 
7080 anupam.sin 9085 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9086 
    args = getRechargeTransaction_args()
9087 
    args.read(iprot)
9088 
    iprot.readMessageEnd()
9089 
    result = getRechargeTransaction_result()
9090 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9091 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9092 
    result.write(oprot)
9093 
    oprot.writeMessageEnd()
9094 
    oprot.trans.flush()
7073 anupam.sin 9095 
 
7080 anupam.sin 9096 
  def process_getFRCs(self, seqid, iprot, oprot):
9097 
    args = getFRCs_args()
9098 
    args.read(iprot)
9099 
    iprot.readMessageEnd()
9100 
    result = getFRCs_result()
9101 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9102 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9103 
    result.write(oprot)
9104 
    oprot.writeMessageEnd()
9105 
    oprot.trans.flush()
9106 
 
9107 
 
94 ashish 9108 
# HELPER FUNCTIONS AND STRUCTURES
9109 
 
9110 
class createTransaction_args:
9111 
  """
9112 
  Attributes:
9113 
   - transaction
9114 
  """
9115 
 
9116 
  thrift_spec = (
9117 
    None, # 0
9118 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9119 
  )
9120 
 
9121 
  def __init__(self, transaction=None,):
9122 
    self.transaction = transaction
9123 
 
9124 
  def read(self, iprot):
9125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9127 
      return
9128 
    iprot.readStructBegin()
9129 
    while True:
9130 
      (fname, ftype, fid) = iprot.readFieldBegin()
9131 
      if ftype == TType.STOP:
9132 
        break
9133 
      if fid == 1:
9134 
        if ftype == TType.STRUCT:
9135 
          self.transaction = Transaction()
9136 
          self.transaction.read(iprot)
9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      else:
9140 
        iprot.skip(ftype)
9141 
      iprot.readFieldEnd()
9142 
    iprot.readStructEnd()
9143 
 
9144 
  def write(self, oprot):
9145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9147 
      return
9148 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9149 
    if self.transaction is not None:
94 ashish 9150 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9151 
      self.transaction.write(oprot)
9152 
      oprot.writeFieldEnd()
9153 
    oprot.writeFieldStop()
9154 
    oprot.writeStructEnd()
9155 
 
3431 rajveer 9156 
  def validate(self):
9157 
    return
9158 
 
9159 
 
94 ashish 9160 
  def __repr__(self):
9161 
    L = ['%s=%r' % (key, value)
9162 
      for key, value in self.__dict__.iteritems()]
9163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9164 
 
9165 
  def __eq__(self, other):
9166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9167 
 
9168 
  def __ne__(self, other):
9169 
    return not (self == other)
9170 
 
9171 
class createTransaction_result:
9172 
  """
9173 
  Attributes:
132 ashish 9174 
   - success
94 ashish 9175 
   - ex
9176 
  """
9177 
 
9178 
  thrift_spec = (
132 ashish 9179 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9181 
  )
9182 
 
132 ashish 9183 
  def __init__(self, success=None, ex=None,):
9184 
    self.success = success
94 ashish 9185 
    self.ex = ex
9186 
 
9187 
  def read(self, iprot):
9188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9190 
      return
9191 
    iprot.readStructBegin()
9192 
    while True:
9193 
      (fname, ftype, fid) = iprot.readFieldBegin()
9194 
      if ftype == TType.STOP:
9195 
        break
132 ashish 9196 
      if fid == 0:
9197 
        if ftype == TType.I64:
9198 
          self.success = iprot.readI64();
9199 
        else:
9200 
          iprot.skip(ftype)
9201 
      elif fid == 1:
94 ashish 9202 
        if ftype == TType.STRUCT:
9203 
          self.ex = TransactionServiceException()
9204 
          self.ex.read(iprot)
9205 
        else:
9206 
          iprot.skip(ftype)
9207 
      else:
9208 
        iprot.skip(ftype)
9209 
      iprot.readFieldEnd()
9210 
    iprot.readStructEnd()
9211 
 
9212 
  def write(self, oprot):
9213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9215 
      return
9216 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9217 
    if self.success is not None:
132 ashish 9218 
      oprot.writeFieldBegin('success', TType.I64, 0)
9219 
      oprot.writeI64(self.success)
9220 
      oprot.writeFieldEnd()
3431 rajveer 9221 
    if self.ex is not None:
94 ashish 9222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9223 
      self.ex.write(oprot)
9224 
      oprot.writeFieldEnd()
9225 
    oprot.writeFieldStop()
9226 
    oprot.writeStructEnd()
9227 
 
3431 rajveer 9228 
  def validate(self):
9229 
    return
9230 
 
9231 
 
94 ashish 9232 
  def __repr__(self):
9233 
    L = ['%s=%r' % (key, value)
9234 
      for key, value in self.__dict__.iteritems()]
9235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9236 
 
9237 
  def __eq__(self, other):
9238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9239 
 
9240 
  def __ne__(self, other):
9241 
    return not (self == other)
9242 
 
9243 
class getTransaction_args:
9244 
  """
9245 
  Attributes:
9246 
   - id
9247 
  """
9248 
 
9249 
  thrift_spec = (
9250 
    None, # 0
9251 
    (1, TType.I64, 'id', None, None, ), # 1
9252 
  )
9253 
 
9254 
  def __init__(self, id=None,):
9255 
    self.id = id
9256 
 
9257 
  def read(self, iprot):
9258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9260 
      return
9261 
    iprot.readStructBegin()
9262 
    while True:
9263 
      (fname, ftype, fid) = iprot.readFieldBegin()
9264 
      if ftype == TType.STOP:
9265 
        break
9266 
      if fid == 1:
9267 
        if ftype == TType.I64:
9268 
          self.id = iprot.readI64();
9269 
        else:
9270 
          iprot.skip(ftype)
9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
9280 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9281 
    if self.id is not None:
94 ashish 9282 
      oprot.writeFieldBegin('id', TType.I64, 1)
9283 
      oprot.writeI64(self.id)
9284 
      oprot.writeFieldEnd()
9285 
    oprot.writeFieldStop()
9286 
    oprot.writeStructEnd()
9287 
 
3431 rajveer 9288 
  def validate(self):
9289 
    return
9290 
 
9291 
 
94 ashish 9292 
  def __repr__(self):
9293 
    L = ['%s=%r' % (key, value)
9294 
      for key, value in self.__dict__.iteritems()]
9295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9296 
 
9297 
  def __eq__(self, other):
9298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9299 
 
9300 
  def __ne__(self, other):
9301 
    return not (self == other)
9302 
 
9303 
class getTransaction_result:
9304 
  """
9305 
  Attributes:
9306 
   - success
9307 
   - ex
9308 
  """
9309 
 
9310 
  thrift_spec = (
9311 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9313 
  )
9314 
 
9315 
  def __init__(self, success=None, ex=None,):
9316 
    self.success = success
9317 
    self.ex = ex
9318 
 
9319 
  def read(self, iprot):
9320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9322 
      return
9323 
    iprot.readStructBegin()
9324 
    while True:
9325 
      (fname, ftype, fid) = iprot.readFieldBegin()
9326 
      if ftype == TType.STOP:
9327 
        break
9328 
      if fid == 0:
9329 
        if ftype == TType.STRUCT:
9330 
          self.success = Transaction()
9331 
          self.success.read(iprot)
9332 
        else:
9333 
          iprot.skip(ftype)
9334 
      elif fid == 1:
9335 
        if ftype == TType.STRUCT:
9336 
          self.ex = TransactionServiceException()
9337 
          self.ex.read(iprot)
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      else:
9341 
        iprot.skip(ftype)
9342 
      iprot.readFieldEnd()
9343 
    iprot.readStructEnd()
9344 
 
9345 
  def write(self, oprot):
9346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9348 
      return
9349 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9350 
    if self.success is not None:
94 ashish 9351 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9352 
      self.success.write(oprot)
9353 
      oprot.writeFieldEnd()
3431 rajveer 9354 
    if self.ex is not None:
94 ashish 9355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9356 
      self.ex.write(oprot)
9357 
      oprot.writeFieldEnd()
9358 
    oprot.writeFieldStop()
9359 
    oprot.writeStructEnd()
9360 
 
3431 rajveer 9361 
  def validate(self):
9362 
    return
9363 
 
9364 
 
94 ashish 9365 
  def __repr__(self):
9366 
    L = ['%s=%r' % (key, value)
9367 
      for key, value in self.__dict__.iteritems()]
9368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9369 
 
9370 
  def __eq__(self, other):
9371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9372 
 
9373 
  def __ne__(self, other):
9374 
    return not (self == other)
9375 
 
9376 
class getTransactionsForCustomer_args:
9377 
  """
9378 
  Attributes:
9379 
   - customerId
9380 
   - from_date
9381 
   - to_date
9382 
   - status
9383 
  """
9384 
 
9385 
  thrift_spec = (
9386 
    None, # 0
9387 
    (1, TType.I64, 'customerId', None, None, ), # 1
9388 
    (2, TType.I64, 'from_date', None, None, ), # 2
9389 
    (3, TType.I64, 'to_date', None, None, ), # 3
9390 
    (4, TType.I32, 'status', None, None, ), # 4
9391 
  )
9392 
 
9393 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9394 
    self.customerId = customerId
9395 
    self.from_date = from_date
9396 
    self.to_date = to_date
9397 
    self.status = status
9398 
 
9399 
  def read(self, iprot):
9400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9402 
      return
9403 
    iprot.readStructBegin()
9404 
    while True:
9405 
      (fname, ftype, fid) = iprot.readFieldBegin()
9406 
      if ftype == TType.STOP:
9407 
        break
9408 
      if fid == 1:
9409 
        if ftype == TType.I64:
9410 
          self.customerId = iprot.readI64();
9411 
        else:
9412 
          iprot.skip(ftype)
9413 
      elif fid == 2:
9414 
        if ftype == TType.I64:
9415 
          self.from_date = iprot.readI64();
9416 
        else:
9417 
          iprot.skip(ftype)
9418 
      elif fid == 3:
9419 
        if ftype == TType.I64:
9420 
          self.to_date = iprot.readI64();
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      elif fid == 4:
9424 
        if ftype == TType.I32:
9425 
          self.status = iprot.readI32();
9426 
        else:
9427 
          iprot.skip(ftype)
9428 
      else:
9429 
        iprot.skip(ftype)
9430 
      iprot.readFieldEnd()
9431 
    iprot.readStructEnd()
9432 
 
9433 
  def write(self, oprot):
9434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9436 
      return
9437 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9438 
    if self.customerId is not None:
94 ashish 9439 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9440 
      oprot.writeI64(self.customerId)
9441 
      oprot.writeFieldEnd()
3431 rajveer 9442 
    if self.from_date is not None:
94 ashish 9443 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9444 
      oprot.writeI64(self.from_date)
9445 
      oprot.writeFieldEnd()
3431 rajveer 9446 
    if self.to_date is not None:
94 ashish 9447 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9448 
      oprot.writeI64(self.to_date)
9449 
      oprot.writeFieldEnd()
3431 rajveer 9450 
    if self.status is not None:
94 ashish 9451 
      oprot.writeFieldBegin('status', TType.I32, 4)
9452 
      oprot.writeI32(self.status)
9453 
      oprot.writeFieldEnd()
9454 
    oprot.writeFieldStop()
9455 
    oprot.writeStructEnd()
9456 
 
3431 rajveer 9457 
  def validate(self):
9458 
    return
9459 
 
9460 
 
94 ashish 9461 
  def __repr__(self):
9462 
    L = ['%s=%r' % (key, value)
9463 
      for key, value in self.__dict__.iteritems()]
9464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9465 
 
9466 
  def __eq__(self, other):
9467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9468 
 
9469 
  def __ne__(self, other):
9470 
    return not (self == other)
9471 
 
9472 
class getTransactionsForCustomer_result:
9473 
  """
9474 
  Attributes:
9475 
   - success
9476 
   - ex
9477 
  """
9478 
 
9479 
  thrift_spec = (
9480 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9482 
  )
9483 
 
9484 
  def __init__(self, success=None, ex=None,):
9485 
    self.success = success
9486 
    self.ex = ex
9487 
 
9488 
  def read(self, iprot):
9489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9491 
      return
9492 
    iprot.readStructBegin()
9493 
    while True:
9494 
      (fname, ftype, fid) = iprot.readFieldBegin()
9495 
      if ftype == TType.STOP:
9496 
        break
9497 
      if fid == 0:
9498 
        if ftype == TType.LIST:
9499 
          self.success = []
6188 rajveer 9500 
          (_etype109, _size106) = iprot.readListBegin()
9501 
          for _i110 in xrange(_size106):
9502 
            _elem111 = Transaction()
9503 
            _elem111.read(iprot)
9504 
            self.success.append(_elem111)
94 ashish 9505 
          iprot.readListEnd()
9506 
        else:
9507 
          iprot.skip(ftype)
9508 
      elif fid == 1:
9509 
        if ftype == TType.STRUCT:
9510 
          self.ex = TransactionServiceException()
9511 
          self.ex.read(iprot)
9512 
        else:
9513 
          iprot.skip(ftype)
9514 
      else:
9515 
        iprot.skip(ftype)
9516 
      iprot.readFieldEnd()
9517 
    iprot.readStructEnd()
9518 
 
9519 
  def write(self, oprot):
9520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9522 
      return
9523 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9524 
    if self.success is not None:
94 ashish 9525 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9526 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9527 
      for iter112 in self.success:
9528 
        iter112.write(oprot)
94 ashish 9529 
      oprot.writeListEnd()
9530 
      oprot.writeFieldEnd()
3431 rajveer 9531 
    if self.ex is not None:
94 ashish 9532 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9533 
      self.ex.write(oprot)
9534 
      oprot.writeFieldEnd()
9535 
    oprot.writeFieldStop()
9536 
    oprot.writeStructEnd()
9537 
 
3431 rajveer 9538 
  def validate(self):
9539 
    return
9540 
 
9541 
 
94 ashish 9542 
  def __repr__(self):
9543 
    L = ['%s=%r' % (key, value)
9544 
      for key, value in self.__dict__.iteritems()]
9545 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9546 
 
9547 
  def __eq__(self, other):
9548 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9549 
 
9550 
  def __ne__(self, other):
9551 
    return not (self == other)
9552 
 
132 ashish 9553 
class getTransactionsForShoppingCartId_args:
9554 
  """
9555 
  Attributes:
9556 
   - shoppingCartId
9557 
  """
9558 
 
9559 
  thrift_spec = (
9560 
    None, # 0
9561 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9562 
  )
9563 
 
9564 
  def __init__(self, shoppingCartId=None,):
9565 
    self.shoppingCartId = shoppingCartId
9566 
 
9567 
  def read(self, iprot):
9568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9570 
      return
9571 
    iprot.readStructBegin()
9572 
    while True:
9573 
      (fname, ftype, fid) = iprot.readFieldBegin()
9574 
      if ftype == TType.STOP:
9575 
        break
9576 
      if fid == 1:
9577 
        if ftype == TType.I64:
9578 
          self.shoppingCartId = iprot.readI64();
9579 
        else:
9580 
          iprot.skip(ftype)
9581 
      else:
9582 
        iprot.skip(ftype)
9583 
      iprot.readFieldEnd()
9584 
    iprot.readStructEnd()
9585 
 
9586 
  def write(self, oprot):
9587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9589 
      return
9590 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9591 
    if self.shoppingCartId is not None:
132 ashish 9592 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9593 
      oprot.writeI64(self.shoppingCartId)
9594 
      oprot.writeFieldEnd()
9595 
    oprot.writeFieldStop()
9596 
    oprot.writeStructEnd()
9597 
 
3431 rajveer 9598 
  def validate(self):
9599 
    return
9600 
 
9601 
 
132 ashish 9602 
  def __repr__(self):
9603 
    L = ['%s=%r' % (key, value)
9604 
      for key, value in self.__dict__.iteritems()]
9605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9606 
 
9607 
  def __eq__(self, other):
9608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9609 
 
9610 
  def __ne__(self, other):
9611 
    return not (self == other)
9612 
 
9613 
class getTransactionsForShoppingCartId_result:
9614 
  """
9615 
  Attributes:
9616 
   - success
9617 
   - ex
9618 
  """
9619 
 
9620 
  thrift_spec = (
9621 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9622 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9623 
  )
9624 
 
9625 
  def __init__(self, success=None, ex=None,):
9626 
    self.success = success
9627 
    self.ex = ex
9628 
 
9629 
  def read(self, iprot):
9630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9632 
      return
9633 
    iprot.readStructBegin()
9634 
    while True:
9635 
      (fname, ftype, fid) = iprot.readFieldBegin()
9636 
      if ftype == TType.STOP:
9637 
        break
9638 
      if fid == 0:
9639 
        if ftype == TType.LIST:
9640 
          self.success = []
6188 rajveer 9641 
          (_etype116, _size113) = iprot.readListBegin()
9642 
          for _i117 in xrange(_size113):
9643 
            _elem118 = Transaction()
9644 
            _elem118.read(iprot)
9645 
            self.success.append(_elem118)
132 ashish 9646 
          iprot.readListEnd()
9647 
        else:
9648 
          iprot.skip(ftype)
9649 
      elif fid == 1:
9650 
        if ftype == TType.STRUCT:
9651 
          self.ex = TransactionServiceException()
9652 
          self.ex.read(iprot)
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
9664 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9665 
    if self.success is not None:
132 ashish 9666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9667 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9668 
      for iter119 in self.success:
9669 
        iter119.write(oprot)
132 ashish 9670 
      oprot.writeListEnd()
9671 
      oprot.writeFieldEnd()
3431 rajveer 9672 
    if self.ex is not None:
132 ashish 9673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9674 
      self.ex.write(oprot)
9675 
      oprot.writeFieldEnd()
9676 
    oprot.writeFieldStop()
9677 
    oprot.writeStructEnd()
9678 
 
3431 rajveer 9679 
  def validate(self):
9680 
    return
9681 
 
9682 
 
132 ashish 9683 
  def __repr__(self):
9684 
    L = ['%s=%r' % (key, value)
9685 
      for key, value in self.__dict__.iteritems()]
9686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9687 
 
9688 
  def __eq__(self, other):
9689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9690 
 
9691 
  def __ne__(self, other):
9692 
    return not (self == other)
9693 
 
94 ashish 9694 
class getTransactionStatus_args:
9695 
  """
9696 
  Attributes:
9697 
   - transactionId
9698 
  """
9699 
 
9700 
  thrift_spec = (
9701 
    None, # 0
9702 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9703 
  )
9704 
 
9705 
  def __init__(self, transactionId=None,):
9706 
    self.transactionId = transactionId
9707 
 
9708 
  def read(self, iprot):
9709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9711 
      return
9712 
    iprot.readStructBegin()
9713 
    while True:
9714 
      (fname, ftype, fid) = iprot.readFieldBegin()
9715 
      if ftype == TType.STOP:
9716 
        break
9717 
      if fid == 1:
9718 
        if ftype == TType.I64:
9719 
          self.transactionId = iprot.readI64();
9720 
        else:
9721 
          iprot.skip(ftype)
9722 
      else:
9723 
        iprot.skip(ftype)
9724 
      iprot.readFieldEnd()
9725 
    iprot.readStructEnd()
9726 
 
9727 
  def write(self, oprot):
9728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9730 
      return
9731 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9732 
    if self.transactionId is not None:
94 ashish 9733 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9734 
      oprot.writeI64(self.transactionId)
9735 
      oprot.writeFieldEnd()
9736 
    oprot.writeFieldStop()
9737 
    oprot.writeStructEnd()
9738 
 
3431 rajveer 9739 
  def validate(self):
9740 
    return
9741 
 
9742 
 
94 ashish 9743 
  def __repr__(self):
9744 
    L = ['%s=%r' % (key, value)
9745 
      for key, value in self.__dict__.iteritems()]
9746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9747 
 
9748 
  def __eq__(self, other):
9749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9750 
 
9751 
  def __ne__(self, other):
9752 
    return not (self == other)
9753 
 
9754 
class getTransactionStatus_result:
9755 
  """
9756 
  Attributes:
9757 
   - success
9758 
   - ex
9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    (0, TType.I32, 'success', None, None, ), # 0
9763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9764 
  )
9765 
 
9766 
  def __init__(self, success=None, ex=None,):
9767 
    self.success = success
9768 
    self.ex = ex
9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 0:
9780 
        if ftype == TType.I32:
9781 
          self.success = iprot.readI32();
9782 
        else:
9783 
          iprot.skip(ftype)
9784 
      elif fid == 1:
9785 
        if ftype == TType.STRUCT:
9786 
          self.ex = TransactionServiceException()
9787 
          self.ex.read(iprot)
9788 
        else:
9789 
          iprot.skip(ftype)
9790 
      else:
9791 
        iprot.skip(ftype)
9792 
      iprot.readFieldEnd()
9793 
    iprot.readStructEnd()
9794 
 
9795 
  def write(self, oprot):
9796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9798 
      return
9799 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9800 
    if self.success is not None:
94 ashish 9801 
      oprot.writeFieldBegin('success', TType.I32, 0)
9802 
      oprot.writeI32(self.success)
9803 
      oprot.writeFieldEnd()
3431 rajveer 9804 
    if self.ex is not None:
94 ashish 9805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9806 
      self.ex.write(oprot)
9807 
      oprot.writeFieldEnd()
9808 
    oprot.writeFieldStop()
9809 
    oprot.writeStructEnd()
9810 
 
3431 rajveer 9811 
  def validate(self):
9812 
    return
9813 
 
9814 
 
94 ashish 9815 
  def __repr__(self):
9816 
    L = ['%s=%r' % (key, value)
9817 
      for key, value in self.__dict__.iteritems()]
9818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9819 
 
9820 
  def __eq__(self, other):
9821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9822 
 
9823 
  def __ne__(self, other):
9824 
    return not (self == other)
9825 
 
9826 
class changeTransactionStatus_args:
9827 
  """
9828 
  Attributes:
9829 
   - transactionId
9830 
   - status
9831 
   - description
5527 anupam.sin 9832 
   - pickUp
9833 
   - orderType
94 ashish 9834 
  """
9835 
 
9836 
  thrift_spec = (
9837 
    None, # 0
9838 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9839 
    (2, TType.I32, 'status', None, None, ), # 2
9840 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9841 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9842 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9843 
  )
9844 
 
5527 anupam.sin 9845 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9846 
    self.transactionId = transactionId
9847 
    self.status = status
9848 
    self.description = description
5527 anupam.sin 9849 
    self.pickUp = pickUp
9850 
    self.orderType = orderType
94 ashish 9851 
 
9852 
  def read(self, iprot):
9853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9855 
      return
9856 
    iprot.readStructBegin()
9857 
    while True:
9858 
      (fname, ftype, fid) = iprot.readFieldBegin()
9859 
      if ftype == TType.STOP:
9860 
        break
9861 
      if fid == 1:
9862 
        if ftype == TType.I64:
9863 
          self.transactionId = iprot.readI64();
9864 
        else:
9865 
          iprot.skip(ftype)
9866 
      elif fid == 2:
9867 
        if ftype == TType.I32:
9868 
          self.status = iprot.readI32();
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      elif fid == 3:
9872 
        if ftype == TType.STRING:
9873 
          self.description = iprot.readString();
9874 
        else:
9875 
          iprot.skip(ftype)
5387 rajveer 9876 
      elif fid == 4:
5527 anupam.sin 9877 
        if ftype == TType.I64:
9878 
          self.pickUp = iprot.readI64();
5387 rajveer 9879 
        else:
9880 
          iprot.skip(ftype)
5527 anupam.sin 9881 
      elif fid == 5:
9882 
        if ftype == TType.I32:
9883 
          self.orderType = iprot.readI32();
9884 
        else:
9885 
          iprot.skip(ftype)
94 ashish 9886 
      else:
9887 
        iprot.skip(ftype)
9888 
      iprot.readFieldEnd()
9889 
    iprot.readStructEnd()
9890 
 
9891 
  def write(self, oprot):
9892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9894 
      return
9895 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9896 
    if self.transactionId is not None:
94 ashish 9897 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9898 
      oprot.writeI64(self.transactionId)
9899 
      oprot.writeFieldEnd()
3431 rajveer 9900 
    if self.status is not None:
94 ashish 9901 
      oprot.writeFieldBegin('status', TType.I32, 2)
9902 
      oprot.writeI32(self.status)
9903 
      oprot.writeFieldEnd()
3431 rajveer 9904 
    if self.description is not None:
94 ashish 9905 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9906 
      oprot.writeString(self.description)
9907 
      oprot.writeFieldEnd()
5527 anupam.sin 9908 
    if self.pickUp is not None:
9909 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9910 
      oprot.writeI64(self.pickUp)
5387 rajveer 9911 
      oprot.writeFieldEnd()
5527 anupam.sin 9912 
    if self.orderType is not None:
9913 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9914 
      oprot.writeI32(self.orderType)
9915 
      oprot.writeFieldEnd()
94 ashish 9916 
    oprot.writeFieldStop()
9917 
    oprot.writeStructEnd()
9918 
 
3431 rajveer 9919 
  def validate(self):
9920 
    return
9921 
 
9922 
 
94 ashish 9923 
  def __repr__(self):
9924 
    L = ['%s=%r' % (key, value)
9925 
      for key, value in self.__dict__.iteritems()]
9926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9927 
 
9928 
  def __eq__(self, other):
9929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9930 
 
9931 
  def __ne__(self, other):
9932 
    return not (self == other)
9933 
 
9934 
class changeTransactionStatus_result:
9935 
  """
9936 
  Attributes:
9937 
   - success
9938 
   - ex
9939 
  """
9940 
 
9941 
  thrift_spec = (
9942 
    (0, TType.BOOL, 'success', None, None, ), # 0
9943 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9944 
  )
9945 
 
9946 
  def __init__(self, success=None, ex=None,):
9947 
    self.success = success
9948 
    self.ex = ex
9949 
 
9950 
  def read(self, iprot):
9951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9953 
      return
9954 
    iprot.readStructBegin()
9955 
    while True:
9956 
      (fname, ftype, fid) = iprot.readFieldBegin()
9957 
      if ftype == TType.STOP:
9958 
        break
9959 
      if fid == 0:
9960 
        if ftype == TType.BOOL:
9961 
          self.success = iprot.readBool();
9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      elif fid == 1:
9965 
        if ftype == TType.STRUCT:
9966 
          self.ex = TransactionServiceException()
9967 
          self.ex.read(iprot)
9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      else:
9971 
        iprot.skip(ftype)
9972 
      iprot.readFieldEnd()
9973 
    iprot.readStructEnd()
9974 
 
9975 
  def write(self, oprot):
9976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9978 
      return
9979 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9980 
    if self.success is not None:
94 ashish 9981 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9982 
      oprot.writeBool(self.success)
9983 
      oprot.writeFieldEnd()
3431 rajveer 9984 
    if self.ex is not None:
94 ashish 9985 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9986 
      self.ex.write(oprot)
9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
3431 rajveer 9991 
  def validate(self):
9992 
    return
9993 
 
9994 
 
94 ashish 9995 
  def __repr__(self):
9996 
    L = ['%s=%r' % (key, value)
9997 
      for key, value in self.__dict__.iteritems()]
9998 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9999 
 
10000 
  def __eq__(self, other):
10001 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10002 
 
10003 
  def __ne__(self, other):
10004 
    return not (self == other)
10005 
 
1398 varun.gupt 10006 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10007 
  """
10008 
  Attributes:
10009 
   - transactionId
10010 
  """
10011 
 
10012 
  thrift_spec = (
10013 
    None, # 0
10014 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10015 
  )
10016 
 
10017 
  def __init__(self, transactionId=None,):
10018 
    self.transactionId = transactionId
10019 
 
10020 
  def read(self, iprot):
10021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10023 
      return
10024 
    iprot.readStructBegin()
10025 
    while True:
10026 
      (fname, ftype, fid) = iprot.readFieldBegin()
10027 
      if ftype == TType.STOP:
10028 
        break
10029 
      if fid == 1:
10030 
        if ftype == TType.I64:
10031 
          self.transactionId = iprot.readI64();
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      else:
10035 
        iprot.skip(ftype)
10036 
      iprot.readFieldEnd()
10037 
    iprot.readStructEnd()
10038 
 
10039 
  def write(self, oprot):
10040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10042 
      return
1398 varun.gupt 10043 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10044 
    if self.transactionId is not None:
1382 varun.gupt 10045 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10046 
      oprot.writeI64(self.transactionId)
10047 
      oprot.writeFieldEnd()
10048 
    oprot.writeFieldStop()
10049 
    oprot.writeStructEnd()
10050 
 
3431 rajveer 10051 
  def validate(self):
10052 
    return
10053 
 
10054 
 
1382 varun.gupt 10055 
  def __repr__(self):
10056 
    L = ['%s=%r' % (key, value)
10057 
      for key, value in self.__dict__.iteritems()]
10058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10059 
 
10060 
  def __eq__(self, other):
10061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10062 
 
10063 
  def __ne__(self, other):
10064 
    return not (self == other)
10065 
 
1398 varun.gupt 10066 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10067 
  """
10068 
  Attributes:
10069 
   - success
10070 
   - ex
10071 
  """
10072 
 
10073 
  thrift_spec = (
10074 
    (0, TType.BOOL, 'success', None, None, ), # 0
10075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10076 
  )
10077 
 
10078 
  def __init__(self, success=None, ex=None,):
10079 
    self.success = success
10080 
    self.ex = ex
10081 
 
10082 
  def read(self, iprot):
10083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10085 
      return
10086 
    iprot.readStructBegin()
10087 
    while True:
10088 
      (fname, ftype, fid) = iprot.readFieldBegin()
10089 
      if ftype == TType.STOP:
10090 
        break
10091 
      if fid == 0:
10092 
        if ftype == TType.BOOL:
10093 
          self.success = iprot.readBool();
10094 
        else:
10095 
          iprot.skip(ftype)
10096 
      elif fid == 1:
10097 
        if ftype == TType.STRUCT:
10098 
          self.ex = TransactionServiceException()
10099 
          self.ex.read(iprot)
10100 
        else:
10101 
          iprot.skip(ftype)
10102 
      else:
10103 
        iprot.skip(ftype)
10104 
      iprot.readFieldEnd()
10105 
    iprot.readStructEnd()
10106 
 
10107 
  def write(self, oprot):
10108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10110 
      return
1398 varun.gupt 10111 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10112 
    if self.success is not None:
1382 varun.gupt 10113 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10114 
      oprot.writeBool(self.success)
10115 
      oprot.writeFieldEnd()
3431 rajveer 10116 
    if self.ex is not None:
1382 varun.gupt 10117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10118 
      self.ex.write(oprot)
10119 
      oprot.writeFieldEnd()
10120 
    oprot.writeFieldStop()
10121 
    oprot.writeStructEnd()
10122 
 
3431 rajveer 10123 
  def validate(self):
10124 
    return
10125 
 
10126 
 
1382 varun.gupt 10127 
  def __repr__(self):
10128 
    L = ['%s=%r' % (key, value)
10129 
      for key, value in self.__dict__.iteritems()]
10130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10131 
 
10132 
  def __eq__(self, other):
10133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10134 
 
10135 
  def __ne__(self, other):
10136 
    return not (self == other)
10137 
 
483 rajveer 10138 
class getAllOrders_args:
94 ashish 10139 
  """
10140 
  Attributes:
4801 anupam.sin 10141 
   - statuses
483 rajveer 10142 
   - from_date
10143 
   - to_date
10144 
   - warehouse_id
94 ashish 10145 
  """
10146 
 
10147 
  thrift_spec = (
10148 
    None, # 0
4801 anupam.sin 10149 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10150 
    (2, TType.I64, 'from_date', None, None, ), # 2
10151 
    (3, TType.I64, 'to_date', None, None, ), # 3
10152 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10153 
  )
10154 
 
4801 anupam.sin 10155 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10156 
    self.statuses = statuses
483 rajveer 10157 
    self.from_date = from_date
10158 
    self.to_date = to_date
10159 
    self.warehouse_id = warehouse_id
94 ashish 10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 1:
4801 anupam.sin 10171 
        if ftype == TType.LIST:
10172 
          self.statuses = []
6188 rajveer 10173 
          (_etype123, _size120) = iprot.readListBegin()
10174 
          for _i124 in xrange(_size120):
10175 
            _elem125 = iprot.readI32();
10176 
            self.statuses.append(_elem125)
4801 anupam.sin 10177 
          iprot.readListEnd()
94 ashish 10178 
        else:
10179 
          iprot.skip(ftype)
483 rajveer 10180 
      elif fid == 2:
10181 
        if ftype == TType.I64:
10182 
          self.from_date = iprot.readI64();
94 ashish 10183 
        else:
10184 
          iprot.skip(ftype)
483 rajveer 10185 
      elif fid == 3:
10186 
        if ftype == TType.I64:
10187 
          self.to_date = iprot.readI64();
94 ashish 10188 
        else:
10189 
          iprot.skip(ftype)
483 rajveer 10190 
      elif fid == 4:
94 ashish 10191 
        if ftype == TType.I64:
483 rajveer 10192 
          self.warehouse_id = iprot.readI64();
94 ashish 10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      else:
10196 
        iprot.skip(ftype)
10197 
      iprot.readFieldEnd()
10198 
    iprot.readStructEnd()
10199 
 
10200 
  def write(self, oprot):
10201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10203 
      return
483 rajveer 10204 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10205 
    if self.statuses is not None:
10206 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10207 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10208 
      for iter126 in self.statuses:
10209 
        oprot.writeI32(iter126)
4801 anupam.sin 10210 
      oprot.writeListEnd()
94 ashish 10211 
      oprot.writeFieldEnd()
3431 rajveer 10212 
    if self.from_date is not None:
483 rajveer 10213 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10214 
      oprot.writeI64(self.from_date)
94 ashish 10215 
      oprot.writeFieldEnd()
3431 rajveer 10216 
    if self.to_date is not None:
483 rajveer 10217 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10218 
      oprot.writeI64(self.to_date)
94 ashish 10219 
      oprot.writeFieldEnd()
3431 rajveer 10220 
    if self.warehouse_id is not None:
483 rajveer 10221 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10222 
      oprot.writeI64(self.warehouse_id)
94 ashish 10223 
      oprot.writeFieldEnd()
10224 
    oprot.writeFieldStop()
10225 
    oprot.writeStructEnd()
10226 
 
3431 rajveer 10227 
  def validate(self):
10228 
    return
10229 
 
10230 
 
94 ashish 10231 
  def __repr__(self):
10232 
    L = ['%s=%r' % (key, value)
10233 
      for key, value in self.__dict__.iteritems()]
10234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10235 
 
10236 
  def __eq__(self, other):
10237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10238 
 
10239 
  def __ne__(self, other):
10240 
    return not (self == other)
10241 
 
483 rajveer 10242 
class getAllOrders_result:
94 ashish 10243 
  """
10244 
  Attributes:
10245 
   - success
10246 
   - ex
10247 
  """
10248 
 
10249 
  thrift_spec = (
483 rajveer 10250 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10252 
  )
10253 
 
10254 
  def __init__(self, success=None, ex=None,):
10255 
    self.success = success
10256 
    self.ex = ex
10257 
 
10258 
  def read(self, iprot):
10259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10261 
      return
10262 
    iprot.readStructBegin()
10263 
    while True:
10264 
      (fname, ftype, fid) = iprot.readFieldBegin()
10265 
      if ftype == TType.STOP:
10266 
        break
10267 
      if fid == 0:
483 rajveer 10268 
        if ftype == TType.LIST:
10269 
          self.success = []
6188 rajveer 10270 
          (_etype130, _size127) = iprot.readListBegin()
10271 
          for _i131 in xrange(_size127):
10272 
            _elem132 = Order()
10273 
            _elem132.read(iprot)
10274 
            self.success.append(_elem132)
483 rajveer 10275 
          iprot.readListEnd()
94 ashish 10276 
        else:
10277 
          iprot.skip(ftype)
10278 
      elif fid == 1:
10279 
        if ftype == TType.STRUCT:
10280 
          self.ex = TransactionServiceException()
10281 
          self.ex.read(iprot)
10282 
        else:
10283 
          iprot.skip(ftype)
10284 
      else:
10285 
        iprot.skip(ftype)
10286 
      iprot.readFieldEnd()
10287 
    iprot.readStructEnd()
10288 
 
10289 
  def write(self, oprot):
10290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10292 
      return
483 rajveer 10293 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10294 
    if self.success is not None:
483 rajveer 10295 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10296 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10297 
      for iter133 in self.success:
10298 
        iter133.write(oprot)
483 rajveer 10299 
      oprot.writeListEnd()
94 ashish 10300 
      oprot.writeFieldEnd()
3431 rajveer 10301 
    if self.ex is not None:
94 ashish 10302 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10303 
      self.ex.write(oprot)
10304 
      oprot.writeFieldEnd()
10305 
    oprot.writeFieldStop()
10306 
    oprot.writeStructEnd()
10307 
 
3431 rajveer 10308 
  def validate(self):
10309 
    return
10310 
 
10311 
 
94 ashish 10312 
  def __repr__(self):
10313 
    L = ['%s=%r' % (key, value)
10314 
      for key, value in self.__dict__.iteritems()]
10315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10316 
 
10317 
  def __eq__(self, other):
10318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10319 
 
10320 
  def __ne__(self, other):
10321 
    return not (self == other)
10322 
 
4133 chandransh 10323 
class getOrdersInBatch_args:
10324 
  """
10325 
  Attributes:
10326 
   - statuses
10327 
   - offset
10328 
   - limit
10329 
   - warehouse_id
10330 
  """
10331 
 
10332 
  thrift_spec = (
10333 
    None, # 0
10334 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10335 
    (2, TType.I64, 'offset', None, None, ), # 2
10336 
    (3, TType.I64, 'limit', None, None, ), # 3
10337 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10338 
  )
10339 
 
10340 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10341 
    self.statuses = statuses
10342 
    self.offset = offset
10343 
    self.limit = limit
10344 
    self.warehouse_id = warehouse_id
10345 
 
10346 
  def read(self, iprot):
10347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10349 
      return
10350 
    iprot.readStructBegin()
10351 
    while True:
10352 
      (fname, ftype, fid) = iprot.readFieldBegin()
10353 
      if ftype == TType.STOP:
10354 
        break
10355 
      if fid == 1:
10356 
        if ftype == TType.LIST:
10357 
          self.statuses = []
6188 rajveer 10358 
          (_etype137, _size134) = iprot.readListBegin()
10359 
          for _i138 in xrange(_size134):
10360 
            _elem139 = iprot.readI32();
10361 
            self.statuses.append(_elem139)
4133 chandransh 10362 
          iprot.readListEnd()
10363 
        else:
10364 
          iprot.skip(ftype)
10365 
      elif fid == 2:
10366 
        if ftype == TType.I64:
10367 
          self.offset = iprot.readI64();
10368 
        else:
10369 
          iprot.skip(ftype)
10370 
      elif fid == 3:
10371 
        if ftype == TType.I64:
10372 
          self.limit = iprot.readI64();
10373 
        else:
10374 
          iprot.skip(ftype)
10375 
      elif fid == 4:
10376 
        if ftype == TType.I64:
10377 
          self.warehouse_id = iprot.readI64();
10378 
        else:
10379 
          iprot.skip(ftype)
10380 
      else:
10381 
        iprot.skip(ftype)
10382 
      iprot.readFieldEnd()
10383 
    iprot.readStructEnd()
10384 
 
10385 
  def write(self, oprot):
10386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10388 
      return
10389 
    oprot.writeStructBegin('getOrdersInBatch_args')
10390 
    if self.statuses is not None:
10391 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10392 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10393 
      for iter140 in self.statuses:
10394 
        oprot.writeI32(iter140)
4133 chandransh 10395 
      oprot.writeListEnd()
10396 
      oprot.writeFieldEnd()
10397 
    if self.offset is not None:
10398 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10399 
      oprot.writeI64(self.offset)
10400 
      oprot.writeFieldEnd()
10401 
    if self.limit is not None:
10402 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10403 
      oprot.writeI64(self.limit)
10404 
      oprot.writeFieldEnd()
10405 
    if self.warehouse_id is not None:
10406 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10407 
      oprot.writeI64(self.warehouse_id)
10408 
      oprot.writeFieldEnd()
10409 
    oprot.writeFieldStop()
10410 
    oprot.writeStructEnd()
10411 
 
10412 
  def validate(self):
10413 
    return
10414 
 
10415 
 
10416 
  def __repr__(self):
10417 
    L = ['%s=%r' % (key, value)
10418 
      for key, value in self.__dict__.iteritems()]
10419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10420 
 
10421 
  def __eq__(self, other):
10422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10423 
 
10424 
  def __ne__(self, other):
10425 
    return not (self == other)
10426 
 
10427 
class getOrdersInBatch_result:
10428 
  """
10429 
  Attributes:
10430 
   - success
10431 
   - ex
10432 
  """
10433 
 
10434 
  thrift_spec = (
10435 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10437 
  )
10438 
 
10439 
  def __init__(self, success=None, ex=None,):
10440 
    self.success = success
10441 
    self.ex = ex
10442 
 
10443 
  def read(self, iprot):
10444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10446 
      return
10447 
    iprot.readStructBegin()
10448 
    while True:
10449 
      (fname, ftype, fid) = iprot.readFieldBegin()
10450 
      if ftype == TType.STOP:
10451 
        break
10452 
      if fid == 0:
10453 
        if ftype == TType.LIST:
10454 
          self.success = []
6188 rajveer 10455 
          (_etype144, _size141) = iprot.readListBegin()
10456 
          for _i145 in xrange(_size141):
10457 
            _elem146 = Order()
10458 
            _elem146.read(iprot)
10459 
            self.success.append(_elem146)
4133 chandransh 10460 
          iprot.readListEnd()
10461 
        else:
10462 
          iprot.skip(ftype)
10463 
      elif fid == 1:
10464 
        if ftype == TType.STRUCT:
10465 
          self.ex = TransactionServiceException()
10466 
          self.ex.read(iprot)
10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      else:
10470 
        iprot.skip(ftype)
10471 
      iprot.readFieldEnd()
10472 
    iprot.readStructEnd()
10473 
 
10474 
  def write(self, oprot):
10475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10477 
      return
10478 
    oprot.writeStructBegin('getOrdersInBatch_result')
10479 
    if self.success is not None:
10480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10481 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10482 
      for iter147 in self.success:
10483 
        iter147.write(oprot)
4133 chandransh 10484 
      oprot.writeListEnd()
10485 
      oprot.writeFieldEnd()
10486 
    if self.ex is not None:
10487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10488 
      self.ex.write(oprot)
10489 
      oprot.writeFieldEnd()
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
10508 
class getOrderCount_args:
10509 
  """
10510 
  Attributes:
10511 
   - statuses
10512 
   - warehouseId
10513 
  """
10514 
 
10515 
  thrift_spec = (
10516 
    None, # 0
10517 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10518 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10519 
  )
10520 
 
10521 
  def __init__(self, statuses=None, warehouseId=None,):
10522 
    self.statuses = statuses
10523 
    self.warehouseId = warehouseId
10524 
 
10525 
  def read(self, iprot):
10526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10528 
      return
10529 
    iprot.readStructBegin()
10530 
    while True:
10531 
      (fname, ftype, fid) = iprot.readFieldBegin()
10532 
      if ftype == TType.STOP:
10533 
        break
10534 
      if fid == 1:
10535 
        if ftype == TType.LIST:
10536 
          self.statuses = []
6188 rajveer 10537 
          (_etype151, _size148) = iprot.readListBegin()
10538 
          for _i152 in xrange(_size148):
10539 
            _elem153 = iprot.readI32();
10540 
            self.statuses.append(_elem153)
4133 chandransh 10541 
          iprot.readListEnd()
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      elif fid == 2:
10545 
        if ftype == TType.I64:
10546 
          self.warehouseId = iprot.readI64();
10547 
        else:
10548 
          iprot.skip(ftype)
10549 
      else:
10550 
        iprot.skip(ftype)
10551 
      iprot.readFieldEnd()
10552 
    iprot.readStructEnd()
10553 
 
10554 
  def write(self, oprot):
10555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10557 
      return
10558 
    oprot.writeStructBegin('getOrderCount_args')
10559 
    if self.statuses is not None:
10560 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10561 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10562 
      for iter154 in self.statuses:
10563 
        oprot.writeI32(iter154)
4133 chandransh 10564 
      oprot.writeListEnd()
10565 
      oprot.writeFieldEnd()
10566 
    if self.warehouseId is not None:
10567 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10568 
      oprot.writeI64(self.warehouseId)
10569 
      oprot.writeFieldEnd()
10570 
    oprot.writeFieldStop()
10571 
    oprot.writeStructEnd()
10572 
 
10573 
  def validate(self):
10574 
    return
10575 
 
10576 
 
10577 
  def __repr__(self):
10578 
    L = ['%s=%r' % (key, value)
10579 
      for key, value in self.__dict__.iteritems()]
10580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10581 
 
10582 
  def __eq__(self, other):
10583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10584 
 
10585 
  def __ne__(self, other):
10586 
    return not (self == other)
10587 
 
10588 
class getOrderCount_result:
10589 
  """
10590 
  Attributes:
10591 
   - success
10592 
   - ex
10593 
  """
10594 
 
10595 
  thrift_spec = (
10596 
    (0, TType.I32, 'success', None, None, ), # 0
10597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10598 
  )
10599 
 
10600 
  def __init__(self, success=None, ex=None,):
10601 
    self.success = success
10602 
    self.ex = ex
10603 
 
10604 
  def read(self, iprot):
10605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10607 
      return
10608 
    iprot.readStructBegin()
10609 
    while True:
10610 
      (fname, ftype, fid) = iprot.readFieldBegin()
10611 
      if ftype == TType.STOP:
10612 
        break
10613 
      if fid == 0:
10614 
        if ftype == TType.I32:
10615 
          self.success = iprot.readI32();
10616 
        else:
10617 
          iprot.skip(ftype)
10618 
      elif fid == 1:
10619 
        if ftype == TType.STRUCT:
10620 
          self.ex = TransactionServiceException()
10621 
          self.ex.read(iprot)
10622 
        else:
10623 
          iprot.skip(ftype)
10624 
      else:
10625 
        iprot.skip(ftype)
10626 
      iprot.readFieldEnd()
10627 
    iprot.readStructEnd()
10628 
 
10629 
  def write(self, oprot):
10630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10632 
      return
10633 
    oprot.writeStructBegin('getOrderCount_result')
10634 
    if self.success is not None:
10635 
      oprot.writeFieldBegin('success', TType.I32, 0)
10636 
      oprot.writeI32(self.success)
10637 
      oprot.writeFieldEnd()
10638 
    if self.ex is not None:
10639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10640 
      self.ex.write(oprot)
10641 
      oprot.writeFieldEnd()
10642 
    oprot.writeFieldStop()
10643 
    oprot.writeStructEnd()
10644 
 
10645 
  def validate(self):
10646 
    return
10647 
 
10648 
 
10649 
  def __repr__(self):
10650 
    L = ['%s=%r' % (key, value)
10651 
      for key, value in self.__dict__.iteritems()]
10652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10653 
 
10654 
  def __eq__(self, other):
10655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10656 
 
10657 
  def __ne__(self, other):
10658 
    return not (self == other)
10659 
 
999 varun.gupt 10660 
class getOrdersByBillingDate_args:
10661 
  """
10662 
  Attributes:
10663 
   - status
10664 
   - start_billing_date
10665 
   - end_billing_date
10666 
   - warehouse_id
10667 
  """
10668 
 
10669 
  thrift_spec = (
10670 
    None, # 0
10671 
    (1, TType.I32, 'status', None, None, ), # 1
10672 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10673 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10674 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10675 
  )
10676 
 
10677 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10678 
    self.status = status
10679 
    self.start_billing_date = start_billing_date
10680 
    self.end_billing_date = end_billing_date
10681 
    self.warehouse_id = warehouse_id
10682 
 
10683 
  def read(self, iprot):
10684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10686 
      return
10687 
    iprot.readStructBegin()
10688 
    while True:
10689 
      (fname, ftype, fid) = iprot.readFieldBegin()
10690 
      if ftype == TType.STOP:
10691 
        break
10692 
      if fid == 1:
10693 
        if ftype == TType.I32:
10694 
          self.status = iprot.readI32();
10695 
        else:
10696 
          iprot.skip(ftype)
10697 
      elif fid == 2:
10698 
        if ftype == TType.I64:
10699 
          self.start_billing_date = iprot.readI64();
10700 
        else:
10701 
          iprot.skip(ftype)
10702 
      elif fid == 3:
10703 
        if ftype == TType.I64:
10704 
          self.end_billing_date = iprot.readI64();
10705 
        else:
10706 
          iprot.skip(ftype)
10707 
      elif fid == 4:
10708 
        if ftype == TType.I64:
10709 
          self.warehouse_id = iprot.readI64();
10710 
        else:
10711 
          iprot.skip(ftype)
10712 
      else:
10713 
        iprot.skip(ftype)
10714 
      iprot.readFieldEnd()
10715 
    iprot.readStructEnd()
10716 
 
10717 
  def write(self, oprot):
10718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10720 
      return
10721 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10722 
    if self.status is not None:
999 varun.gupt 10723 
      oprot.writeFieldBegin('status', TType.I32, 1)
10724 
      oprot.writeI32(self.status)
10725 
      oprot.writeFieldEnd()
3431 rajveer 10726 
    if self.start_billing_date is not None:
999 varun.gupt 10727 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10728 
      oprot.writeI64(self.start_billing_date)
10729 
      oprot.writeFieldEnd()
3431 rajveer 10730 
    if self.end_billing_date is not None:
999 varun.gupt 10731 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10732 
      oprot.writeI64(self.end_billing_date)
10733 
      oprot.writeFieldEnd()
3431 rajveer 10734 
    if self.warehouse_id is not None:
999 varun.gupt 10735 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10736 
      oprot.writeI64(self.warehouse_id)
10737 
      oprot.writeFieldEnd()
10738 
    oprot.writeFieldStop()
10739 
    oprot.writeStructEnd()
10740 
 
3431 rajveer 10741 
  def validate(self):
10742 
    return
10743 
 
10744 
 
999 varun.gupt 10745 
  def __repr__(self):
10746 
    L = ['%s=%r' % (key, value)
10747 
      for key, value in self.__dict__.iteritems()]
10748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10749 
 
10750 
  def __eq__(self, other):
10751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10752 
 
10753 
  def __ne__(self, other):
10754 
    return not (self == other)
10755 
 
10756 
class getOrdersByBillingDate_result:
10757 
  """
10758 
  Attributes:
10759 
   - success
10760 
   - ex
10761 
  """
10762 
 
10763 
  thrift_spec = (
10764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10766 
  )
10767 
 
10768 
  def __init__(self, success=None, ex=None,):
10769 
    self.success = success
10770 
    self.ex = ex
10771 
 
10772 
  def read(self, iprot):
10773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10775 
      return
10776 
    iprot.readStructBegin()
10777 
    while True:
10778 
      (fname, ftype, fid) = iprot.readFieldBegin()
10779 
      if ftype == TType.STOP:
10780 
        break
10781 
      if fid == 0:
10782 
        if ftype == TType.LIST:
10783 
          self.success = []
6188 rajveer 10784 
          (_etype158, _size155) = iprot.readListBegin()
10785 
          for _i159 in xrange(_size155):
10786 
            _elem160 = Order()
10787 
            _elem160.read(iprot)
10788 
            self.success.append(_elem160)
999 varun.gupt 10789 
          iprot.readListEnd()
10790 
        else:
10791 
          iprot.skip(ftype)
10792 
      elif fid == 1:
10793 
        if ftype == TType.STRUCT:
10794 
          self.ex = TransactionServiceException()
10795 
          self.ex.read(iprot)
10796 
        else:
10797 
          iprot.skip(ftype)
10798 
      else:
10799 
        iprot.skip(ftype)
10800 
      iprot.readFieldEnd()
10801 
    iprot.readStructEnd()
10802 
 
10803 
  def write(self, oprot):
10804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10806 
      return
10807 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10808 
    if self.success is not None:
999 varun.gupt 10809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10811 
      for iter161 in self.success:
10812 
        iter161.write(oprot)
999 varun.gupt 10813 
      oprot.writeListEnd()
10814 
      oprot.writeFieldEnd()
3431 rajveer 10815 
    if self.ex is not None:
999 varun.gupt 10816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10817 
      self.ex.write(oprot)
10818 
      oprot.writeFieldEnd()
10819 
    oprot.writeFieldStop()
10820 
    oprot.writeStructEnd()
10821 
 
3431 rajveer 10822 
  def validate(self):
10823 
    return
10824 
 
10825 
 
999 varun.gupt 10826 
  def __repr__(self):
10827 
    L = ['%s=%r' % (key, value)
10828 
      for key, value in self.__dict__.iteritems()]
10829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10830 
 
10831 
  def __eq__(self, other):
10832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10833 
 
10834 
  def __ne__(self, other):
10835 
    return not (self == other)
10836 
 
3427 chandransh 10837 
class getOrdersByShippingDate_args:
10838 
  """
10839 
  Attributes:
10840 
   - fromShippingDate
10841 
   - toShippingDate
10842 
   - providerId
10843 
   - warehouseId
3451 chandransh 10844 
   - cod
3427 chandransh 10845 
  """
10846 
 
10847 
  thrift_spec = (
10848 
    None, # 0
10849 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10850 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10851 
    (3, TType.I64, 'providerId', None, None, ), # 3
10852 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10853 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10854 
  )
10855 
 
3451 chandransh 10856 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10857 
    self.fromShippingDate = fromShippingDate
10858 
    self.toShippingDate = toShippingDate
10859 
    self.providerId = providerId
10860 
    self.warehouseId = warehouseId
3451 chandransh 10861 
    self.cod = cod
3427 chandransh 10862 
 
10863 
  def read(self, iprot):
10864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10866 
      return
10867 
    iprot.readStructBegin()
10868 
    while True:
10869 
      (fname, ftype, fid) = iprot.readFieldBegin()
10870 
      if ftype == TType.STOP:
10871 
        break
10872 
      if fid == 1:
10873 
        if ftype == TType.I64:
10874 
          self.fromShippingDate = iprot.readI64();
10875 
        else:
10876 
          iprot.skip(ftype)
10877 
      elif fid == 2:
10878 
        if ftype == TType.I64:
10879 
          self.toShippingDate = iprot.readI64();
10880 
        else:
10881 
          iprot.skip(ftype)
10882 
      elif fid == 3:
10883 
        if ftype == TType.I64:
10884 
          self.providerId = iprot.readI64();
10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      elif fid == 4:
10888 
        if ftype == TType.I64:
10889 
          self.warehouseId = iprot.readI64();
10890 
        else:
10891 
          iprot.skip(ftype)
3451 chandransh 10892 
      elif fid == 5:
10893 
        if ftype == TType.BOOL:
10894 
          self.cod = iprot.readBool();
10895 
        else:
10896 
          iprot.skip(ftype)
3427 chandransh 10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
10906 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10907 
    if self.fromShippingDate is not None:
3427 chandransh 10908 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10909 
      oprot.writeI64(self.fromShippingDate)
10910 
      oprot.writeFieldEnd()
3431 rajveer 10911 
    if self.toShippingDate is not None:
3427 chandransh 10912 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10913 
      oprot.writeI64(self.toShippingDate)
10914 
      oprot.writeFieldEnd()
3431 rajveer 10915 
    if self.providerId is not None:
3427 chandransh 10916 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10917 
      oprot.writeI64(self.providerId)
10918 
      oprot.writeFieldEnd()
3431 rajveer 10919 
    if self.warehouseId is not None:
3427 chandransh 10920 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10921 
      oprot.writeI64(self.warehouseId)
10922 
      oprot.writeFieldEnd()
3451 chandransh 10923 
    if self.cod is not None:
10924 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10925 
      oprot.writeBool(self.cod)
10926 
      oprot.writeFieldEnd()
3427 chandransh 10927 
    oprot.writeFieldStop()
10928 
    oprot.writeStructEnd()
10929 
 
3431 rajveer 10930 
  def validate(self):
10931 
    return
10932 
 
10933 
 
3427 chandransh 10934 
  def __repr__(self):
10935 
    L = ['%s=%r' % (key, value)
10936 
      for key, value in self.__dict__.iteritems()]
10937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10938 
 
10939 
  def __eq__(self, other):
10940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10941 
 
10942 
  def __ne__(self, other):
10943 
    return not (self == other)
10944 
 
10945 
class getOrdersByShippingDate_result:
10946 
  """
10947 
  Attributes:
10948 
   - success
10949 
   - ex
10950 
  """
10951 
 
10952 
  thrift_spec = (
10953 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10954 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10955 
  )
10956 
 
10957 
  def __init__(self, success=None, ex=None,):
10958 
    self.success = success
10959 
    self.ex = ex
10960 
 
10961 
  def read(self, iprot):
10962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10964 
      return
10965 
    iprot.readStructBegin()
10966 
    while True:
10967 
      (fname, ftype, fid) = iprot.readFieldBegin()
10968 
      if ftype == TType.STOP:
10969 
        break
10970 
      if fid == 0:
10971 
        if ftype == TType.LIST:
10972 
          self.success = []
6188 rajveer 10973 
          (_etype165, _size162) = iprot.readListBegin()
10974 
          for _i166 in xrange(_size162):
10975 
            _elem167 = Order()
10976 
            _elem167.read(iprot)
10977 
            self.success.append(_elem167)
3427 chandransh 10978 
          iprot.readListEnd()
10979 
        else:
10980 
          iprot.skip(ftype)
10981 
      elif fid == 1:
10982 
        if ftype == TType.STRUCT:
10983 
          self.ex = TransactionServiceException()
10984 
          self.ex.read(iprot)
10985 
        else:
10986 
          iprot.skip(ftype)
10987 
      else:
10988 
        iprot.skip(ftype)
10989 
      iprot.readFieldEnd()
10990 
    iprot.readStructEnd()
10991 
 
10992 
  def write(self, oprot):
10993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10995 
      return
10996 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10997 
    if self.success is not None:
3427 chandransh 10998 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10999 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11000 
      for iter168 in self.success:
11001 
        iter168.write(oprot)
3427 chandransh 11002 
      oprot.writeListEnd()
11003 
      oprot.writeFieldEnd()
3431 rajveer 11004 
    if self.ex is not None:
3427 chandransh 11005 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11006 
      self.ex.write(oprot)
11007 
      oprot.writeFieldEnd()
11008 
    oprot.writeFieldStop()
11009 
    oprot.writeStructEnd()
11010 
 
3431 rajveer 11011 
  def validate(self):
11012 
    return
11013 
 
11014 
 
3427 chandransh 11015 
  def __repr__(self):
11016 
    L = ['%s=%r' % (key, value)
11017 
      for key, value in self.__dict__.iteritems()]
11018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11019 
 
11020 
  def __eq__(self, other):
11021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11022 
 
11023 
  def __ne__(self, other):
11024 
    return not (self == other)
11025 
 
1382 varun.gupt 11026 
class getReturnableOrdersForCustomer_args:
11027 
  """
11028 
  Attributes:
11029 
   - customer_id
11030 
   - limit
11031 
  """
11032 
 
11033 
  thrift_spec = (
11034 
    None, # 0
11035 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11036 
    (2, TType.I64, 'limit', None, None, ), # 2
11037 
  )
11038 
 
11039 
  def __init__(self, customer_id=None, limit=None,):
11040 
    self.customer_id = customer_id
11041 
    self.limit = limit
11042 
 
11043 
  def read(self, iprot):
11044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11046 
      return
11047 
    iprot.readStructBegin()
11048 
    while True:
11049 
      (fname, ftype, fid) = iprot.readFieldBegin()
11050 
      if ftype == TType.STOP:
11051 
        break
11052 
      if fid == 1:
11053 
        if ftype == TType.I64:
11054 
          self.customer_id = iprot.readI64();
11055 
        else:
11056 
          iprot.skip(ftype)
11057 
      elif fid == 2:
11058 
        if ftype == TType.I64:
11059 
          self.limit = iprot.readI64();
11060 
        else:
11061 
          iprot.skip(ftype)
11062 
      else:
11063 
        iprot.skip(ftype)
11064 
      iprot.readFieldEnd()
11065 
    iprot.readStructEnd()
11066 
 
11067 
  def write(self, oprot):
11068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11070 
      return
11071 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11072 
    if self.customer_id is not None:
1382 varun.gupt 11073 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11074 
      oprot.writeI64(self.customer_id)
11075 
      oprot.writeFieldEnd()
3431 rajveer 11076 
    if self.limit is not None:
1382 varun.gupt 11077 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11078 
      oprot.writeI64(self.limit)
11079 
      oprot.writeFieldEnd()
11080 
    oprot.writeFieldStop()
11081 
    oprot.writeStructEnd()
11082 
 
3431 rajveer 11083 
  def validate(self):
11084 
    return
11085 
 
11086 
 
1382 varun.gupt 11087 
  def __repr__(self):
11088 
    L = ['%s=%r' % (key, value)
11089 
      for key, value in self.__dict__.iteritems()]
11090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11091 
 
11092 
  def __eq__(self, other):
11093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11094 
 
11095 
  def __ne__(self, other):
11096 
    return not (self == other)
11097 
 
11098 
class getReturnableOrdersForCustomer_result:
11099 
  """
11100 
  Attributes:
11101 
   - success
11102 
   - ex
11103 
  """
11104 
 
11105 
  thrift_spec = (
11106 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11107 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11108 
  )
11109 
 
11110 
  def __init__(self, success=None, ex=None,):
11111 
    self.success = success
11112 
    self.ex = ex
11113 
 
11114 
  def read(self, iprot):
11115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11117 
      return
11118 
    iprot.readStructBegin()
11119 
    while True:
11120 
      (fname, ftype, fid) = iprot.readFieldBegin()
11121 
      if ftype == TType.STOP:
11122 
        break
11123 
      if fid == 0:
11124 
        if ftype == TType.LIST:
11125 
          self.success = []
6188 rajveer 11126 
          (_etype172, _size169) = iprot.readListBegin()
11127 
          for _i173 in xrange(_size169):
11128 
            _elem174 = iprot.readI64();
11129 
            self.success.append(_elem174)
1382 varun.gupt 11130 
          iprot.readListEnd()
11131 
        else:
11132 
          iprot.skip(ftype)
11133 
      elif fid == 1:
11134 
        if ftype == TType.STRUCT:
11135 
          self.ex = TransactionServiceException()
11136 
          self.ex.read(iprot)
11137 
        else:
11138 
          iprot.skip(ftype)
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11149 
    if self.success is not None:
1382 varun.gupt 11150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11151 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11152 
      for iter175 in self.success:
11153 
        oprot.writeI64(iter175)
1382 varun.gupt 11154 
      oprot.writeListEnd()
11155 
      oprot.writeFieldEnd()
3431 rajveer 11156 
    if self.ex is not None:
1382 varun.gupt 11157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11158 
      self.ex.write(oprot)
11159 
      oprot.writeFieldEnd()
11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
1382 varun.gupt 11167 
  def __repr__(self):
11168 
    L = ['%s=%r' % (key, value)
11169 
      for key, value in self.__dict__.iteritems()]
11170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11171 
 
11172 
  def __eq__(self, other):
11173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11174 
 
11175 
  def __ne__(self, other):
11176 
    return not (self == other)
11177 
 
11178 
class getCancellableOrdersForCustomer_args:
11179 
  """
11180 
  Attributes:
11181 
   - customer_id
11182 
   - limit
11183 
  """
11184 
 
11185 
  thrift_spec = (
11186 
    None, # 0
11187 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11188 
    (2, TType.I64, 'limit', None, None, ), # 2
11189 
  )
11190 
 
11191 
  def __init__(self, customer_id=None, limit=None,):
11192 
    self.customer_id = customer_id
11193 
    self.limit = limit
11194 
 
11195 
  def read(self, iprot):
11196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11198 
      return
11199 
    iprot.readStructBegin()
11200 
    while True:
11201 
      (fname, ftype, fid) = iprot.readFieldBegin()
11202 
      if ftype == TType.STOP:
11203 
        break
11204 
      if fid == 1:
11205 
        if ftype == TType.I64:
11206 
          self.customer_id = iprot.readI64();
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      elif fid == 2:
11210 
        if ftype == TType.I64:
11211 
          self.limit = iprot.readI64();
11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      else:
11215 
        iprot.skip(ftype)
11216 
      iprot.readFieldEnd()
11217 
    iprot.readStructEnd()
11218 
 
11219 
  def write(self, oprot):
11220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11222 
      return
11223 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11224 
    if self.customer_id is not None:
1382 varun.gupt 11225 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11226 
      oprot.writeI64(self.customer_id)
11227 
      oprot.writeFieldEnd()
3431 rajveer 11228 
    if self.limit is not None:
1382 varun.gupt 11229 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11230 
      oprot.writeI64(self.limit)
11231 
      oprot.writeFieldEnd()
11232 
    oprot.writeFieldStop()
11233 
    oprot.writeStructEnd()
11234 
 
3431 rajveer 11235 
  def validate(self):
11236 
    return
11237 
 
11238 
 
1382 varun.gupt 11239 
  def __repr__(self):
11240 
    L = ['%s=%r' % (key, value)
11241 
      for key, value in self.__dict__.iteritems()]
11242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11243 
 
11244 
  def __eq__(self, other):
11245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11246 
 
11247 
  def __ne__(self, other):
11248 
    return not (self == other)
11249 
 
11250 
class getCancellableOrdersForCustomer_result:
11251 
  """
11252 
  Attributes:
11253 
   - success
11254 
   - ex
11255 
  """
11256 
 
11257 
  thrift_spec = (
11258 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11260 
  )
11261 
 
11262 
  def __init__(self, success=None, ex=None,):
11263 
    self.success = success
11264 
    self.ex = ex
11265 
 
11266 
  def read(self, iprot):
11267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11269 
      return
11270 
    iprot.readStructBegin()
11271 
    while True:
11272 
      (fname, ftype, fid) = iprot.readFieldBegin()
11273 
      if ftype == TType.STOP:
11274 
        break
11275 
      if fid == 0:
11276 
        if ftype == TType.LIST:
11277 
          self.success = []
6188 rajveer 11278 
          (_etype179, _size176) = iprot.readListBegin()
11279 
          for _i180 in xrange(_size176):
11280 
            _elem181 = iprot.readI64();
11281 
            self.success.append(_elem181)
1382 varun.gupt 11282 
          iprot.readListEnd()
11283 
        else:
11284 
          iprot.skip(ftype)
11285 
      elif fid == 1:
11286 
        if ftype == TType.STRUCT:
11287 
          self.ex = TransactionServiceException()
11288 
          self.ex.read(iprot)
11289 
        else:
11290 
          iprot.skip(ftype)
11291 
      else:
11292 
        iprot.skip(ftype)
11293 
      iprot.readFieldEnd()
11294 
    iprot.readStructEnd()
11295 
 
11296 
  def write(self, oprot):
11297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11299 
      return
11300 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11301 
    if self.success is not None:
1382 varun.gupt 11302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11303 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11304 
      for iter182 in self.success:
11305 
        oprot.writeI64(iter182)
1382 varun.gupt 11306 
      oprot.writeListEnd()
11307 
      oprot.writeFieldEnd()
3431 rajveer 11308 
    if self.ex is not None:
1382 varun.gupt 11309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11310 
      self.ex.write(oprot)
11311 
      oprot.writeFieldEnd()
11312 
    oprot.writeFieldStop()
11313 
    oprot.writeStructEnd()
11314 
 
3431 rajveer 11315 
  def validate(self):
11316 
    return
11317 
 
11318 
 
1382 varun.gupt 11319 
  def __repr__(self):
11320 
    L = ['%s=%r' % (key, value)
11321 
      for key, value in self.__dict__.iteritems()]
11322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11323 
 
11324 
  def __eq__(self, other):
11325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11326 
 
11327 
  def __ne__(self, other):
11328 
    return not (self == other)
11329 
 
483 rajveer 11330 
class changeOrderStatus_args:
94 ashish 11331 
  """
11332 
  Attributes:
483 rajveer 11333 
   - orderId
11334 
   - status
11335 
   - description
94 ashish 11336 
  """
11337 
 
11338 
  thrift_spec = (
11339 
    None, # 0
483 rajveer 11340 
    (1, TType.I64, 'orderId', None, None, ), # 1
11341 
    (2, TType.I32, 'status', None, None, ), # 2
11342 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11343 
  )
11344 
 
483 rajveer 11345 
  def __init__(self, orderId=None, status=None, description=None,):
11346 
    self.orderId = orderId
11347 
    self.status = status
11348 
    self.description = description
94 ashish 11349 
 
11350 
  def read(self, iprot):
11351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11353 
      return
11354 
    iprot.readStructBegin()
11355 
    while True:
11356 
      (fname, ftype, fid) = iprot.readFieldBegin()
11357 
      if ftype == TType.STOP:
11358 
        break
11359 
      if fid == 1:
11360 
        if ftype == TType.I64:
483 rajveer 11361 
          self.orderId = iprot.readI64();
94 ashish 11362 
        else:
11363 
          iprot.skip(ftype)
11364 
      elif fid == 2:
483 rajveer 11365 
        if ftype == TType.I32:
11366 
          self.status = iprot.readI32();
94 ashish 11367 
        else:
11368 
          iprot.skip(ftype)
483 rajveer 11369 
      elif fid == 3:
11370 
        if ftype == TType.STRING:
11371 
          self.description = iprot.readString();
11372 
        else:
11373 
          iprot.skip(ftype)
94 ashish 11374 
      else:
11375 
        iprot.skip(ftype)
11376 
      iprot.readFieldEnd()
11377 
    iprot.readStructEnd()
11378 
 
11379 
  def write(self, oprot):
11380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11382 
      return
483 rajveer 11383 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11384 
    if self.orderId is not None:
483 rajveer 11385 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11386 
      oprot.writeI64(self.orderId)
94 ashish 11387 
      oprot.writeFieldEnd()
3431 rajveer 11388 
    if self.status is not None:
483 rajveer 11389 
      oprot.writeFieldBegin('status', TType.I32, 2)
11390 
      oprot.writeI32(self.status)
94 ashish 11391 
      oprot.writeFieldEnd()
3431 rajveer 11392 
    if self.description is not None:
483 rajveer 11393 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11394 
      oprot.writeString(self.description)
11395 
      oprot.writeFieldEnd()
94 ashish 11396 
    oprot.writeFieldStop()
11397 
    oprot.writeStructEnd()
11398 
 
3431 rajveer 11399 
  def validate(self):
11400 
    return
11401 
 
11402 
 
94 ashish 11403 
  def __repr__(self):
11404 
    L = ['%s=%r' % (key, value)
11405 
      for key, value in self.__dict__.iteritems()]
11406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11407 
 
11408 
  def __eq__(self, other):
11409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11410 
 
11411 
  def __ne__(self, other):
11412 
    return not (self == other)
11413 
 
483 rajveer 11414 
class changeOrderStatus_result:
94 ashish 11415 
  """
11416 
  Attributes:
11417 
   - success
11418 
   - ex
11419 
  """
11420 
 
11421 
  thrift_spec = (
11422 
    (0, TType.BOOL, 'success', None, None, ), # 0
11423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11424 
  )
11425 
 
11426 
  def __init__(self, success=None, ex=None,):
11427 
    self.success = success
11428 
    self.ex = ex
11429 
 
11430 
  def read(self, iprot):
11431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11433 
      return
11434 
    iprot.readStructBegin()
11435 
    while True:
11436 
      (fname, ftype, fid) = iprot.readFieldBegin()
11437 
      if ftype == TType.STOP:
11438 
        break
11439 
      if fid == 0:
11440 
        if ftype == TType.BOOL:
11441 
          self.success = iprot.readBool();
11442 
        else:
11443 
          iprot.skip(ftype)
11444 
      elif fid == 1:
11445 
        if ftype == TType.STRUCT:
11446 
          self.ex = TransactionServiceException()
11447 
          self.ex.read(iprot)
11448 
        else:
11449 
          iprot.skip(ftype)
11450 
      else:
11451 
        iprot.skip(ftype)
11452 
      iprot.readFieldEnd()
11453 
    iprot.readStructEnd()
11454 
 
11455 
  def write(self, oprot):
11456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11458 
      return
483 rajveer 11459 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11460 
    if self.success is not None:
94 ashish 11461 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11462 
      oprot.writeBool(self.success)
11463 
      oprot.writeFieldEnd()
3431 rajveer 11464 
    if self.ex is not None:
94 ashish 11465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11466 
      self.ex.write(oprot)
11467 
      oprot.writeFieldEnd()
11468 
    oprot.writeFieldStop()
11469 
    oprot.writeStructEnd()
11470 
 
3431 rajveer 11471 
  def validate(self):
11472 
    return
11473 
 
11474 
 
94 ashish 11475 
  def __repr__(self):
11476 
    L = ['%s=%r' % (key, value)
11477 
      for key, value in self.__dict__.iteritems()]
11478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11479 
 
11480 
  def __eq__(self, other):
11481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11482 
 
11483 
  def __ne__(self, other):
11484 
    return not (self == other)
11485 
 
3064 chandransh 11486 
class getOrdersForTransaction_args:
494 rajveer 11487 
  """
11488 
  Attributes:
3064 chandransh 11489 
   - transactionId
11490 
   - customerId
494 rajveer 11491 
  """
11492 
 
11493 
  thrift_spec = (
11494 
    None, # 0
3064 chandransh 11495 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11496 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11497 
  )
11498 
 
3064 chandransh 11499 
  def __init__(self, transactionId=None, customerId=None,):
11500 
    self.transactionId = transactionId
11501 
    self.customerId = customerId
494 rajveer 11502 
 
11503 
  def read(self, iprot):
11504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11506 
      return
11507 
    iprot.readStructBegin()
11508 
    while True:
11509 
      (fname, ftype, fid) = iprot.readFieldBegin()
11510 
      if ftype == TType.STOP:
11511 
        break
11512 
      if fid == 1:
11513 
        if ftype == TType.I64:
3064 chandransh 11514 
          self.transactionId = iprot.readI64();
494 rajveer 11515 
        else:
11516 
          iprot.skip(ftype)
11517 
      elif fid == 2:
3064 chandransh 11518 
        if ftype == TType.I64:
11519 
          self.customerId = iprot.readI64();
494 rajveer 11520 
        else:
11521 
          iprot.skip(ftype)
11522 
      else:
11523 
        iprot.skip(ftype)
11524 
      iprot.readFieldEnd()
11525 
    iprot.readStructEnd()
11526 
 
11527 
  def write(self, oprot):
11528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11530 
      return
3064 chandransh 11531 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11532 
    if self.transactionId is not None:
3064 chandransh 11533 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11534 
      oprot.writeI64(self.transactionId)
494 rajveer 11535 
      oprot.writeFieldEnd()
3431 rajveer 11536 
    if self.customerId is not None:
3064 chandransh 11537 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11538 
      oprot.writeI64(self.customerId)
494 rajveer 11539 
      oprot.writeFieldEnd()
11540 
    oprot.writeFieldStop()
11541 
    oprot.writeStructEnd()
11542 
 
3431 rajveer 11543 
  def validate(self):
11544 
    return
11545 
 
11546 
 
494 rajveer 11547 
  def __repr__(self):
11548 
    L = ['%s=%r' % (key, value)
11549 
      for key, value in self.__dict__.iteritems()]
11550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11551 
 
11552 
  def __eq__(self, other):
11553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11554 
 
11555 
  def __ne__(self, other):
11556 
    return not (self == other)
11557 
 
3064 chandransh 11558 
class getOrdersForTransaction_result:
494 rajveer 11559 
  """
11560 
  Attributes:
11561 
   - success
11562 
   - ex
11563 
  """
11564 
 
11565 
  thrift_spec = (
3064 chandransh 11566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11568 
  )
11569 
 
11570 
  def __init__(self, success=None, ex=None,):
11571 
    self.success = success
11572 
    self.ex = ex
11573 
 
11574 
  def read(self, iprot):
11575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11577 
      return
11578 
    iprot.readStructBegin()
11579 
    while True:
11580 
      (fname, ftype, fid) = iprot.readFieldBegin()
11581 
      if ftype == TType.STOP:
11582 
        break
11583 
      if fid == 0:
3064 chandransh 11584 
        if ftype == TType.LIST:
11585 
          self.success = []
6188 rajveer 11586 
          (_etype186, _size183) = iprot.readListBegin()
11587 
          for _i187 in xrange(_size183):
11588 
            _elem188 = Order()
11589 
            _elem188.read(iprot)
11590 
            self.success.append(_elem188)
3064 chandransh 11591 
          iprot.readListEnd()
494 rajveer 11592 
        else:
11593 
          iprot.skip(ftype)
11594 
      elif fid == 1:
11595 
        if ftype == TType.STRUCT:
11596 
          self.ex = TransactionServiceException()
11597 
          self.ex.read(iprot)
11598 
        else:
11599 
          iprot.skip(ftype)
11600 
      else:
11601 
        iprot.skip(ftype)
11602 
      iprot.readFieldEnd()
11603 
    iprot.readStructEnd()
11604 
 
11605 
  def write(self, oprot):
11606 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11607 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11608 
      return
3064 chandransh 11609 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11610 
    if self.success is not None:
3064 chandransh 11611 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11612 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11613 
      for iter189 in self.success:
11614 
        iter189.write(oprot)
3064 chandransh 11615 
      oprot.writeListEnd()
494 rajveer 11616 
      oprot.writeFieldEnd()
3431 rajveer 11617 
    if self.ex is not None:
494 rajveer 11618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11619 
      self.ex.write(oprot)
11620 
      oprot.writeFieldEnd()
11621 
    oprot.writeFieldStop()
11622 
    oprot.writeStructEnd()
11623 
 
3431 rajveer 11624 
  def validate(self):
11625 
    return
11626 
 
11627 
 
494 rajveer 11628 
  def __repr__(self):
11629 
    L = ['%s=%r' % (key, value)
11630 
      for key, value in self.__dict__.iteritems()]
11631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11632 
 
11633 
  def __eq__(self, other):
11634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11635 
 
11636 
  def __ne__(self, other):
11637 
    return not (self == other)
11638 
 
3064 chandransh 11639 
class getOrdersForCustomer_args:
1149 chandransh 11640 
  """
11641 
  Attributes:
3064 chandransh 11642 
   - customerId
11643 
   - from_date
11644 
   - to_date
11645 
   - statuses
1149 chandransh 11646 
  """
11647 
 
11648 
  thrift_spec = (
11649 
    None, # 0
3064 chandransh 11650 
    (1, TType.I64, 'customerId', None, None, ), # 1
11651 
    (2, TType.I64, 'from_date', None, None, ), # 2
11652 
    (3, TType.I64, 'to_date', None, None, ), # 3
11653 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11654 
  )
11655 
 
3064 chandransh 11656 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11657 
    self.customerId = customerId
11658 
    self.from_date = from_date
11659 
    self.to_date = to_date
11660 
    self.statuses = statuses
1149 chandransh 11661 
 
11662 
  def read(self, iprot):
11663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11665 
      return
11666 
    iprot.readStructBegin()
11667 
    while True:
11668 
      (fname, ftype, fid) = iprot.readFieldBegin()
11669 
      if ftype == TType.STOP:
11670 
        break
11671 
      if fid == 1:
11672 
        if ftype == TType.I64:
3064 chandransh 11673 
          self.customerId = iprot.readI64();
1149 chandransh 11674 
        else:
11675 
          iprot.skip(ftype)
11676 
      elif fid == 2:
11677 
        if ftype == TType.I64:
3064 chandransh 11678 
          self.from_date = iprot.readI64();
1149 chandransh 11679 
        else:
11680 
          iprot.skip(ftype)
2783 chandransh 11681 
      elif fid == 3:
11682 
        if ftype == TType.I64:
3064 chandransh 11683 
          self.to_date = iprot.readI64();
2783 chandransh 11684 
        else:
11685 
          iprot.skip(ftype)
11686 
      elif fid == 4:
3064 chandransh 11687 
        if ftype == TType.LIST:
11688 
          self.statuses = []
6188 rajveer 11689 
          (_etype193, _size190) = iprot.readListBegin()
11690 
          for _i194 in xrange(_size190):
11691 
            _elem195 = iprot.readI32();
11692 
            self.statuses.append(_elem195)
3064 chandransh 11693 
          iprot.readListEnd()
2783 chandransh 11694 
        else:
11695 
          iprot.skip(ftype)
1149 chandransh 11696 
      else:
11697 
        iprot.skip(ftype)
11698 
      iprot.readFieldEnd()
11699 
    iprot.readStructEnd()
11700 
 
11701 
  def write(self, oprot):
11702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11704 
      return
3064 chandransh 11705 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11706 
    if self.customerId is not None:
3064 chandransh 11707 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11708 
      oprot.writeI64(self.customerId)
1149 chandransh 11709 
      oprot.writeFieldEnd()
3431 rajveer 11710 
    if self.from_date is not None:
3064 chandransh 11711 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11712 
      oprot.writeI64(self.from_date)
1149 chandransh 11713 
      oprot.writeFieldEnd()
3431 rajveer 11714 
    if self.to_date is not None:
3064 chandransh 11715 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11716 
      oprot.writeI64(self.to_date)
2783 chandransh 11717 
      oprot.writeFieldEnd()
3431 rajveer 11718 
    if self.statuses is not None:
3064 chandransh 11719 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11720 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11721 
      for iter196 in self.statuses:
11722 
        oprot.writeI32(iter196)
3064 chandransh 11723 
      oprot.writeListEnd()
2783 chandransh 11724 
      oprot.writeFieldEnd()
1149 chandransh 11725 
    oprot.writeFieldStop()
11726 
    oprot.writeStructEnd()
11727 
 
3431 rajveer 11728 
  def validate(self):
11729 
    return
11730 
 
11731 
 
1149 chandransh 11732 
  def __repr__(self):
11733 
    L = ['%s=%r' % (key, value)
11734 
      for key, value in self.__dict__.iteritems()]
11735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11736 
 
11737 
  def __eq__(self, other):
11738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11739 
 
11740 
  def __ne__(self, other):
11741 
    return not (self == other)
11742 
 
3064 chandransh 11743 
class getOrdersForCustomer_result:
1149 chandransh 11744 
  """
11745 
  Attributes:
11746 
   - success
11747 
   - ex
11748 
  """
11749 
 
11750 
  thrift_spec = (
3064 chandransh 11751 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11753 
  )
11754 
 
11755 
  def __init__(self, success=None, ex=None,):
11756 
    self.success = success
11757 
    self.ex = ex
11758 
 
11759 
  def read(self, iprot):
11760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11762 
      return
11763 
    iprot.readStructBegin()
11764 
    while True:
11765 
      (fname, ftype, fid) = iprot.readFieldBegin()
11766 
      if ftype == TType.STOP:
11767 
        break
11768 
      if fid == 0:
3064 chandransh 11769 
        if ftype == TType.LIST:
11770 
          self.success = []
6188 rajveer 11771 
          (_etype200, _size197) = iprot.readListBegin()
11772 
          for _i201 in xrange(_size197):
11773 
            _elem202 = Order()
11774 
            _elem202.read(iprot)
11775 
            self.success.append(_elem202)
3064 chandransh 11776 
          iprot.readListEnd()
1149 chandransh 11777 
        else:
11778 
          iprot.skip(ftype)
11779 
      elif fid == 1:
11780 
        if ftype == TType.STRUCT:
11781 
          self.ex = TransactionServiceException()
11782 
          self.ex.read(iprot)
11783 
        else:
11784 
          iprot.skip(ftype)
11785 
      else:
11786 
        iprot.skip(ftype)
11787 
      iprot.readFieldEnd()
11788 
    iprot.readStructEnd()
11789 
 
11790 
  def write(self, oprot):
11791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11793 
      return
3064 chandransh 11794 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11795 
    if self.success is not None:
3064 chandransh 11796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11797 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11798 
      for iter203 in self.success:
11799 
        iter203.write(oprot)
3064 chandransh 11800 
      oprot.writeListEnd()
1149 chandransh 11801 
      oprot.writeFieldEnd()
3431 rajveer 11802 
    if self.ex is not None:
1149 chandransh 11803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11804 
      self.ex.write(oprot)
11805 
      oprot.writeFieldEnd()
11806 
    oprot.writeFieldStop()
11807 
    oprot.writeStructEnd()
11808 
 
3431 rajveer 11809 
  def validate(self):
11810 
    return
11811 
 
11812 
 
1149 chandransh 11813 
  def __repr__(self):
11814 
    L = ['%s=%r' % (key, value)
11815 
      for key, value in self.__dict__.iteritems()]
11816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11817 
 
11818 
  def __eq__(self, other):
11819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11820 
 
11821 
  def __ne__(self, other):
11822 
    return not (self == other)
11823 
 
3064 chandransh 11824 
class createOrder_args:
921 rajveer 11825 
  """
11826 
  Attributes:
3064 chandransh 11827 
   - order
921 rajveer 11828 
  """
11829 
 
11830 
  thrift_spec = (
11831 
    None, # 0
3064 chandransh 11832 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11833 
  )
11834 
 
3064 chandransh 11835 
  def __init__(self, order=None,):
11836 
    self.order = order
921 rajveer 11837 
 
11838 
  def read(self, iprot):
11839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11841 
      return
11842 
    iprot.readStructBegin()
11843 
    while True:
11844 
      (fname, ftype, fid) = iprot.readFieldBegin()
11845 
      if ftype == TType.STOP:
11846 
        break
11847 
      if fid == 1:
3064 chandransh 11848 
        if ftype == TType.STRUCT:
11849 
          self.order = Order()
11850 
          self.order.read(iprot)
921 rajveer 11851 
        else:
11852 
          iprot.skip(ftype)
11853 
      else:
11854 
        iprot.skip(ftype)
11855 
      iprot.readFieldEnd()
11856 
    iprot.readStructEnd()
11857 
 
11858 
  def write(self, oprot):
11859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11861 
      return
3064 chandransh 11862 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11863 
    if self.order is not None:
3064 chandransh 11864 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11865 
      self.order.write(oprot)
921 rajveer 11866 
      oprot.writeFieldEnd()
11867 
    oprot.writeFieldStop()
11868 
    oprot.writeStructEnd()
11869 
 
3431 rajveer 11870 
  def validate(self):
11871 
    return
11872 
 
11873 
 
921 rajveer 11874 
  def __repr__(self):
11875 
    L = ['%s=%r' % (key, value)
11876 
      for key, value in self.__dict__.iteritems()]
11877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11878 
 
11879 
  def __eq__(self, other):
11880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11881 
 
11882 
  def __ne__(self, other):
11883 
    return not (self == other)
11884 
 
3064 chandransh 11885 
class createOrder_result:
921 rajveer 11886 
  """
11887 
  Attributes:
11888 
   - success
11889 
   - ex
11890 
  """
11891 
 
11892 
  thrift_spec = (
3064 chandransh 11893 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11895 
  )
11896 
 
11897 
  def __init__(self, success=None, ex=None,):
11898 
    self.success = success
11899 
    self.ex = ex
11900 
 
11901 
  def read(self, iprot):
11902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11904 
      return
11905 
    iprot.readStructBegin()
11906 
    while True:
11907 
      (fname, ftype, fid) = iprot.readFieldBegin()
11908 
      if ftype == TType.STOP:
11909 
        break
11910 
      if fid == 0:
3064 chandransh 11911 
        if ftype == TType.I64:
11912 
          self.success = iprot.readI64();
921 rajveer 11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      elif fid == 1:
11916 
        if ftype == TType.STRUCT:
11917 
          self.ex = TransactionServiceException()
11918 
          self.ex.read(iprot)
11919 
        else:
11920 
          iprot.skip(ftype)
11921 
      else:
11922 
        iprot.skip(ftype)
11923 
      iprot.readFieldEnd()
11924 
    iprot.readStructEnd()
11925 
 
11926 
  def write(self, oprot):
11927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11929 
      return
3064 chandransh 11930 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11931 
    if self.success is not None:
3064 chandransh 11932 
      oprot.writeFieldBegin('success', TType.I64, 0)
11933 
      oprot.writeI64(self.success)
921 rajveer 11934 
      oprot.writeFieldEnd()
3431 rajveer 11935 
    if self.ex is not None:
921 rajveer 11936 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11937 
      self.ex.write(oprot)
11938 
      oprot.writeFieldEnd()
11939 
    oprot.writeFieldStop()
11940 
    oprot.writeStructEnd()
11941 
 
3431 rajveer 11942 
  def validate(self):
11943 
    return
11944 
 
11945 
 
921 rajveer 11946 
  def __repr__(self):
11947 
    L = ['%s=%r' % (key, value)
11948 
      for key, value in self.__dict__.iteritems()]
11949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11950 
 
11951 
  def __eq__(self, other):
11952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11953 
 
11954 
  def __ne__(self, other):
11955 
    return not (self == other)
11956 
 
3064 chandransh 11957 
class getOrder_args:
921 rajveer 11958 
  """
11959 
  Attributes:
3064 chandransh 11960 
   - id
921 rajveer 11961 
  """
11962 
 
11963 
  thrift_spec = (
11964 
    None, # 0
3064 chandransh 11965 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11966 
  )
11967 
 
3064 chandransh 11968 
  def __init__(self, id=None,):
11969 
    self.id = id
921 rajveer 11970 
 
11971 
  def read(self, iprot):
11972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11974 
      return
11975 
    iprot.readStructBegin()
11976 
    while True:
11977 
      (fname, ftype, fid) = iprot.readFieldBegin()
11978 
      if ftype == TType.STOP:
11979 
        break
11980 
      if fid == 1:
11981 
        if ftype == TType.I64:
3064 chandransh 11982 
          self.id = iprot.readI64();
921 rajveer 11983 
        else:
11984 
          iprot.skip(ftype)
11985 
      else:
11986 
        iprot.skip(ftype)
11987 
      iprot.readFieldEnd()
11988 
    iprot.readStructEnd()
11989 
 
11990 
  def write(self, oprot):
11991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11993 
      return
3064 chandransh 11994 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11995 
    if self.id is not None:
3064 chandransh 11996 
      oprot.writeFieldBegin('id', TType.I64, 1)
11997 
      oprot.writeI64(self.id)
921 rajveer 11998 
      oprot.writeFieldEnd()
11999 
    oprot.writeFieldStop()
12000 
    oprot.writeStructEnd()
12001 
 
3431 rajveer 12002 
  def validate(self):
12003 
    return
12004 
 
12005 
 
921 rajveer 12006 
  def __repr__(self):
12007 
    L = ['%s=%r' % (key, value)
12008 
      for key, value in self.__dict__.iteritems()]
12009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12010 
 
12011 
  def __eq__(self, other):
12012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12013 
 
12014 
  def __ne__(self, other):
12015 
    return not (self == other)
12016 
 
3064 chandransh 12017 
class getOrder_result:
921 rajveer 12018 
  """
12019 
  Attributes:
12020 
   - success
12021 
   - ex
12022 
  """
12023 
 
12024 
  thrift_spec = (
3064 chandransh 12025 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12027 
  )
12028 
 
12029 
  def __init__(self, success=None, ex=None,):
12030 
    self.success = success
12031 
    self.ex = ex
12032 
 
12033 
  def read(self, iprot):
12034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12036 
      return
12037 
    iprot.readStructBegin()
12038 
    while True:
12039 
      (fname, ftype, fid) = iprot.readFieldBegin()
12040 
      if ftype == TType.STOP:
12041 
        break
12042 
      if fid == 0:
3064 chandransh 12043 
        if ftype == TType.STRUCT:
12044 
          self.success = Order()
12045 
          self.success.read(iprot)
921 rajveer 12046 
        else:
12047 
          iprot.skip(ftype)
12048 
      elif fid == 1:
12049 
        if ftype == TType.STRUCT:
12050 
          self.ex = TransactionServiceException()
12051 
          self.ex.read(iprot)
12052 
        else:
12053 
          iprot.skip(ftype)
12054 
      else:
12055 
        iprot.skip(ftype)
12056 
      iprot.readFieldEnd()
12057 
    iprot.readStructEnd()
12058 
 
12059 
  def write(self, oprot):
12060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12062 
      return
3064 chandransh 12063 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12064 
    if self.success is not None:
3064 chandransh 12065 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12066 
      self.success.write(oprot)
921 rajveer 12067 
      oprot.writeFieldEnd()
3431 rajveer 12068 
    if self.ex is not None:
921 rajveer 12069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12070 
      self.ex.write(oprot)
12071 
      oprot.writeFieldEnd()
12072 
    oprot.writeFieldStop()
12073 
    oprot.writeStructEnd()
12074 
 
3431 rajveer 12075 
  def validate(self):
12076 
    return
12077 
 
12078 
 
921 rajveer 12079 
  def __repr__(self):
12080 
    L = ['%s=%r' % (key, value)
12081 
      for key, value in self.__dict__.iteritems()]
12082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12083 
 
12084 
  def __eq__(self, other):
12085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12086 
 
12087 
  def __ne__(self, other):
12088 
    return not (self == other)
12089 
 
3064 chandransh 12090 
class getLineItemsForOrder_args:
94 ashish 12091 
  """
12092 
  Attributes:
3064 chandransh 12093 
   - orderId
94 ashish 12094 
  """
12095 
 
12096 
  thrift_spec = (
12097 
    None, # 0
3064 chandransh 12098 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12099 
  )
12100 
 
3064 chandransh 12101 
  def __init__(self, orderId=None,):
12102 
    self.orderId = orderId
94 ashish 12103 
 
12104 
  def read(self, iprot):
12105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12107 
      return
12108 
    iprot.readStructBegin()
12109 
    while True:
12110 
      (fname, ftype, fid) = iprot.readFieldBegin()
12111 
      if ftype == TType.STOP:
12112 
        break
12113 
      if fid == 1:
12114 
        if ftype == TType.I64:
3064 chandransh 12115 
          self.orderId = iprot.readI64();
94 ashish 12116 
        else:
12117 
          iprot.skip(ftype)
12118 
      else:
12119 
        iprot.skip(ftype)
12120 
      iprot.readFieldEnd()
12121 
    iprot.readStructEnd()
12122 
 
12123 
  def write(self, oprot):
12124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12126 
      return
3064 chandransh 12127 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12128 
    if self.orderId is not None:
3064 chandransh 12129 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12130 
      oprot.writeI64(self.orderId)
94 ashish 12131 
      oprot.writeFieldEnd()
12132 
    oprot.writeFieldStop()
12133 
    oprot.writeStructEnd()
12134 
 
3431 rajveer 12135 
  def validate(self):
12136 
    return
12137 
 
12138 
 
94 ashish 12139 
  def __repr__(self):
12140 
    L = ['%s=%r' % (key, value)
12141 
      for key, value in self.__dict__.iteritems()]
12142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12143 
 
12144 
  def __eq__(self, other):
12145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12146 
 
12147 
  def __ne__(self, other):
12148 
    return not (self == other)
12149 
 
3064 chandransh 12150 
class getLineItemsForOrder_result:
94 ashish 12151 
  """
12152 
  Attributes:
12153 
   - success
12154 
   - ex
12155 
  """
12156 
 
12157 
  thrift_spec = (
3064 chandransh 12158 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12159 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12160 
  )
12161 
 
12162 
  def __init__(self, success=None, ex=None,):
12163 
    self.success = success
12164 
    self.ex = ex
12165 
 
12166 
  def read(self, iprot):
12167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12169 
      return
12170 
    iprot.readStructBegin()
12171 
    while True:
12172 
      (fname, ftype, fid) = iprot.readFieldBegin()
12173 
      if ftype == TType.STOP:
12174 
        break
12175 
      if fid == 0:
483 rajveer 12176 
        if ftype == TType.LIST:
12177 
          self.success = []
6188 rajveer 12178 
          (_etype207, _size204) = iprot.readListBegin()
12179 
          for _i208 in xrange(_size204):
12180 
            _elem209 = LineItem()
12181 
            _elem209.read(iprot)
12182 
            self.success.append(_elem209)
483 rajveer 12183 
          iprot.readListEnd()
94 ashish 12184 
        else:
12185 
          iprot.skip(ftype)
12186 
      elif fid == 1:
12187 
        if ftype == TType.STRUCT:
12188 
          self.ex = TransactionServiceException()
12189 
          self.ex.read(iprot)
12190 
        else:
12191 
          iprot.skip(ftype)
12192 
      else:
12193 
        iprot.skip(ftype)
12194 
      iprot.readFieldEnd()
12195 
    iprot.readStructEnd()
12196 
 
12197 
  def write(self, oprot):
12198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12200 
      return
3064 chandransh 12201 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12202 
    if self.success is not None:
483 rajveer 12203 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12204 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12205 
      for iter210 in self.success:
12206 
        iter210.write(oprot)
483 rajveer 12207 
      oprot.writeListEnd()
94 ashish 12208 
      oprot.writeFieldEnd()
3431 rajveer 12209 
    if self.ex is not None:
94 ashish 12210 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12211 
      self.ex.write(oprot)
12212 
      oprot.writeFieldEnd()
12213 
    oprot.writeFieldStop()
12214 
    oprot.writeStructEnd()
12215 
 
3431 rajveer 12216 
  def validate(self):
12217 
    return
12218 
 
12219 
 
94 ashish 12220 
  def __repr__(self):
12221 
    L = ['%s=%r' % (key, value)
12222 
      for key, value in self.__dict__.iteritems()]
12223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12224 
 
12225 
  def __eq__(self, other):
12226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12227 
 
12228 
  def __ne__(self, other):
12229 
    return not (self == other)
12230 
 
4999 phani.kuma 12231 
class getOrderList_args:
12232 
  """
12233 
  Attributes:
12234 
   - order_ids
12235 
  """
12236 
 
12237 
  thrift_spec = (
12238 
    None, # 0
12239 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12240 
  )
12241 
 
12242 
  def __init__(self, order_ids=None,):
12243 
    self.order_ids = order_ids
12244 
 
12245 
  def read(self, iprot):
12246 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12247 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12248 
      return
12249 
    iprot.readStructBegin()
12250 
    while True:
12251 
      (fname, ftype, fid) = iprot.readFieldBegin()
12252 
      if ftype == TType.STOP:
12253 
        break
12254 
      if fid == 1:
12255 
        if ftype == TType.LIST:
12256 
          self.order_ids = []
6188 rajveer 12257 
          (_etype214, _size211) = iprot.readListBegin()
12258 
          for _i215 in xrange(_size211):
12259 
            _elem216 = iprot.readI64();
12260 
            self.order_ids.append(_elem216)
4999 phani.kuma 12261 
          iprot.readListEnd()
12262 
        else:
12263 
          iprot.skip(ftype)
12264 
      else:
12265 
        iprot.skip(ftype)
12266 
      iprot.readFieldEnd()
12267 
    iprot.readStructEnd()
12268 
 
12269 
  def write(self, oprot):
12270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12272 
      return
12273 
    oprot.writeStructBegin('getOrderList_args')
12274 
    if self.order_ids is not None:
12275 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12276 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12277 
      for iter217 in self.order_ids:
12278 
        oprot.writeI64(iter217)
4999 phani.kuma 12279 
      oprot.writeListEnd()
12280 
      oprot.writeFieldEnd()
12281 
    oprot.writeFieldStop()
12282 
    oprot.writeStructEnd()
12283 
 
12284 
  def validate(self):
12285 
    return
12286 
 
12287 
 
12288 
  def __repr__(self):
12289 
    L = ['%s=%r' % (key, value)
12290 
      for key, value in self.__dict__.iteritems()]
12291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12292 
 
12293 
  def __eq__(self, other):
12294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12295 
 
12296 
  def __ne__(self, other):
12297 
    return not (self == other)
12298 
 
12299 
class getOrderList_result:
12300 
  """
12301 
  Attributes:
12302 
   - success
12303 
  """
12304 
 
12305 
  thrift_spec = (
12306 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12307 
  )
12308 
 
12309 
  def __init__(self, success=None,):
12310 
    self.success = success
12311 
 
12312 
  def read(self, iprot):
12313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12315 
      return
12316 
    iprot.readStructBegin()
12317 
    while True:
12318 
      (fname, ftype, fid) = iprot.readFieldBegin()
12319 
      if ftype == TType.STOP:
12320 
        break
12321 
      if fid == 0:
12322 
        if ftype == TType.LIST:
12323 
          self.success = []
6188 rajveer 12324 
          (_etype221, _size218) = iprot.readListBegin()
12325 
          for _i222 in xrange(_size218):
12326 
            _elem223 = Order()
12327 
            _elem223.read(iprot)
12328 
            self.success.append(_elem223)
4999 phani.kuma 12329 
          iprot.readListEnd()
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      else:
12333 
        iprot.skip(ftype)
12334 
      iprot.readFieldEnd()
12335 
    iprot.readStructEnd()
12336 
 
12337 
  def write(self, oprot):
12338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12340 
      return
12341 
    oprot.writeStructBegin('getOrderList_result')
12342 
    if self.success is not None:
12343 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12344 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12345 
      for iter224 in self.success:
12346 
        iter224.write(oprot)
4999 phani.kuma 12347 
      oprot.writeListEnd()
12348 
      oprot.writeFieldEnd()
12349 
    oprot.writeFieldStop()
12350 
    oprot.writeStructEnd()
12351 
 
12352 
  def validate(self):
12353 
    return
12354 
 
12355 
 
12356 
  def __repr__(self):
12357 
    L = ['%s=%r' % (key, value)
12358 
      for key, value in self.__dict__.iteritems()]
12359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12360 
 
12361 
  def __eq__(self, other):
12362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12363 
 
12364 
  def __ne__(self, other):
12365 
    return not (self == other)
12366 
 
5386 phani.kuma 12367 
class getOrderListForVendor_args:
12368 
  """
12369 
  Attributes:
12370 
   - order_ids
12371 
   - vendorId
12372 
  """
12373 
 
12374 
  thrift_spec = (
12375 
    None, # 0
12376 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12377 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12378 
  )
12379 
 
12380 
  def __init__(self, order_ids=None, vendorId=None,):
12381 
    self.order_ids = order_ids
12382 
    self.vendorId = vendorId
12383 
 
12384 
  def read(self, iprot):
12385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12387 
      return
12388 
    iprot.readStructBegin()
12389 
    while True:
12390 
      (fname, ftype, fid) = iprot.readFieldBegin()
12391 
      if ftype == TType.STOP:
12392 
        break
12393 
      if fid == 1:
12394 
        if ftype == TType.LIST:
12395 
          self.order_ids = []
6188 rajveer 12396 
          (_etype228, _size225) = iprot.readListBegin()
12397 
          for _i229 in xrange(_size225):
12398 
            _elem230 = iprot.readI64();
12399 
            self.order_ids.append(_elem230)
5386 phani.kuma 12400 
          iprot.readListEnd()
12401 
        else:
12402 
          iprot.skip(ftype)
12403 
      elif fid == 2:
12404 
        if ftype == TType.I64:
12405 
          self.vendorId = iprot.readI64();
12406 
        else:
12407 
          iprot.skip(ftype)
12408 
      else:
12409 
        iprot.skip(ftype)
12410 
      iprot.readFieldEnd()
12411 
    iprot.readStructEnd()
12412 
 
12413 
  def write(self, oprot):
12414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12416 
      return
12417 
    oprot.writeStructBegin('getOrderListForVendor_args')
12418 
    if self.order_ids is not None:
12419 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12420 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12421 
      for iter231 in self.order_ids:
12422 
        oprot.writeI64(iter231)
5386 phani.kuma 12423 
      oprot.writeListEnd()
12424 
      oprot.writeFieldEnd()
12425 
    if self.vendorId is not None:
12426 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12427 
      oprot.writeI64(self.vendorId)
12428 
      oprot.writeFieldEnd()
12429 
    oprot.writeFieldStop()
12430 
    oprot.writeStructEnd()
12431 
 
12432 
  def validate(self):
12433 
    return
12434 
 
12435 
 
12436 
  def __repr__(self):
12437 
    L = ['%s=%r' % (key, value)
12438 
      for key, value in self.__dict__.iteritems()]
12439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12440 
 
12441 
  def __eq__(self, other):
12442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12443 
 
12444 
  def __ne__(self, other):
12445 
    return not (self == other)
12446 
 
12447 
class getOrderListForVendor_result:
12448 
  """
12449 
  Attributes:
12450 
   - success
12451 
  """
12452 
 
12453 
  thrift_spec = (
12454 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12455 
  )
12456 
 
12457 
  def __init__(self, success=None,):
12458 
    self.success = success
12459 
 
12460 
  def read(self, iprot):
12461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12463 
      return
12464 
    iprot.readStructBegin()
12465 
    while True:
12466 
      (fname, ftype, fid) = iprot.readFieldBegin()
12467 
      if ftype == TType.STOP:
12468 
        break
12469 
      if fid == 0:
12470 
        if ftype == TType.LIST:
12471 
          self.success = []
6188 rajveer 12472 
          (_etype235, _size232) = iprot.readListBegin()
12473 
          for _i236 in xrange(_size232):
12474 
            _elem237 = Order()
12475 
            _elem237.read(iprot)
12476 
            self.success.append(_elem237)
5386 phani.kuma 12477 
          iprot.readListEnd()
12478 
        else:
12479 
          iprot.skip(ftype)
12480 
      else:
12481 
        iprot.skip(ftype)
12482 
      iprot.readFieldEnd()
12483 
    iprot.readStructEnd()
12484 
 
12485 
  def write(self, oprot):
12486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12488 
      return
12489 
    oprot.writeStructBegin('getOrderListForVendor_result')
12490 
    if self.success is not None:
12491 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12492 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12493 
      for iter238 in self.success:
12494 
        iter238.write(oprot)
5386 phani.kuma 12495 
      oprot.writeListEnd()
12496 
      oprot.writeFieldEnd()
12497 
    oprot.writeFieldStop()
12498 
    oprot.writeStructEnd()
12499 
 
12500 
  def validate(self):
12501 
    return
12502 
 
12503 
 
12504 
  def __repr__(self):
12505 
    L = ['%s=%r' % (key, value)
12506 
      for key, value in self.__dict__.iteritems()]
12507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12508 
 
12509 
  def __eq__(self, other):
12510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12511 
 
12512 
  def __ne__(self, other):
12513 
    return not (self == other)
12514 
 
3064 chandransh 12515 
class getOrderForCustomer_args:
94 ashish 12516 
  """
12517 
  Attributes:
3064 chandransh 12518 
   - orderId
483 rajveer 12519 
   - customerId
94 ashish 12520 
  """
12521 
 
12522 
  thrift_spec = (
12523 
    None, # 0
3064 chandransh 12524 
    (1, TType.I64, 'orderId', None, None, ), # 1
12525 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12526 
  )
12527 
 
3064 chandransh 12528 
  def __init__(self, orderId=None, customerId=None,):
12529 
    self.orderId = orderId
483 rajveer 12530 
    self.customerId = customerId
94 ashish 12531 
 
12532 
  def read(self, iprot):
12533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12535 
      return
12536 
    iprot.readStructBegin()
12537 
    while True:
12538 
      (fname, ftype, fid) = iprot.readFieldBegin()
12539 
      if ftype == TType.STOP:
12540 
        break
12541 
      if fid == 1:
12542 
        if ftype == TType.I64:
3064 chandransh 12543 
          self.orderId = iprot.readI64();
94 ashish 12544 
        else:
12545 
          iprot.skip(ftype)
12546 
      elif fid == 2:
12547 
        if ftype == TType.I64:
3064 chandransh 12548 
          self.customerId = iprot.readI64();
94 ashish 12549 
        else:
12550 
          iprot.skip(ftype)
12551 
      else:
12552 
        iprot.skip(ftype)
12553 
      iprot.readFieldEnd()
12554 
    iprot.readStructEnd()
12555 
 
12556 
  def write(self, oprot):
12557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12559 
      return
3064 chandransh 12560 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12561 
    if self.orderId is not None:
3064 chandransh 12562 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12563 
      oprot.writeI64(self.orderId)
12564 
      oprot.writeFieldEnd()
3431 rajveer 12565 
    if self.customerId is not None:
3064 chandransh 12566 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12567 
      oprot.writeI64(self.customerId)
94 ashish 12568 
      oprot.writeFieldEnd()
12569 
    oprot.writeFieldStop()
12570 
    oprot.writeStructEnd()
12571 
 
3431 rajveer 12572 
  def validate(self):
12573 
    return
12574 
 
12575 
 
94 ashish 12576 
  def __repr__(self):
12577 
    L = ['%s=%r' % (key, value)
12578 
      for key, value in self.__dict__.iteritems()]
12579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12580 
 
12581 
  def __eq__(self, other):
12582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12583 
 
12584 
  def __ne__(self, other):
12585 
    return not (self == other)
12586 
 
3064 chandransh 12587 
class getOrderForCustomer_result:
94 ashish 12588 
  """
12589 
  Attributes:
12590 
   - success
12591 
   - ex
12592 
  """
12593 
 
12594 
  thrift_spec = (
3064 chandransh 12595 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12597 
  )
12598 
 
12599 
  def __init__(self, success=None, ex=None,):
12600 
    self.success = success
12601 
    self.ex = ex
12602 
 
12603 
  def read(self, iprot):
12604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12606 
      return
12607 
    iprot.readStructBegin()
12608 
    while True:
12609 
      (fname, ftype, fid) = iprot.readFieldBegin()
12610 
      if ftype == TType.STOP:
12611 
        break
12612 
      if fid == 0:
3064 chandransh 12613 
        if ftype == TType.STRUCT:
12614 
          self.success = Order()
12615 
          self.success.read(iprot)
94 ashish 12616 
        else:
12617 
          iprot.skip(ftype)
12618 
      elif fid == 1:
12619 
        if ftype == TType.STRUCT:
12620 
          self.ex = TransactionServiceException()
12621 
          self.ex.read(iprot)
12622 
        else:
12623 
          iprot.skip(ftype)
12624 
      else:
12625 
        iprot.skip(ftype)
12626 
      iprot.readFieldEnd()
12627 
    iprot.readStructEnd()
12628 
 
12629 
  def write(self, oprot):
12630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12632 
      return
3064 chandransh 12633 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12634 
    if self.success is not None:
3064 chandransh 12635 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12636 
      self.success.write(oprot)
94 ashish 12637 
      oprot.writeFieldEnd()
3431 rajveer 12638 
    if self.ex is not None:
94 ashish 12639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12640 
      self.ex.write(oprot)
12641 
      oprot.writeFieldEnd()
12642 
    oprot.writeFieldStop()
12643 
    oprot.writeStructEnd()
12644 
 
3431 rajveer 12645 
  def validate(self):
12646 
    return
12647 
 
12648 
 
94 ashish 12649 
  def __repr__(self):
12650 
    L = ['%s=%r' % (key, value)
12651 
      for key, value in self.__dict__.iteritems()]
12652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12653 
 
12654 
  def __eq__(self, other):
12655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12656 
 
12657 
  def __ne__(self, other):
12658 
    return not (self == other)
12659 
 
3064 chandransh 12660 
class getAlerts_args:
94 ashish 12661 
  """
12662 
  Attributes:
4394 rajveer 12663 
   - type
4444 rajveer 12664 
   - warehouseId
4394 rajveer 12665 
   - status
12666 
   - timestamp
94 ashish 12667 
  """
12668 
 
12669 
  thrift_spec = (
12670 
    None, # 0
4394 rajveer 12671 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12672 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12673 
    (3, TType.I64, 'status', None, None, ), # 3
12674 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12675 
  )
12676 
 
4444 rajveer 12677 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12678 
    self.type = type
4444 rajveer 12679 
    self.warehouseId = warehouseId
4394 rajveer 12680 
    self.status = status
12681 
    self.timestamp = timestamp
94 ashish 12682 
 
12683 
  def read(self, iprot):
12684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12686 
      return
12687 
    iprot.readStructBegin()
12688 
    while True:
12689 
      (fname, ftype, fid) = iprot.readFieldBegin()
12690 
      if ftype == TType.STOP:
12691 
        break
12692 
      if fid == 1:
3064 chandransh 12693 
        if ftype == TType.I64:
4394 rajveer 12694 
          self.type = iprot.readI64();
94 ashish 12695 
        else:
12696 
          iprot.skip(ftype)
3064 chandransh 12697 
      elif fid == 2:
4394 rajveer 12698 
        if ftype == TType.I64:
4444 rajveer 12699 
          self.warehouseId = iprot.readI64();
3064 chandransh 12700 
        else:
12701 
          iprot.skip(ftype)
4394 rajveer 12702 
      elif fid == 3:
12703 
        if ftype == TType.I64:
4444 rajveer 12704 
          self.status = iprot.readI64();
12705 
        else:
12706 
          iprot.skip(ftype)
12707 
      elif fid == 4:
12708 
        if ftype == TType.I64:
4394 rajveer 12709 
          self.timestamp = iprot.readI64();
12710 
        else:
12711 
          iprot.skip(ftype)
94 ashish 12712 
      else:
12713 
        iprot.skip(ftype)
12714 
      iprot.readFieldEnd()
12715 
    iprot.readStructEnd()
12716 
 
12717 
  def write(self, oprot):
12718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12720 
      return
3064 chandransh 12721 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12722 
    if self.type is not None:
12723 
      oprot.writeFieldBegin('type', TType.I64, 1)
12724 
      oprot.writeI64(self.type)
94 ashish 12725 
      oprot.writeFieldEnd()
4444 rajveer 12726 
    if self.warehouseId is not None:
12727 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12728 
      oprot.writeI64(self.warehouseId)
12729 
      oprot.writeFieldEnd()
4394 rajveer 12730 
    if self.status is not None:
4444 rajveer 12731 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12732 
      oprot.writeI64(self.status)
3064 chandransh 12733 
      oprot.writeFieldEnd()
4394 rajveer 12734 
    if self.timestamp is not None:
4444 rajveer 12735 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12736 
      oprot.writeI64(self.timestamp)
12737 
      oprot.writeFieldEnd()
94 ashish 12738 
    oprot.writeFieldStop()
12739 
    oprot.writeStructEnd()
12740 
 
3431 rajveer 12741 
  def validate(self):
12742 
    return
12743 
 
12744 
 
94 ashish 12745 
  def __repr__(self):
12746 
    L = ['%s=%r' % (key, value)
12747 
      for key, value in self.__dict__.iteritems()]
12748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12749 
 
12750 
  def __eq__(self, other):
12751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12752 
 
12753 
  def __ne__(self, other):
12754 
    return not (self == other)
12755 
 
3064 chandransh 12756 
class getAlerts_result:
94 ashish 12757 
  """
12758 
  Attributes:
12759 
   - success
12760 
  """
12761 
 
12762 
  thrift_spec = (
3064 chandransh 12763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12764 
  )
12765 
 
3064 chandransh 12766 
  def __init__(self, success=None,):
94 ashish 12767 
    self.success = success
12768 
 
12769 
  def read(self, iprot):
12770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12772 
      return
12773 
    iprot.readStructBegin()
12774 
    while True:
12775 
      (fname, ftype, fid) = iprot.readFieldBegin()
12776 
      if ftype == TType.STOP:
12777 
        break
12778 
      if fid == 0:
3064 chandransh 12779 
        if ftype == TType.LIST:
12780 
          self.success = []
6188 rajveer 12781 
          (_etype242, _size239) = iprot.readListBegin()
12782 
          for _i243 in xrange(_size239):
12783 
            _elem244 = Alert()
12784 
            _elem244.read(iprot)
12785 
            self.success.append(_elem244)
3064 chandransh 12786 
          iprot.readListEnd()
94 ashish 12787 
        else:
12788 
          iprot.skip(ftype)
12789 
      else:
12790 
        iprot.skip(ftype)
12791 
      iprot.readFieldEnd()
12792 
    iprot.readStructEnd()
12793 
 
12794 
  def write(self, oprot):
12795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12797 
      return
3064 chandransh 12798 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12799 
    if self.success is not None:
3064 chandransh 12800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12802 
      for iter245 in self.success:
12803 
        iter245.write(oprot)
3064 chandransh 12804 
      oprot.writeListEnd()
94 ashish 12805 
      oprot.writeFieldEnd()
12806 
    oprot.writeFieldStop()
12807 
    oprot.writeStructEnd()
12808 
 
3431 rajveer 12809 
  def validate(self):
12810 
    return
12811 
 
12812 
 
94 ashish 12813 
  def __repr__(self):
12814 
    L = ['%s=%r' % (key, value)
12815 
      for key, value in self.__dict__.iteritems()]
12816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12817 
 
12818 
  def __eq__(self, other):
12819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12820 
 
12821 
  def __ne__(self, other):
12822 
    return not (self == other)
12823 
 
4394 rajveer 12824 
class addAlert_args:
94 ashish 12825 
  """
12826 
  Attributes:
3064 chandransh 12827 
   - type
4444 rajveer 12828 
   - warehouseId
4394 rajveer 12829 
   - description
94 ashish 12830 
  """
12831 
 
12832 
  thrift_spec = (
12833 
    None, # 0
4394 rajveer 12834 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12835 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12836 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12837 
  )
12838 
 
4444 rajveer 12839 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12840 
    self.type = type
4444 rajveer 12841 
    self.warehouseId = warehouseId
4394 rajveer 12842 
    self.description = description
94 ashish 12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
12853 
      if fid == 1:
12854 
        if ftype == TType.I64:
4394 rajveer 12855 
          self.type = iprot.readI64();
94 ashish 12856 
        else:
12857 
          iprot.skip(ftype)
3064 chandransh 12858 
      elif fid == 2:
4444 rajveer 12859 
        if ftype == TType.I64:
12860 
          self.warehouseId = iprot.readI64();
12861 
        else:
12862 
          iprot.skip(ftype)
12863 
      elif fid == 3:
3064 chandransh 12864 
        if ftype == TType.STRING:
4394 rajveer 12865 
          self.description = iprot.readString();
3064 chandransh 12866 
        else:
12867 
          iprot.skip(ftype)
94 ashish 12868 
      else:
12869 
        iprot.skip(ftype)
12870 
      iprot.readFieldEnd()
12871 
    iprot.readStructEnd()
12872 
 
12873 
  def write(self, oprot):
12874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12876 
      return
4394 rajveer 12877 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12878 
    if self.type is not None:
4394 rajveer 12879 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12880 
      oprot.writeI64(self.type)
12881 
      oprot.writeFieldEnd()
4444 rajveer 12882 
    if self.warehouseId is not None:
12883 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12884 
      oprot.writeI64(self.warehouseId)
12885 
      oprot.writeFieldEnd()
4394 rajveer 12886 
    if self.description is not None:
4444 rajveer 12887 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12888 
      oprot.writeString(self.description)
3064 chandransh 12889 
      oprot.writeFieldEnd()
94 ashish 12890 
    oprot.writeFieldStop()
12891 
    oprot.writeStructEnd()
12892 
 
3431 rajveer 12893 
  def validate(self):
12894 
    return
12895 
 
12896 
 
94 ashish 12897 
  def __repr__(self):
12898 
    L = ['%s=%r' % (key, value)
12899 
      for key, value in self.__dict__.iteritems()]
12900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12901 
 
12902 
  def __eq__(self, other):
12903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12904 
 
12905 
  def __ne__(self, other):
12906 
    return not (self == other)
12907 
 
4394 rajveer 12908 
class addAlert_result:
3064 chandransh 12909 
 
12910 
  thrift_spec = (
12911 
  )
12912 
 
12913 
  def read(self, iprot):
12914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12916 
      return
12917 
    iprot.readStructBegin()
12918 
    while True:
12919 
      (fname, ftype, fid) = iprot.readFieldBegin()
12920 
      if ftype == TType.STOP:
12921 
        break
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
4394 rajveer 12931 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12932 
    oprot.writeFieldStop()
12933 
    oprot.writeStructEnd()
12934 
 
3431 rajveer 12935 
  def validate(self):
12936 
    return
12937 
 
12938 
 
3064 chandransh 12939 
  def __repr__(self):
12940 
    L = ['%s=%r' % (key, value)
12941 
      for key, value in self.__dict__.iteritems()]
12942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12943 
 
12944 
  def __eq__(self, other):
12945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12946 
 
12947 
  def __ne__(self, other):
12948 
    return not (self == other)
12949 
 
4444 rajveer 12950 
class markAlertsAsSeen_args:
12951 
  """
12952 
  Attributes:
12953 
   - warehouseId
12954 
  """
12955 
 
12956 
  thrift_spec = (
12957 
    None, # 0
12958 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12959 
  )
12960 
 
12961 
  def __init__(self, warehouseId=None,):
12962 
    self.warehouseId = warehouseId
12963 
 
12964 
  def read(self, iprot):
12965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12967 
      return
12968 
    iprot.readStructBegin()
12969 
    while True:
12970 
      (fname, ftype, fid) = iprot.readFieldBegin()
12971 
      if ftype == TType.STOP:
12972 
        break
12973 
      if fid == 1:
12974 
        if ftype == TType.I64:
12975 
          self.warehouseId = iprot.readI64();
12976 
        else:
12977 
          iprot.skip(ftype)
12978 
      else:
12979 
        iprot.skip(ftype)
12980 
      iprot.readFieldEnd()
12981 
    iprot.readStructEnd()
12982 
 
12983 
  def write(self, oprot):
12984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12986 
      return
12987 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12988 
    if self.warehouseId is not None:
12989 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12990 
      oprot.writeI64(self.warehouseId)
12991 
      oprot.writeFieldEnd()
12992 
    oprot.writeFieldStop()
12993 
    oprot.writeStructEnd()
12994 
 
12995 
  def validate(self):
12996 
    return
12997 
 
12998 
 
12999 
  def __repr__(self):
13000 
    L = ['%s=%r' % (key, value)
13001 
      for key, value in self.__dict__.iteritems()]
13002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13003 
 
13004 
  def __eq__(self, other):
13005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13006 
 
13007 
  def __ne__(self, other):
13008 
    return not (self == other)
13009 
 
13010 
class markAlertsAsSeen_result:
13011 
 
13012 
  thrift_spec = (
13013 
  )
13014 
 
13015 
  def read(self, iprot):
13016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13018 
      return
13019 
    iprot.readStructBegin()
13020 
    while True:
13021 
      (fname, ftype, fid) = iprot.readFieldBegin()
13022 
      if ftype == TType.STOP:
13023 
        break
13024 
      else:
13025 
        iprot.skip(ftype)
13026 
      iprot.readFieldEnd()
13027 
    iprot.readStructEnd()
13028 
 
13029 
  def write(self, oprot):
13030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13032 
      return
13033 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13034 
    oprot.writeFieldStop()
13035 
    oprot.writeStructEnd()
13036 
 
13037 
  def validate(self):
13038 
    return
13039 
 
13040 
 
13041 
  def __repr__(self):
13042 
    L = ['%s=%r' % (key, value)
13043 
      for key, value in self.__dict__.iteritems()]
13044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13045 
 
13046 
  def __eq__(self, other):
13047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13048 
 
13049 
  def __ne__(self, other):
13050 
    return not (self == other)
13051 
 
3064 chandransh 13052 
class getValidOrderCount_args:
13053 
 
13054 
  thrift_spec = (
13055 
  )
13056 
 
13057 
  def read(self, iprot):
13058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13060 
      return
13061 
    iprot.readStructBegin()
13062 
    while True:
13063 
      (fname, ftype, fid) = iprot.readFieldBegin()
13064 
      if ftype == TType.STOP:
13065 
        break
13066 
      else:
13067 
        iprot.skip(ftype)
13068 
      iprot.readFieldEnd()
13069 
    iprot.readStructEnd()
13070 
 
13071 
  def write(self, oprot):
13072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13074 
      return
13075 
    oprot.writeStructBegin('getValidOrderCount_args')
13076 
    oprot.writeFieldStop()
13077 
    oprot.writeStructEnd()
13078 
 
3431 rajveer 13079 
  def validate(self):
13080 
    return
13081 
 
13082 
 
3064 chandransh 13083 
  def __repr__(self):
13084 
    L = ['%s=%r' % (key, value)
13085 
      for key, value in self.__dict__.iteritems()]
13086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13087 
 
13088 
  def __eq__(self, other):
13089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13090 
 
13091 
  def __ne__(self, other):
13092 
    return not (self == other)
13093 
 
13094 
class getValidOrderCount_result:
94 ashish 13095 
  """
13096 
  Attributes:
13097 
   - success
13098 
  """
13099 
 
13100 
  thrift_spec = (
3064 chandransh 13101 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13102 
  )
13103 
 
3064 chandransh 13104 
  def __init__(self, success=None,):
94 ashish 13105 
    self.success = success
13106 
 
13107 
  def read(self, iprot):
13108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13110 
      return
13111 
    iprot.readStructBegin()
13112 
    while True:
13113 
      (fname, ftype, fid) = iprot.readFieldBegin()
13114 
      if ftype == TType.STOP:
13115 
        break
13116 
      if fid == 0:
3064 chandransh 13117 
        if ftype == TType.I64:
13118 
          self.success = iprot.readI64();
94 ashish 13119 
        else:
13120 
          iprot.skip(ftype)
13121 
      else:
13122 
        iprot.skip(ftype)
13123 
      iprot.readFieldEnd()
13124 
    iprot.readStructEnd()
13125 
 
13126 
  def write(self, oprot):
13127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13129 
      return
3064 chandransh 13130 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13131 
    if self.success is not None:
3064 chandransh 13132 
      oprot.writeFieldBegin('success', TType.I64, 0)
13133 
      oprot.writeI64(self.success)
94 ashish 13134 
      oprot.writeFieldEnd()
13135 
    oprot.writeFieldStop()
13136 
    oprot.writeStructEnd()
13137 
 
3431 rajveer 13138 
  def validate(self):
13139 
    return
13140 
 
13141 
 
94 ashish 13142 
  def __repr__(self):
13143 
    L = ['%s=%r' % (key, value)
13144 
      for key, value in self.__dict__.iteritems()]
13145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13146 
 
13147 
  def __eq__(self, other):
13148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13149 
 
13150 
  def __ne__(self, other):
13151 
    return not (self == other)
13152 
 
3064 chandransh 13153 
class getNoOfCustomersWithSuccessfulTransaction_args:
13154 
 
13155 
  thrift_spec = (
13156 
  )
13157 
 
13158 
  def read(self, iprot):
13159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13161 
      return
13162 
    iprot.readStructBegin()
13163 
    while True:
13164 
      (fname, ftype, fid) = iprot.readFieldBegin()
13165 
      if ftype == TType.STOP:
13166 
        break
13167 
      else:
13168 
        iprot.skip(ftype)
13169 
      iprot.readFieldEnd()
13170 
    iprot.readStructEnd()
13171 
 
13172 
  def write(self, oprot):
13173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13175 
      return
13176 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13177 
    oprot.writeFieldStop()
13178 
    oprot.writeStructEnd()
13179 
 
3431 rajveer 13180 
  def validate(self):
13181 
    return
13182 
 
13183 
 
3064 chandransh 13184 
  def __repr__(self):
13185 
    L = ['%s=%r' % (key, value)
13186 
      for key, value in self.__dict__.iteritems()]
13187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13188 
 
13189 
  def __eq__(self, other):
13190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13191 
 
13192 
  def __ne__(self, other):
13193 
    return not (self == other)
13194 
 
13195 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13196 
  """
13197 
  Attributes:
3064 chandransh 13198 
   - success
94 ashish 13199 
  """
13200 
 
13201 
  thrift_spec = (
3064 chandransh 13202 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13203 
  )
13204 
 
3064 chandransh 13205 
  def __init__(self, success=None,):
13206 
    self.success = success
94 ashish 13207 
 
13208 
  def read(self, iprot):
13209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13211 
      return
13212 
    iprot.readStructBegin()
13213 
    while True:
13214 
      (fname, ftype, fid) = iprot.readFieldBegin()
13215 
      if ftype == TType.STOP:
13216 
        break
3064 chandransh 13217 
      if fid == 0:
94 ashish 13218 
        if ftype == TType.I64:
3064 chandransh 13219 
          self.success = iprot.readI64();
94 ashish 13220 
        else:
13221 
          iprot.skip(ftype)
13222 
      else:
13223 
        iprot.skip(ftype)
13224 
      iprot.readFieldEnd()
13225 
    iprot.readStructEnd()
13226 
 
13227 
  def write(self, oprot):
13228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13230 
      return
3064 chandransh 13231 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13232 
    if self.success is not None:
3064 chandransh 13233 
      oprot.writeFieldBegin('success', TType.I64, 0)
13234 
      oprot.writeI64(self.success)
94 ashish 13235 
      oprot.writeFieldEnd()
13236 
    oprot.writeFieldStop()
13237 
    oprot.writeStructEnd()
13238 
 
3431 rajveer 13239 
  def validate(self):
13240 
    return
13241 
 
13242 
 
94 ashish 13243 
  def __repr__(self):
13244 
    L = ['%s=%r' % (key, value)
13245 
      for key, value in self.__dict__.iteritems()]
13246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13247 
 
13248 
  def __eq__(self, other):
13249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13250 
 
13251 
  def __ne__(self, other):
13252 
    return not (self == other)
13253 
 
3064 chandransh 13254 
class getValidOrdersAmountRange_args:
13255 
 
13256 
  thrift_spec = (
13257 
  )
13258 
 
13259 
  def read(self, iprot):
13260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13262 
      return
13263 
    iprot.readStructBegin()
13264 
    while True:
13265 
      (fname, ftype, fid) = iprot.readFieldBegin()
13266 
      if ftype == TType.STOP:
13267 
        break
13268 
      else:
13269 
        iprot.skip(ftype)
13270 
      iprot.readFieldEnd()
13271 
    iprot.readStructEnd()
13272 
 
13273 
  def write(self, oprot):
13274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13276 
      return
13277 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13278 
    oprot.writeFieldStop()
13279 
    oprot.writeStructEnd()
13280 
 
3431 rajveer 13281 
  def validate(self):
13282 
    return
13283 
 
13284 
 
3064 chandransh 13285 
  def __repr__(self):
13286 
    L = ['%s=%r' % (key, value)
13287 
      for key, value in self.__dict__.iteritems()]
13288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13289 
 
13290 
  def __eq__(self, other):
13291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13292 
 
13293 
  def __ne__(self, other):
13294 
    return not (self == other)
13295 
 
13296 
class getValidOrdersAmountRange_result:
94 ashish 13297 
  """
13298 
  Attributes:
13299 
   - success
13300 
  """
13301 
 
13302 
  thrift_spec = (
3064 chandransh 13303 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13304 
  )
13305 
 
3064 chandransh 13306 
  def __init__(self, success=None,):
94 ashish 13307 
    self.success = success
13308 
 
13309 
  def read(self, iprot):
13310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13312 
      return
13313 
    iprot.readStructBegin()
13314 
    while True:
13315 
      (fname, ftype, fid) = iprot.readFieldBegin()
13316 
      if ftype == TType.STOP:
13317 
        break
13318 
      if fid == 0:
483 rajveer 13319 
        if ftype == TType.LIST:
13320 
          self.success = []
6188 rajveer 13321 
          (_etype249, _size246) = iprot.readListBegin()
13322 
          for _i250 in xrange(_size246):
13323 
            _elem251 = iprot.readDouble();
13324 
            self.success.append(_elem251)
483 rajveer 13325 
          iprot.readListEnd()
94 ashish 13326 
        else:
13327 
          iprot.skip(ftype)
13328 
      else:
13329 
        iprot.skip(ftype)
13330 
      iprot.readFieldEnd()
13331 
    iprot.readStructEnd()
13332 
 
13333 
  def write(self, oprot):
13334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13336 
      return
3064 chandransh 13337 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13338 
    if self.success is not None:
483 rajveer 13339 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13340 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13341 
      for iter252 in self.success:
13342 
        oprot.writeDouble(iter252)
483 rajveer 13343 
      oprot.writeListEnd()
94 ashish 13344 
      oprot.writeFieldEnd()
13345 
    oprot.writeFieldStop()
13346 
    oprot.writeStructEnd()
13347 
 
3431 rajveer 13348 
  def validate(self):
13349 
    return
13350 
 
13351 
 
94 ashish 13352 
  def __repr__(self):
13353 
    L = ['%s=%r' % (key, value)
13354 
      for key, value in self.__dict__.iteritems()]
13355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13356 
 
13357 
  def __eq__(self, other):
13358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13359 
 
13360 
  def __ne__(self, other):
13361 
    return not (self == other)
13362 
 
3064 chandransh 13363 
class getValidOrders_args:
1528 ankur.sing 13364 
  """
13365 
  Attributes:
3064 chandransh 13366 
   - limit
5874 rajveer 13367 
   - onlyStore
1528 ankur.sing 13368 
  """
13369 
 
13370 
  thrift_spec = (
13371 
    None, # 0
3064 chandransh 13372 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13373 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13374 
  )
13375 
 
5874 rajveer 13376 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13377 
    self.limit = limit
5874 rajveer 13378 
    self.onlyStore = onlyStore
1528 ankur.sing 13379 
 
13380 
  def read(self, iprot):
13381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13383 
      return
13384 
    iprot.readStructBegin()
13385 
    while True:
13386 
      (fname, ftype, fid) = iprot.readFieldBegin()
13387 
      if ftype == TType.STOP:
13388 
        break
13389 
      if fid == 1:
13390 
        if ftype == TType.I64:
3064 chandransh 13391 
          self.limit = iprot.readI64();
1528 ankur.sing 13392 
        else:
13393 
          iprot.skip(ftype)
5874 rajveer 13394 
      elif fid == 2:
13395 
        if ftype == TType.BOOL:
13396 
          self.onlyStore = iprot.readBool();
13397 
        else:
13398 
          iprot.skip(ftype)
1528 ankur.sing 13399 
      else:
13400 
        iprot.skip(ftype)
13401 
      iprot.readFieldEnd()
13402 
    iprot.readStructEnd()
13403 
 
13404 
  def write(self, oprot):
13405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13407 
      return
3064 chandransh 13408 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13409 
    if self.limit is not None:
3064 chandransh 13410 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13411 
      oprot.writeI64(self.limit)
1528 ankur.sing 13412 
      oprot.writeFieldEnd()
5874 rajveer 13413 
    if self.onlyStore is not None:
13414 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13415 
      oprot.writeBool(self.onlyStore)
13416 
      oprot.writeFieldEnd()
1528 ankur.sing 13417 
    oprot.writeFieldStop()
13418 
    oprot.writeStructEnd()
13419 
 
3431 rajveer 13420 
  def validate(self):
13421 
    return
13422 
 
13423 
 
1528 ankur.sing 13424 
  def __repr__(self):
13425 
    L = ['%s=%r' % (key, value)
13426 
      for key, value in self.__dict__.iteritems()]
13427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13428 
 
13429 
  def __eq__(self, other):
13430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13431 
 
13432 
  def __ne__(self, other):
13433 
    return not (self == other)
13434 
 
3064 chandransh 13435 
class getValidOrders_result:
1528 ankur.sing 13436 
  """
13437 
  Attributes:
13438 
   - success
13439 
  """
13440 
 
13441 
  thrift_spec = (
3064 chandransh 13442 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13443 
  )
13444 
 
3064 chandransh 13445 
  def __init__(self, success=None,):
1528 ankur.sing 13446 
    self.success = success
13447 
 
13448 
  def read(self, iprot):
13449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13451 
      return
13452 
    iprot.readStructBegin()
13453 
    while True:
13454 
      (fname, ftype, fid) = iprot.readFieldBegin()
13455 
      if ftype == TType.STOP:
13456 
        break
13457 
      if fid == 0:
3064 chandransh 13458 
        if ftype == TType.LIST:
13459 
          self.success = []
6188 rajveer 13460 
          (_etype256, _size253) = iprot.readListBegin()
13461 
          for _i257 in xrange(_size253):
13462 
            _elem258 = Order()
13463 
            _elem258.read(iprot)
13464 
            self.success.append(_elem258)
3064 chandransh 13465 
          iprot.readListEnd()
1528 ankur.sing 13466 
        else:
13467 
          iprot.skip(ftype)
13468 
      else:
13469 
        iprot.skip(ftype)
13470 
      iprot.readFieldEnd()
13471 
    iprot.readStructEnd()
13472 
 
13473 
  def write(self, oprot):
13474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13476 
      return
3064 chandransh 13477 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13478 
    if self.success is not None:
3064 chandransh 13479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13481 
      for iter259 in self.success:
13482 
        iter259.write(oprot)
3064 chandransh 13483 
      oprot.writeListEnd()
1528 ankur.sing 13484 
      oprot.writeFieldEnd()
13485 
    oprot.writeFieldStop()
13486 
    oprot.writeStructEnd()
13487 
 
3431 rajveer 13488 
  def validate(self):
13489 
    return
13490 
 
13491 
 
1528 ankur.sing 13492 
  def __repr__(self):
13493 
    L = ['%s=%r' % (key, value)
13494 
      for key, value in self.__dict__.iteritems()]
13495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13496 
 
13497 
  def __eq__(self, other):
13498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13499 
 
13500 
  def __ne__(self, other):
13501 
    return not (self == other)
13502 
 
1220 chandransh 13503 
class batchOrders_args:
13504 
  """
13505 
  Attributes:
13506 
   - warehouseId
13507 
  """
13508 
 
13509 
  thrift_spec = (
13510 
    None, # 0
13511 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13512 
  )
13513 
 
13514 
  def __init__(self, warehouseId=None,):
13515 
    self.warehouseId = warehouseId
13516 
 
13517 
  def read(self, iprot):
13518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13520 
      return
13521 
    iprot.readStructBegin()
13522 
    while True:
13523 
      (fname, ftype, fid) = iprot.readFieldBegin()
13524 
      if ftype == TType.STOP:
13525 
        break
13526 
      if fid == 1:
13527 
        if ftype == TType.I64:
13528 
          self.warehouseId = iprot.readI64();
13529 
        else:
13530 
          iprot.skip(ftype)
13531 
      else:
13532 
        iprot.skip(ftype)
13533 
      iprot.readFieldEnd()
13534 
    iprot.readStructEnd()
13535 
 
13536 
  def write(self, oprot):
13537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13539 
      return
13540 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13541 
    if self.warehouseId is not None:
1220 chandransh 13542 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13543 
      oprot.writeI64(self.warehouseId)
13544 
      oprot.writeFieldEnd()
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
3431 rajveer 13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
1220 chandransh 13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
13562 
 
13563 
class batchOrders_result:
13564 
  """
13565 
  Attributes:
13566 
   - success
13567 
   - ex
13568 
  """
13569 
 
13570 
  thrift_spec = (
13571 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13572 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13573 
  )
13574 
 
13575 
  def __init__(self, success=None, ex=None,):
13576 
    self.success = success
13577 
    self.ex = ex
13578 
 
13579 
  def read(self, iprot):
13580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13582 
      return
13583 
    iprot.readStructBegin()
13584 
    while True:
13585 
      (fname, ftype, fid) = iprot.readFieldBegin()
13586 
      if ftype == TType.STOP:
13587 
        break
13588 
      if fid == 0:
13589 
        if ftype == TType.LIST:
13590 
          self.success = []
6188 rajveer 13591 
          (_etype263, _size260) = iprot.readListBegin()
13592 
          for _i264 in xrange(_size260):
13593 
            _elem265 = Order()
13594 
            _elem265.read(iprot)
13595 
            self.success.append(_elem265)
1220 chandransh 13596 
          iprot.readListEnd()
13597 
        else:
13598 
          iprot.skip(ftype)
13599 
      elif fid == 1:
13600 
        if ftype == TType.STRUCT:
13601 
          self.ex = TransactionServiceException()
13602 
          self.ex.read(iprot)
13603 
        else:
13604 
          iprot.skip(ftype)
13605 
      else:
13606 
        iprot.skip(ftype)
13607 
      iprot.readFieldEnd()
13608 
    iprot.readStructEnd()
13609 
 
13610 
  def write(self, oprot):
13611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13613 
      return
13614 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13615 
    if self.success is not None:
1220 chandransh 13616 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13617 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13618 
      for iter266 in self.success:
13619 
        iter266.write(oprot)
1220 chandransh 13620 
      oprot.writeListEnd()
13621 
      oprot.writeFieldEnd()
3431 rajveer 13622 
    if self.ex is not None:
1220 chandransh 13623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13624 
      self.ex.write(oprot)
13625 
      oprot.writeFieldEnd()
13626 
    oprot.writeFieldStop()
13627 
    oprot.writeStructEnd()
13628 
 
3431 rajveer 13629 
  def validate(self):
13630 
    return
13631 
 
13632 
 
1220 chandransh 13633 
  def __repr__(self):
13634 
    L = ['%s=%r' % (key, value)
13635 
      for key, value in self.__dict__.iteritems()]
13636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13637 
 
13638 
  def __eq__(self, other):
13639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13640 
 
13641 
  def __ne__(self, other):
13642 
    return not (self == other)
13643 
 
1208 chandransh 13644 
class markOrderAsOutOfStock_args:
13645 
  """
13646 
  Attributes:
13647 
   - orderId
13648 
  """
13649 
 
13650 
  thrift_spec = (
13651 
    None, # 0
13652 
    (1, TType.I64, 'orderId', None, None, ), # 1
13653 
  )
13654 
 
13655 
  def __init__(self, orderId=None,):
13656 
    self.orderId = orderId
13657 
 
13658 
  def read(self, iprot):
13659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13661 
      return
13662 
    iprot.readStructBegin()
13663 
    while True:
13664 
      (fname, ftype, fid) = iprot.readFieldBegin()
13665 
      if ftype == TType.STOP:
13666 
        break
13667 
      if fid == 1:
13668 
        if ftype == TType.I64:
13669 
          self.orderId = iprot.readI64();
13670 
        else:
13671 
          iprot.skip(ftype)
13672 
      else:
13673 
        iprot.skip(ftype)
13674 
      iprot.readFieldEnd()
13675 
    iprot.readStructEnd()
13676 
 
13677 
  def write(self, oprot):
13678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13680 
      return
13681 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13682 
    if self.orderId is not None:
1208 chandransh 13683 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13684 
      oprot.writeI64(self.orderId)
13685 
      oprot.writeFieldEnd()
13686 
    oprot.writeFieldStop()
13687 
    oprot.writeStructEnd()
13688 
 
3431 rajveer 13689 
  def validate(self):
13690 
    return
13691 
 
13692 
 
1208 chandransh 13693 
  def __repr__(self):
13694 
    L = ['%s=%r' % (key, value)
13695 
      for key, value in self.__dict__.iteritems()]
13696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13697 
 
13698 
  def __eq__(self, other):
13699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13700 
 
13701 
  def __ne__(self, other):
13702 
    return not (self == other)
13703 
 
13704 
class markOrderAsOutOfStock_result:
13705 
  """
13706 
  Attributes:
13707 
   - success
13708 
   - ex
13709 
  """
13710 
 
13711 
  thrift_spec = (
13712 
    (0, TType.BOOL, 'success', None, None, ), # 0
13713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13714 
  )
13715 
 
13716 
  def __init__(self, success=None, ex=None,):
13717 
    self.success = success
13718 
    self.ex = ex
13719 
 
13720 
  def read(self, iprot):
13721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13723 
      return
13724 
    iprot.readStructBegin()
13725 
    while True:
13726 
      (fname, ftype, fid) = iprot.readFieldBegin()
13727 
      if ftype == TType.STOP:
13728 
        break
13729 
      if fid == 0:
13730 
        if ftype == TType.BOOL:
13731 
          self.success = iprot.readBool();
13732 
        else:
13733 
          iprot.skip(ftype)
13734 
      elif fid == 1:
13735 
        if ftype == TType.STRUCT:
13736 
          self.ex = TransactionServiceException()
13737 
          self.ex.read(iprot)
13738 
        else:
13739 
          iprot.skip(ftype)
13740 
      else:
13741 
        iprot.skip(ftype)
13742 
      iprot.readFieldEnd()
13743 
    iprot.readStructEnd()
13744 
 
13745 
  def write(self, oprot):
13746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13748 
      return
13749 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13750 
    if self.success is not None:
1208 chandransh 13751 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13752 
      oprot.writeBool(self.success)
13753 
      oprot.writeFieldEnd()
3431 rajveer 13754 
    if self.ex is not None:
1208 chandransh 13755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13756 
      self.ex.write(oprot)
13757 
      oprot.writeFieldEnd()
13758 
    oprot.writeFieldStop()
13759 
    oprot.writeStructEnd()
13760 
 
3431 rajveer 13761 
  def validate(self):
13762 
    return
13763 
 
13764 
 
1208 chandransh 13765 
  def __repr__(self):
13766 
    L = ['%s=%r' % (key, value)
13767 
      for key, value in self.__dict__.iteritems()]
13768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13769 
 
13770 
  def __eq__(self, other):
13771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13772 
 
13773 
  def __ne__(self, other):
13774 
    return not (self == other)
13775 
 
3064 chandransh 13776 
class verifyOrder_args:
759 chandransh 13777 
  """
13778 
  Attributes:
3064 chandransh 13779 
   - orderId
759 chandransh 13780 
  """
13781 
 
13782 
  thrift_spec = (
13783 
    None, # 0
3064 chandransh 13784 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13785 
  )
13786 
 
3064 chandransh 13787 
  def __init__(self, orderId=None,):
13788 
    self.orderId = orderId
759 chandransh 13789 
 
13790 
  def read(self, iprot):
13791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13793 
      return
13794 
    iprot.readStructBegin()
13795 
    while True:
13796 
      (fname, ftype, fid) = iprot.readFieldBegin()
13797 
      if ftype == TType.STOP:
13798 
        break
13799 
      if fid == 1:
13800 
        if ftype == TType.I64:
3064 chandransh 13801 
          self.orderId = iprot.readI64();
759 chandransh 13802 
        else:
13803 
          iprot.skip(ftype)
13804 
      else:
13805 
        iprot.skip(ftype)
13806 
      iprot.readFieldEnd()
13807 
    iprot.readStructEnd()
13808 
 
13809 
  def write(self, oprot):
13810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13812 
      return
3064 chandransh 13813 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13814 
    if self.orderId is not None:
3064 chandransh 13815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13816 
      oprot.writeI64(self.orderId)
759 chandransh 13817 
      oprot.writeFieldEnd()
13818 
    oprot.writeFieldStop()
13819 
    oprot.writeStructEnd()
13820 
 
3431 rajveer 13821 
  def validate(self):
13822 
    return
13823 
 
13824 
 
759 chandransh 13825 
  def __repr__(self):
13826 
    L = ['%s=%r' % (key, value)
13827 
      for key, value in self.__dict__.iteritems()]
13828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13829 
 
13830 
  def __eq__(self, other):
13831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13832 
 
13833 
  def __ne__(self, other):
13834 
    return not (self == other)
13835 
 
3064 chandransh 13836 
class verifyOrder_result:
759 chandransh 13837 
  """
13838 
  Attributes:
13839 
   - success
13840 
   - ex
13841 
  """
13842 
 
13843 
  thrift_spec = (
13844 
    (0, TType.BOOL, 'success', None, None, ), # 0
13845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13846 
  )
13847 
 
13848 
  def __init__(self, success=None, ex=None,):
13849 
    self.success = success
13850 
    self.ex = ex
13851 
 
13852 
  def read(self, iprot):
13853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13855 
      return
13856 
    iprot.readStructBegin()
13857 
    while True:
13858 
      (fname, ftype, fid) = iprot.readFieldBegin()
13859 
      if ftype == TType.STOP:
13860 
        break
13861 
      if fid == 0:
13862 
        if ftype == TType.BOOL:
13863 
          self.success = iprot.readBool();
13864 
        else:
13865 
          iprot.skip(ftype)
13866 
      elif fid == 1:
13867 
        if ftype == TType.STRUCT:
13868 
          self.ex = TransactionServiceException()
13869 
          self.ex.read(iprot)
13870 
        else:
13871 
          iprot.skip(ftype)
13872 
      else:
13873 
        iprot.skip(ftype)
13874 
      iprot.readFieldEnd()
13875 
    iprot.readStructEnd()
13876 
 
13877 
  def write(self, oprot):
13878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13880 
      return
3064 chandransh 13881 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13882 
    if self.success is not None:
759 chandransh 13883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13884 
      oprot.writeBool(self.success)
13885 
      oprot.writeFieldEnd()
3431 rajveer 13886 
    if self.ex is not None:
759 chandransh 13887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13888 
      self.ex.write(oprot)
13889 
      oprot.writeFieldEnd()
13890 
    oprot.writeFieldStop()
13891 
    oprot.writeStructEnd()
13892 
 
3431 rajveer 13893 
  def validate(self):
13894 
    return
13895 
 
13896 
 
759 chandransh 13897 
  def __repr__(self):
13898 
    L = ['%s=%r' % (key, value)
13899 
      for key, value in self.__dict__.iteritems()]
13900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13901 
 
13902 
  def __eq__(self, other):
13903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13904 
 
13905 
  def __ne__(self, other):
13906 
    return not (self == other)
13907 
 
3064 chandransh 13908 
class acceptOrder_args:
1113 chandransh 13909 
  """
13910 
  Attributes:
3064 chandransh 13911 
   - orderId
1113 chandransh 13912 
  """
13913 
 
13914 
  thrift_spec = (
13915 
    None, # 0
3064 chandransh 13916 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13917 
  )
13918 
 
3064 chandransh 13919 
  def __init__(self, orderId=None,):
13920 
    self.orderId = orderId
1113 chandransh 13921 
 
13922 
  def read(self, iprot):
13923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13925 
      return
13926 
    iprot.readStructBegin()
13927 
    while True:
13928 
      (fname, ftype, fid) = iprot.readFieldBegin()
13929 
      if ftype == TType.STOP:
13930 
        break
13931 
      if fid == 1:
13932 
        if ftype == TType.I64:
3064 chandransh 13933 
          self.orderId = iprot.readI64();
1113 chandransh 13934 
        else:
13935 
          iprot.skip(ftype)
13936 
      else:
13937 
        iprot.skip(ftype)
13938 
      iprot.readFieldEnd()
13939 
    iprot.readStructEnd()
13940 
 
13941 
  def write(self, oprot):
13942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13944 
      return
3064 chandransh 13945 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13946 
    if self.orderId is not None:
3064 chandransh 13947 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13948 
      oprot.writeI64(self.orderId)
1113 chandransh 13949 
      oprot.writeFieldEnd()
13950 
    oprot.writeFieldStop()
13951 
    oprot.writeStructEnd()
13952 
 
3431 rajveer 13953 
  def validate(self):
13954 
    return
13955 
 
13956 
 
1113 chandransh 13957 
  def __repr__(self):
13958 
    L = ['%s=%r' % (key, value)
13959 
      for key, value in self.__dict__.iteritems()]
13960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13961 
 
13962 
  def __eq__(self, other):
13963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13964 
 
13965 
  def __ne__(self, other):
13966 
    return not (self == other)
13967 
 
3064 chandransh 13968 
class acceptOrder_result:
1113 chandransh 13969 
  """
13970 
  Attributes:
13971 
   - success
13972 
   - ex
13973 
  """
13974 
 
13975 
  thrift_spec = (
3064 chandransh 13976 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13978 
  )
13979 
 
13980 
  def __init__(self, success=None, ex=None,):
13981 
    self.success = success
13982 
    self.ex = ex
13983 
 
13984 
  def read(self, iprot):
13985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13987 
      return
13988 
    iprot.readStructBegin()
13989 
    while True:
13990 
      (fname, ftype, fid) = iprot.readFieldBegin()
13991 
      if ftype == TType.STOP:
13992 
        break
13993 
      if fid == 0:
3064 chandransh 13994 
        if ftype == TType.BOOL:
13995 
          self.success = iprot.readBool();
1113 chandransh 13996 
        else:
13997 
          iprot.skip(ftype)
13998 
      elif fid == 1:
13999 
        if ftype == TType.STRUCT:
14000 
          self.ex = TransactionServiceException()
14001 
          self.ex.read(iprot)
14002 
        else:
14003 
          iprot.skip(ftype)
14004 
      else:
14005 
        iprot.skip(ftype)
14006 
      iprot.readFieldEnd()
14007 
    iprot.readStructEnd()
14008 
 
14009 
  def write(self, oprot):
14010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14012 
      return
3064 chandransh 14013 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14014 
    if self.success is not None:
3064 chandransh 14015 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14016 
      oprot.writeBool(self.success)
1113 chandransh 14017 
      oprot.writeFieldEnd()
3431 rajveer 14018 
    if self.ex is not None:
1113 chandransh 14019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14020 
      self.ex.write(oprot)
14021 
      oprot.writeFieldEnd()
14022 
    oprot.writeFieldStop()
14023 
    oprot.writeStructEnd()
14024 
 
3431 rajveer 14025 
  def validate(self):
14026 
    return
14027 
 
14028 
 
1113 chandransh 14029 
  def __repr__(self):
14030 
    L = ['%s=%r' % (key, value)
14031 
      for key, value in self.__dict__.iteritems()]
14032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14033 
 
14034 
  def __eq__(self, other):
14035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14036 
 
14037 
  def __ne__(self, other):
14038 
    return not (self == other)
14039 
 
3064 chandransh 14040 
class addBillingDetails_args:
1135 chandransh 14041 
  """
14042 
  Attributes:
3064 chandransh 14043 
   - orderId
14044 
   - invoice_number
4658 mandeep.dh 14045 
   - serialNumber
4283 anupam.sin 14046 
   - itemNumber
3064 chandransh 14047 
   - billed_by
4264 rajveer 14048 
   - jacketNumber
4283 anupam.sin 14049 
   - billingType
5110 mandeep.dh 14050 
   - fulfilmentWarehouseId
4763 rajveer 14051 
   - authorize
1135 chandransh 14052 
  """
14053 
 
14054 
  thrift_spec = (
14055 
    None, # 0
3064 chandransh 14056 
    (1, TType.I64, 'orderId', None, None, ), # 1
14057 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14058 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14059 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14060 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14061 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14062 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14063 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14064 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14065 
  )
14066 
 
5110 mandeep.dh 14067 
  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 14068 
    self.orderId = orderId
14069 
    self.invoice_number = invoice_number
4658 mandeep.dh 14070 
    self.serialNumber = serialNumber
4283 anupam.sin 14071 
    self.itemNumber = itemNumber
3064 chandransh 14072 
    self.billed_by = billed_by
4264 rajveer 14073 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14074 
    self.billingType = billingType
5110 mandeep.dh 14075 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14076 
    self.authorize = authorize
1135 chandransh 14077 
 
14078 
  def read(self, iprot):
14079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14081 
      return
14082 
    iprot.readStructBegin()
14083 
    while True:
14084 
      (fname, ftype, fid) = iprot.readFieldBegin()
14085 
      if ftype == TType.STOP:
14086 
        break
14087 
      if fid == 1:
14088 
        if ftype == TType.I64:
3064 chandransh 14089 
          self.orderId = iprot.readI64();
1135 chandransh 14090 
        else:
14091 
          iprot.skip(ftype)
14092 
      elif fid == 2:
3064 chandransh 14093 
        if ftype == TType.STRING:
14094 
          self.invoice_number = iprot.readString();
1135 chandransh 14095 
        else:
14096 
          iprot.skip(ftype)
3064 chandransh 14097 
      elif fid == 3:
5411 rajveer 14098 
        if ftype == TType.LIST:
14099 
          self.serialNumber = []
6188 rajveer 14100 
          (_etype270, _size267) = iprot.readListBegin()
14101 
          for _i271 in xrange(_size267):
14102 
            _elem272 = iprot.readString();
14103 
            self.serialNumber.append(_elem272)
5411 rajveer 14104 
          iprot.readListEnd()
3064 chandransh 14105 
        else:
14106 
          iprot.skip(ftype)
14107 
      elif fid == 4:
5411 rajveer 14108 
        if ftype == TType.LIST:
14109 
          self.itemNumber = []
6188 rajveer 14110 
          (_etype276, _size273) = iprot.readListBegin()
14111 
          for _i277 in xrange(_size273):
14112 
            _elem278 = iprot.readString();
14113 
            self.itemNumber.append(_elem278)
5411 rajveer 14114 
          iprot.readListEnd()
3064 chandransh 14115 
        else:
14116 
          iprot.skip(ftype)
14117 
      elif fid == 5:
14118 
        if ftype == TType.STRING:
4283 anupam.sin 14119 
          self.billed_by = iprot.readString();
3064 chandransh 14120 
        else:
14121 
          iprot.skip(ftype)
14122 
      elif fid == 6:
14123 
        if ftype == TType.I64:
4283 anupam.sin 14124 
          self.jacketNumber = iprot.readI64();
14125 
        else:
14126 
          iprot.skip(ftype)
14127 
      elif fid == 7:
14128 
        if ftype == TType.I64:
3064 chandransh 14129 
          self.billingType = iprot.readI64();
14130 
        else:
14131 
          iprot.skip(ftype)
4283 anupam.sin 14132 
      elif fid == 8:
14133 
        if ftype == TType.I64:
5110 mandeep.dh 14134 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14135 
        else:
14136 
          iprot.skip(ftype)
4763 rajveer 14137 
      elif fid == 9:
14138 
        if ftype == TType.BOOL:
14139 
          self.authorize = iprot.readBool();
14140 
        else:
14141 
          iprot.skip(ftype)
1246 chandransh 14142 
      else:
14143 
        iprot.skip(ftype)
14144 
      iprot.readFieldEnd()
14145 
    iprot.readStructEnd()
14146 
 
14147 
  def write(self, oprot):
14148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14150 
      return
4283 anupam.sin 14151 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14152 
    if self.orderId is not None:
3064 chandransh 14153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14154 
      oprot.writeI64(self.orderId)
1246 chandransh 14155 
      oprot.writeFieldEnd()
4283 anupam.sin 14156 
    if self.invoice_number is not None:
14157 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14158 
      oprot.writeString(self.invoice_number)
1246 chandransh 14159 
      oprot.writeFieldEnd()
4658 mandeep.dh 14160 
    if self.serialNumber is not None:
5411 rajveer 14161 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14162 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14163 
      for iter279 in self.serialNumber:
14164 
        oprot.writeString(iter279)
5411 rajveer 14165 
      oprot.writeListEnd()
3064 chandransh 14166 
      oprot.writeFieldEnd()
3431 rajveer 14167 
    if self.itemNumber is not None:
5411 rajveer 14168 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14169 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14170 
      for iter280 in self.itemNumber:
14171 
        oprot.writeString(iter280)
5411 rajveer 14172 
      oprot.writeListEnd()
3064 chandransh 14173 
      oprot.writeFieldEnd()
4283 anupam.sin 14174 
    if self.billed_by is not None:
14175 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14176 
      oprot.writeString(self.billed_by)
3064 chandransh 14177 
      oprot.writeFieldEnd()
4283 anupam.sin 14178 
    if self.jacketNumber is not None:
14179 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14180 
      oprot.writeI64(self.jacketNumber)
14181 
      oprot.writeFieldEnd()
3431 rajveer 14182 
    if self.billingType is not None:
4283 anupam.sin 14183 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14184 
      oprot.writeI64(self.billingType)
14185 
      oprot.writeFieldEnd()
5110 mandeep.dh 14186 
    if self.fulfilmentWarehouseId is not None:
14187 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14188 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14189 
      oprot.writeFieldEnd()
4763 rajveer 14190 
    if self.authorize is not None:
14191 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14192 
      oprot.writeBool(self.authorize)
14193 
      oprot.writeFieldEnd()
1246 chandransh 14194 
    oprot.writeFieldStop()
14195 
    oprot.writeStructEnd()
14196 
 
3431 rajveer 14197 
  def validate(self):
14198 
    return
14199 
 
14200 
 
1246 chandransh 14201 
  def __repr__(self):
14202 
    L = ['%s=%r' % (key, value)
14203 
      for key, value in self.__dict__.iteritems()]
14204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14205 
 
14206 
  def __eq__(self, other):
14207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14208 
 
14209 
  def __ne__(self, other):
14210 
    return not (self == other)
14211 
 
4283 anupam.sin 14212 
class addBillingDetails_result:
1246 chandransh 14213 
  """
14214 
  Attributes:
3064 chandransh 14215 
   - success
1246 chandransh 14216 
   - ex
14217 
  """
14218 
 
14219 
  thrift_spec = (
3064 chandransh 14220 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14222 
  )
14223 
 
3064 chandransh 14224 
  def __init__(self, success=None, ex=None,):
14225 
    self.success = success
1246 chandransh 14226 
    self.ex = ex
14227 
 
14228 
  def read(self, iprot):
14229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14231 
      return
14232 
    iprot.readStructBegin()
14233 
    while True:
14234 
      (fname, ftype, fid) = iprot.readFieldBegin()
14235 
      if ftype == TType.STOP:
14236 
        break
3064 chandransh 14237 
      if fid == 0:
14238 
        if ftype == TType.BOOL:
14239 
          self.success = iprot.readBool();
14240 
        else:
14241 
          iprot.skip(ftype)
14242 
      elif fid == 1:
1246 chandransh 14243 
        if ftype == TType.STRUCT:
14244 
          self.ex = TransactionServiceException()
14245 
          self.ex.read(iprot)
14246 
        else:
14247 
          iprot.skip(ftype)
14248 
      else:
14249 
        iprot.skip(ftype)
14250 
      iprot.readFieldEnd()
14251 
    iprot.readStructEnd()
14252 
 
14253 
  def write(self, oprot):
14254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14256 
      return
4283 anupam.sin 14257 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14258 
    if self.success is not None:
3064 chandransh 14259 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14260 
      oprot.writeBool(self.success)
14261 
      oprot.writeFieldEnd()
3431 rajveer 14262 
    if self.ex is not None:
1246 chandransh 14263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14264 
      self.ex.write(oprot)
14265 
      oprot.writeFieldEnd()
14266 
    oprot.writeFieldStop()
14267 
    oprot.writeStructEnd()
14268 
 
3431 rajveer 14269 
  def validate(self):
14270 
    return
14271 
 
14272 
 
1246 chandransh 14273 
  def __repr__(self):
14274 
    L = ['%s=%r' % (key, value)
14275 
      for key, value in self.__dict__.iteritems()]
14276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14277 
 
14278 
  def __eq__(self, other):
14279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14280 
 
14281 
  def __ne__(self, other):
14282 
    return not (self == other)
14283 
 
4579 rajveer 14284 
class addInvoiceNumber_args:
14285 
  """
14286 
  Attributes:
14287 
   - orderId
14288 
   - invoiceNumber
4763 rajveer 14289 
   - color
6756 amar.kumar 14290 
   - serialNumber
14291 
   - itemNumber
4579 rajveer 14292 
  """
14293 
 
14294 
  thrift_spec = (
14295 
    None, # 0
14296 
    (1, TType.I64, 'orderId', None, None, ), # 1
14297 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14298 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14299 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14300 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14301 
  )
14302 
 
6756 amar.kumar 14303 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14304 
    self.orderId = orderId
14305 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14306 
    self.color = color
6756 amar.kumar 14307 
    self.serialNumber = serialNumber
14308 
    self.itemNumber = itemNumber
4579 rajveer 14309 
 
14310 
  def read(self, iprot):
14311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14313 
      return
14314 
    iprot.readStructBegin()
14315 
    while True:
14316 
      (fname, ftype, fid) = iprot.readFieldBegin()
14317 
      if ftype == TType.STOP:
14318 
        break
14319 
      if fid == 1:
14320 
        if ftype == TType.I64:
14321 
          self.orderId = iprot.readI64();
14322 
        else:
14323 
          iprot.skip(ftype)
14324 
      elif fid == 2:
14325 
        if ftype == TType.STRING:
14326 
          self.invoiceNumber = iprot.readString();
14327 
        else:
14328 
          iprot.skip(ftype)
4763 rajveer 14329 
      elif fid == 3:
14330 
        if ftype == TType.STRING:
14331 
          self.color = iprot.readString();
14332 
        else:
14333 
          iprot.skip(ftype)
6756 amar.kumar 14334 
      elif fid == 4:
14335 
        if ftype == TType.STRING:
14336 
          self.serialNumber = iprot.readString();
14337 
        else:
14338 
          iprot.skip(ftype)
14339 
      elif fid == 5:
14340 
        if ftype == TType.STRING:
14341 
          self.itemNumber = iprot.readString();
14342 
        else:
14343 
          iprot.skip(ftype)
4579 rajveer 14344 
      else:
14345 
        iprot.skip(ftype)
14346 
      iprot.readFieldEnd()
14347 
    iprot.readStructEnd()
14348 
 
14349 
  def write(self, oprot):
14350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14352 
      return
14353 
    oprot.writeStructBegin('addInvoiceNumber_args')
14354 
    if self.orderId is not None:
14355 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14356 
      oprot.writeI64(self.orderId)
14357 
      oprot.writeFieldEnd()
14358 
    if self.invoiceNumber is not None:
14359 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14360 
      oprot.writeString(self.invoiceNumber)
14361 
      oprot.writeFieldEnd()
4763 rajveer 14362 
    if self.color is not None:
14363 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14364 
      oprot.writeString(self.color)
14365 
      oprot.writeFieldEnd()
6756 amar.kumar 14366 
    if self.serialNumber is not None:
14367 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14368 
      oprot.writeString(self.serialNumber)
14369 
      oprot.writeFieldEnd()
14370 
    if self.itemNumber is not None:
14371 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14372 
      oprot.writeString(self.itemNumber)
14373 
      oprot.writeFieldEnd()
4579 rajveer 14374 
    oprot.writeFieldStop()
14375 
    oprot.writeStructEnd()
14376 
 
14377 
  def validate(self):
14378 
    return
14379 
 
14380 
 
14381 
  def __repr__(self):
14382 
    L = ['%s=%r' % (key, value)
14383 
      for key, value in self.__dict__.iteritems()]
14384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14385 
 
14386 
  def __eq__(self, other):
14387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14388 
 
14389 
  def __ne__(self, other):
14390 
    return not (self == other)
14391 
 
14392 
class addInvoiceNumber_result:
14393 
  """
14394 
  Attributes:
14395 
   - ex
14396 
  """
14397 
 
14398 
  thrift_spec = (
14399 
    None, # 0
14400 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14401 
  )
14402 
 
14403 
  def __init__(self, ex=None,):
14404 
    self.ex = ex
14405 
 
14406 
  def read(self, iprot):
14407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14409 
      return
14410 
    iprot.readStructBegin()
14411 
    while True:
14412 
      (fname, ftype, fid) = iprot.readFieldBegin()
14413 
      if ftype == TType.STOP:
14414 
        break
14415 
      if fid == 1:
14416 
        if ftype == TType.STRUCT:
14417 
          self.ex = TransactionServiceException()
14418 
          self.ex.read(iprot)
14419 
        else:
14420 
          iprot.skip(ftype)
14421 
      else:
14422 
        iprot.skip(ftype)
14423 
      iprot.readFieldEnd()
14424 
    iprot.readStructEnd()
14425 
 
14426 
  def write(self, oprot):
14427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14429 
      return
14430 
    oprot.writeStructBegin('addInvoiceNumber_result')
14431 
    if self.ex is not None:
14432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14433 
      self.ex.write(oprot)
14434 
      oprot.writeFieldEnd()
14435 
    oprot.writeFieldStop()
14436 
    oprot.writeStructEnd()
14437 
 
14438 
  def validate(self):
14439 
    return
14440 
 
14441 
 
14442 
  def __repr__(self):
14443 
    L = ['%s=%r' % (key, value)
14444 
      for key, value in self.__dict__.iteritems()]
14445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14446 
 
14447 
  def __eq__(self, other):
14448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14449 
 
14450 
  def __ne__(self, other):
14451 
    return not (self == other)
14452 
 
4910 phani.kuma 14453 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14454 
  """
14455 
  Attributes:
3064 chandransh 14456 
   - warehouseId
1408 ankur.sing 14457 
   - providerId
3064 chandransh 14458 
   - cod
4910 phani.kuma 14459 
   - orderIds
1408 ankur.sing 14460 
  """
14461 
 
14462 
  thrift_spec = (
14463 
    None, # 0
3064 chandransh 14464 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14465 
    (2, TType.I64, 'providerId', None, None, ), # 2
14466 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14467 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14468 
  )
14469 
 
4910 phani.kuma 14470 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14471 
    self.warehouseId = warehouseId
1408 ankur.sing 14472 
    self.providerId = providerId
3064 chandransh 14473 
    self.cod = cod
4910 phani.kuma 14474 
    self.orderIds = orderIds
1408 ankur.sing 14475 
 
14476 
  def read(self, iprot):
14477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14479 
      return
14480 
    iprot.readStructBegin()
14481 
    while True:
14482 
      (fname, ftype, fid) = iprot.readFieldBegin()
14483 
      if ftype == TType.STOP:
14484 
        break
14485 
      if fid == 1:
14486 
        if ftype == TType.I64:
3064 chandransh 14487 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14488 
        else:
14489 
          iprot.skip(ftype)
14490 
      elif fid == 2:
14491 
        if ftype == TType.I64:
3064 chandransh 14492 
          self.providerId = iprot.readI64();
1408 ankur.sing 14493 
        else:
14494 
          iprot.skip(ftype)
3064 chandransh 14495 
      elif fid == 3:
14496 
        if ftype == TType.BOOL:
14497 
          self.cod = iprot.readBool();
14498 
        else:
14499 
          iprot.skip(ftype)
4910 phani.kuma 14500 
      elif fid == 4:
14501 
        if ftype == TType.LIST:
14502 
          self.orderIds = []
6188 rajveer 14503 
          (_etype284, _size281) = iprot.readListBegin()
14504 
          for _i285 in xrange(_size281):
14505 
            _elem286 = iprot.readI64();
14506 
            self.orderIds.append(_elem286)
4910 phani.kuma 14507 
          iprot.readListEnd()
14508 
        else:
14509 
          iprot.skip(ftype)
1408 ankur.sing 14510 
      else:
14511 
        iprot.skip(ftype)
14512 
      iprot.readFieldEnd()
14513 
    iprot.readStructEnd()
14514 
 
14515 
  def write(self, oprot):
14516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14518 
      return
4910 phani.kuma 14519 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14520 
    if self.warehouseId is not None:
3064 chandransh 14521 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14522 
      oprot.writeI64(self.warehouseId)
14523 
      oprot.writeFieldEnd()
3431 rajveer 14524 
    if self.providerId is not None:
3064 chandransh 14525 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14526 
      oprot.writeI64(self.providerId)
14527 
      oprot.writeFieldEnd()
3431 rajveer 14528 
    if self.cod is not None:
3064 chandransh 14529 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14530 
      oprot.writeBool(self.cod)
1408 ankur.sing 14531 
      oprot.writeFieldEnd()
4910 phani.kuma 14532 
    if self.orderIds is not None:
14533 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14534 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14535 
      for iter287 in self.orderIds:
14536 
        oprot.writeI64(iter287)
4910 phani.kuma 14537 
      oprot.writeListEnd()
14538 
      oprot.writeFieldEnd()
1408 ankur.sing 14539 
    oprot.writeFieldStop()
14540 
    oprot.writeStructEnd()
14541 
 
3431 rajveer 14542 
  def validate(self):
14543 
    return
14544 
 
14545 
 
1408 ankur.sing 14546 
  def __repr__(self):
14547 
    L = ['%s=%r' % (key, value)
14548 
      for key, value in self.__dict__.iteritems()]
14549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14550 
 
14551 
  def __eq__(self, other):
14552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14553 
 
14554 
  def __ne__(self, other):
14555 
    return not (self == other)
14556 
 
4910 phani.kuma 14557 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14558 
  """
14559 
  Attributes:
14560 
   - success
3064 chandransh 14561 
   - ex
1408 ankur.sing 14562 
  """
14563 
 
14564 
  thrift_spec = (
3064 chandransh 14565 
    (0, TType.BOOL, 'success', None, None, ), # 0
14566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14567 
  )
14568 
 
3064 chandransh 14569 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14570 
    self.success = success
3064 chandransh 14571 
    self.ex = ex
1408 ankur.sing 14572 
 
14573 
  def read(self, iprot):
14574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14576 
      return
14577 
    iprot.readStructBegin()
14578 
    while True:
14579 
      (fname, ftype, fid) = iprot.readFieldBegin()
14580 
      if ftype == TType.STOP:
14581 
        break
14582 
      if fid == 0:
3064 chandransh 14583 
        if ftype == TType.BOOL:
14584 
          self.success = iprot.readBool();
1408 ankur.sing 14585 
        else:
14586 
          iprot.skip(ftype)
3064 chandransh 14587 
      elif fid == 1:
14588 
        if ftype == TType.STRUCT:
14589 
          self.ex = TransactionServiceException()
14590 
          self.ex.read(iprot)
14591 
        else:
14592 
          iprot.skip(ftype)
1408 ankur.sing 14593 
      else:
14594 
        iprot.skip(ftype)
14595 
      iprot.readFieldEnd()
14596 
    iprot.readStructEnd()
14597 
 
14598 
  def write(self, oprot):
14599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14601 
      return
4910 phani.kuma 14602 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14603 
    if self.success is not None:
3064 chandransh 14604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14605 
      oprot.writeBool(self.success)
1408 ankur.sing 14606 
      oprot.writeFieldEnd()
3431 rajveer 14607 
    if self.ex is not None:
3064 chandransh 14608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14609 
      self.ex.write(oprot)
14610 
      oprot.writeFieldEnd()
1408 ankur.sing 14611 
    oprot.writeFieldStop()
14612 
    oprot.writeStructEnd()
14613 
 
3431 rajveer 14614 
  def validate(self):
14615 
    return
14616 
 
14617 
 
1408 ankur.sing 14618 
  def __repr__(self):
14619 
    L = ['%s=%r' % (key, value)
14620 
      for key, value in self.__dict__.iteritems()]
14621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14622 
 
14623 
  def __eq__(self, other):
14624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14625 
 
14626 
  def __ne__(self, other):
14627 
    return not (self == other)
14628 
 
5676 rajveer 14629 
class markOrdersAsReturnedFromStore_args:
14630 
  """
14631 
  Attributes:
14632 
   - providerId
14633 
   - orderIds
5713 rajveer 14634 
   - awbs
5676 rajveer 14635 
  """
14636 
 
14637 
  thrift_spec = (
14638 
    None, # 0
14639 
    (1, TType.I64, 'providerId', None, None, ), # 1
14640 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14641 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14642 
  )
14643 
 
5713 rajveer 14644 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14645 
    self.providerId = providerId
14646 
    self.orderIds = orderIds
5713 rajveer 14647 
    self.awbs = awbs
5676 rajveer 14648 
 
14649 
  def read(self, iprot):
14650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14652 
      return
14653 
    iprot.readStructBegin()
14654 
    while True:
14655 
      (fname, ftype, fid) = iprot.readFieldBegin()
14656 
      if ftype == TType.STOP:
14657 
        break
14658 
      if fid == 1:
14659 
        if ftype == TType.I64:
14660 
          self.providerId = iprot.readI64();
14661 
        else:
14662 
          iprot.skip(ftype)
14663 
      elif fid == 2:
14664 
        if ftype == TType.LIST:
14665 
          self.orderIds = []
6188 rajveer 14666 
          (_etype291, _size288) = iprot.readListBegin()
14667 
          for _i292 in xrange(_size288):
14668 
            _elem293 = iprot.readI64();
14669 
            self.orderIds.append(_elem293)
5676 rajveer 14670 
          iprot.readListEnd()
14671 
        else:
14672 
          iprot.skip(ftype)
5713 rajveer 14673 
      elif fid == 3:
14674 
        if ftype == TType.LIST:
14675 
          self.awbs = []
6188 rajveer 14676 
          (_etype297, _size294) = iprot.readListBegin()
14677 
          for _i298 in xrange(_size294):
14678 
            _elem299 = iprot.readString();
14679 
            self.awbs.append(_elem299)
5713 rajveer 14680 
          iprot.readListEnd()
14681 
        else:
14682 
          iprot.skip(ftype)
5676 rajveer 14683 
      else:
14684 
        iprot.skip(ftype)
14685 
      iprot.readFieldEnd()
14686 
    iprot.readStructEnd()
14687 
 
14688 
  def write(self, oprot):
14689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14691 
      return
14692 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14693 
    if self.providerId is not None:
14694 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14695 
      oprot.writeI64(self.providerId)
14696 
      oprot.writeFieldEnd()
14697 
    if self.orderIds is not None:
14698 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14699 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14700 
      for iter300 in self.orderIds:
14701 
        oprot.writeI64(iter300)
5676 rajveer 14702 
      oprot.writeListEnd()
14703 
      oprot.writeFieldEnd()
5713 rajveer 14704 
    if self.awbs is not None:
14705 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14706 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14707 
      for iter301 in self.awbs:
14708 
        oprot.writeString(iter301)
5713 rajveer 14709 
      oprot.writeListEnd()
14710 
      oprot.writeFieldEnd()
5676 rajveer 14711 
    oprot.writeFieldStop()
14712 
    oprot.writeStructEnd()
14713 
 
14714 
  def validate(self):
14715 
    return
14716 
 
14717 
 
14718 
  def __repr__(self):
14719 
    L = ['%s=%r' % (key, value)
14720 
      for key, value in self.__dict__.iteritems()]
14721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14722 
 
14723 
  def __eq__(self, other):
14724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14725 
 
14726 
  def __ne__(self, other):
14727 
    return not (self == other)
14728 
 
14729 
class markOrdersAsReturnedFromStore_result:
14730 
  """
14731 
  Attributes:
14732 
   - success
14733 
   - ex
14734 
  """
14735 
 
14736 
  thrift_spec = (
14737 
    (0, TType.BOOL, 'success', None, None, ), # 0
14738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14739 
  )
14740 
 
14741 
  def __init__(self, success=None, ex=None,):
14742 
    self.success = success
14743 
    self.ex = ex
14744 
 
14745 
  def read(self, iprot):
14746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14748 
      return
14749 
    iprot.readStructBegin()
14750 
    while True:
14751 
      (fname, ftype, fid) = iprot.readFieldBegin()
14752 
      if ftype == TType.STOP:
14753 
        break
14754 
      if fid == 0:
14755 
        if ftype == TType.BOOL:
14756 
          self.success = iprot.readBool();
14757 
        else:
14758 
          iprot.skip(ftype)
14759 
      elif fid == 1:
14760 
        if ftype == TType.STRUCT:
14761 
          self.ex = TransactionServiceException()
14762 
          self.ex.read(iprot)
14763 
        else:
14764 
          iprot.skip(ftype)
14765 
      else:
14766 
        iprot.skip(ftype)
14767 
      iprot.readFieldEnd()
14768 
    iprot.readStructEnd()
14769 
 
14770 
  def write(self, oprot):
14771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14773 
      return
14774 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14775 
    if self.success is not None:
14776 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14777 
      oprot.writeBool(self.success)
14778 
      oprot.writeFieldEnd()
14779 
    if self.ex is not None:
14780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14781 
      self.ex.write(oprot)
14782 
      oprot.writeFieldEnd()
14783 
    oprot.writeFieldStop()
14784 
    oprot.writeStructEnd()
14785 
 
14786 
  def validate(self):
14787 
    return
14788 
 
14789 
 
14790 
  def __repr__(self):
14791 
    L = ['%s=%r' % (key, value)
14792 
      for key, value in self.__dict__.iteritems()]
14793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14794 
 
14795 
  def __eq__(self, other):
14796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14797 
 
14798 
  def __ne__(self, other):
14799 
    return not (self == other)
14800 
 
4910 phani.kuma 14801 
class markOrdersAsPickedUp_args:
4410 rajveer 14802 
  """
14803 
  Attributes:
14804 
   - providerId
4910 phani.kuma 14805 
   - pickupDetails
4410 rajveer 14806 
  """
14807 
 
14808 
  thrift_spec = (
14809 
    None, # 0
4910 phani.kuma 14810 
    (1, TType.I64, 'providerId', None, None, ), # 1
14811 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14812 
  )
14813 
 
4910 phani.kuma 14814 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14815 
    self.providerId = providerId
4910 phani.kuma 14816 
    self.pickupDetails = pickupDetails
4410 rajveer 14817 
 
14818 
  def read(self, iprot):
14819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14821 
      return
14822 
    iprot.readStructBegin()
14823 
    while True:
14824 
      (fname, ftype, fid) = iprot.readFieldBegin()
14825 
      if ftype == TType.STOP:
14826 
        break
14827 
      if fid == 1:
14828 
        if ftype == TType.I64:
4910 phani.kuma 14829 
          self.providerId = iprot.readI64();
4410 rajveer 14830 
        else:
14831 
          iprot.skip(ftype)
14832 
      elif fid == 2:
4910 phani.kuma 14833 
        if ftype == TType.MAP:
14834 
          self.pickupDetails = {}
6188 rajveer 14835 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14836 
          for _i306 in xrange(_size302):
14837 
            _key307 = iprot.readString();
14838 
            _val308 = iprot.readString();
14839 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14840 
          iprot.readMapEnd()
4410 rajveer 14841 
        else:
14842 
          iprot.skip(ftype)
14843 
      else:
14844 
        iprot.skip(ftype)
14845 
      iprot.readFieldEnd()
14846 
    iprot.readStructEnd()
14847 
 
14848 
  def write(self, oprot):
14849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14851 
      return
4910 phani.kuma 14852 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14853 
    if self.providerId is not None:
4910 phani.kuma 14854 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14855 
      oprot.writeI64(self.providerId)
14856 
      oprot.writeFieldEnd()
4910 phani.kuma 14857 
    if self.pickupDetails is not None:
14858 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14859 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14860 
      for kiter309,viter310 in self.pickupDetails.items():
14861 
        oprot.writeString(kiter309)
14862 
        oprot.writeString(viter310)
4910 phani.kuma 14863 
      oprot.writeMapEnd()
4410 rajveer 14864 
      oprot.writeFieldEnd()
14865 
    oprot.writeFieldStop()
14866 
    oprot.writeStructEnd()
14867 
 
14868 
  def validate(self):
14869 
    return
14870 
 
14871 
 
14872 
  def __repr__(self):
14873 
    L = ['%s=%r' % (key, value)
14874 
      for key, value in self.__dict__.iteritems()]
14875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14876 
 
14877 
  def __eq__(self, other):
14878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14879 
 
14880 
  def __ne__(self, other):
14881 
    return not (self == other)
14882 
 
4910 phani.kuma 14883 
class markOrdersAsPickedUp_result:
4410 rajveer 14884 
  """
14885 
  Attributes:
14886 
   - ex
14887 
  """
14888 
 
14889 
  thrift_spec = (
4910 phani.kuma 14890 
    None, # 0
4410 rajveer 14891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14892 
  )
14893 
 
4910 phani.kuma 14894 
  def __init__(self, ex=None,):
4410 rajveer 14895 
    self.ex = ex
14896 
 
14897 
  def read(self, iprot):
14898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14900 
      return
14901 
    iprot.readStructBegin()
14902 
    while True:
14903 
      (fname, ftype, fid) = iprot.readFieldBegin()
14904 
      if ftype == TType.STOP:
14905 
        break
4910 phani.kuma 14906 
      if fid == 1:
4410 rajveer 14907 
        if ftype == TType.STRUCT:
14908 
          self.ex = TransactionServiceException()
14909 
          self.ex.read(iprot)
14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      else:
14913 
        iprot.skip(ftype)
14914 
      iprot.readFieldEnd()
14915 
    iprot.readStructEnd()
14916 
 
14917 
  def write(self, oprot):
14918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14920 
      return
4910 phani.kuma 14921 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14922 
    if self.ex is not None:
14923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14924 
      self.ex.write(oprot)
14925 
      oprot.writeFieldEnd()
14926 
    oprot.writeFieldStop()
14927 
    oprot.writeStructEnd()
14928 
 
14929 
  def validate(self):
14930 
    return
14931 
 
14932 
 
14933 
  def __repr__(self):
14934 
    L = ['%s=%r' % (key, value)
14935 
      for key, value in self.__dict__.iteritems()]
14936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14937 
 
14938 
  def __eq__(self, other):
14939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14940 
 
14941 
  def __ne__(self, other):
14942 
    return not (self == other)
14943 
 
4910 phani.kuma 14944 
class getOrdersNotPickedUp_args:
304 ashish 14945 
  """
14946 
  Attributes:
3064 chandransh 14947 
   - providerId
304 ashish 14948 
  """
94 ashish 14949 
 
304 ashish 14950 
  thrift_spec = (
14951 
    None, # 0
3064 chandransh 14952 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14953 
  )
14954 
 
4910 phani.kuma 14955 
  def __init__(self, providerId=None,):
3064 chandransh 14956 
    self.providerId = providerId
304 ashish 14957 
 
14958 
  def read(self, iprot):
14959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14961 
      return
14962 
    iprot.readStructBegin()
14963 
    while True:
14964 
      (fname, ftype, fid) = iprot.readFieldBegin()
14965 
      if ftype == TType.STOP:
14966 
        break
14967 
      if fid == 1:
14968 
        if ftype == TType.I64:
3064 chandransh 14969 
          self.providerId = iprot.readI64();
304 ashish 14970 
        else:
14971 
          iprot.skip(ftype)
14972 
      else:
14973 
        iprot.skip(ftype)
14974 
      iprot.readFieldEnd()
14975 
    iprot.readStructEnd()
14976 
 
14977 
  def write(self, oprot):
14978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14980 
      return
4910 phani.kuma 14981 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14982 
    if self.providerId is not None:
3064 chandransh 14983 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14984 
      oprot.writeI64(self.providerId)
304 ashish 14985 
      oprot.writeFieldEnd()
14986 
    oprot.writeFieldStop()
14987 
    oprot.writeStructEnd()
14988 
 
3431 rajveer 14989 
  def validate(self):
14990 
    return
14991 
 
14992 
 
304 ashish 14993 
  def __repr__(self):
14994 
    L = ['%s=%r' % (key, value)
14995 
      for key, value in self.__dict__.iteritems()]
14996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14997 
 
14998 
  def __eq__(self, other):
14999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15000 
 
15001 
  def __ne__(self, other):
15002 
    return not (self == other)
15003 
 
4910 phani.kuma 15004 
class getOrdersNotPickedUp_result:
304 ashish 15005 
  """
15006 
  Attributes:
15007 
   - success
15008 
  """
15009 
 
15010 
  thrift_spec = (
3064 chandransh 15011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15012 
  )
15013 
 
4910 phani.kuma 15014 
  def __init__(self, success=None,):
304 ashish 15015 
    self.success = success
15016 
 
15017 
  def read(self, iprot):
15018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15020 
      return
15021 
    iprot.readStructBegin()
15022 
    while True:
15023 
      (fname, ftype, fid) = iprot.readFieldBegin()
15024 
      if ftype == TType.STOP:
15025 
        break
15026 
      if fid == 0:
15027 
        if ftype == TType.LIST:
15028 
          self.success = []
6188 rajveer 15029 
          (_etype314, _size311) = iprot.readListBegin()
15030 
          for _i315 in xrange(_size311):
15031 
            _elem316 = Order()
15032 
            _elem316.read(iprot)
15033 
            self.success.append(_elem316)
304 ashish 15034 
          iprot.readListEnd()
15035 
        else:
15036 
          iprot.skip(ftype)
15037 
      else:
15038 
        iprot.skip(ftype)
15039 
      iprot.readFieldEnd()
15040 
    iprot.readStructEnd()
15041 
 
15042 
  def write(self, oprot):
15043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15045 
      return
4910 phani.kuma 15046 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15047 
    if self.success is not None:
304 ashish 15048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15050 
      for iter317 in self.success:
15051 
        iter317.write(oprot)
304 ashish 15052 
      oprot.writeListEnd()
15053 
      oprot.writeFieldEnd()
15054 
    oprot.writeFieldStop()
15055 
    oprot.writeStructEnd()
15056 
 
3431 rajveer 15057 
  def validate(self):
15058 
    return
15059 
 
15060 
 
304 ashish 15061 
  def __repr__(self):
15062 
    L = ['%s=%r' % (key, value)
15063 
      for key, value in self.__dict__.iteritems()]
15064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15065 
 
15066 
  def __eq__(self, other):
15067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15068 
 
15069 
  def __ne__(self, other):
15070 
    return not (self == other)
15071 
 
3064 chandransh 15072 
class markOrdersAsDelivered_args:
304 ashish 15073 
  """
15074 
  Attributes:
3064 chandransh 15075 
   - providerId
15076 
   - deliveredOrders
304 ashish 15077 
  """
15078 
 
15079 
  thrift_spec = (
15080 
    None, # 0
3064 chandransh 15081 
    (1, TType.I64, 'providerId', None, None, ), # 1
15082 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15083 
  )
15084 
 
3064 chandransh 15085 
  def __init__(self, providerId=None, deliveredOrders=None,):
15086 
    self.providerId = providerId
15087 
    self.deliveredOrders = deliveredOrders
304 ashish 15088 
 
15089 
  def read(self, iprot):
15090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15092 
      return
15093 
    iprot.readStructBegin()
15094 
    while True:
15095 
      (fname, ftype, fid) = iprot.readFieldBegin()
15096 
      if ftype == TType.STOP:
15097 
        break
15098 
      if fid == 1:
15099 
        if ftype == TType.I64:
3064 chandransh 15100 
          self.providerId = iprot.readI64();
304 ashish 15101 
        else:
15102 
          iprot.skip(ftype)
15103 
      elif fid == 2:
3064 chandransh 15104 
        if ftype == TType.MAP:
15105 
          self.deliveredOrders = {}
6188 rajveer 15106 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15107 
          for _i322 in xrange(_size318):
15108 
            _key323 = iprot.readString();
15109 
            _val324 = iprot.readString();
15110 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15111 
          iprot.readMapEnd()
304 ashish 15112 
        else:
15113 
          iprot.skip(ftype)
15114 
      else:
15115 
        iprot.skip(ftype)
15116 
      iprot.readFieldEnd()
15117 
    iprot.readStructEnd()
15118 
 
15119 
  def write(self, oprot):
15120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15122 
      return
3064 chandransh 15123 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15124 
    if self.providerId is not None:
3064 chandransh 15125 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15126 
      oprot.writeI64(self.providerId)
304 ashish 15127 
      oprot.writeFieldEnd()
3431 rajveer 15128 
    if self.deliveredOrders is not None:
3064 chandransh 15129 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15130 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15131 
      for kiter325,viter326 in self.deliveredOrders.items():
15132 
        oprot.writeString(kiter325)
15133 
        oprot.writeString(viter326)
3064 chandransh 15134 
      oprot.writeMapEnd()
304 ashish 15135 
      oprot.writeFieldEnd()
15136 
    oprot.writeFieldStop()
15137 
    oprot.writeStructEnd()
15138 
 
3431 rajveer 15139 
  def validate(self):
15140 
    return
15141 
 
15142 
 
304 ashish 15143 
  def __repr__(self):
15144 
    L = ['%s=%r' % (key, value)
15145 
      for key, value in self.__dict__.iteritems()]
15146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15147 
 
15148 
  def __eq__(self, other):
15149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15150 
 
15151 
  def __ne__(self, other):
15152 
    return not (self == other)
15153 
 
3064 chandransh 15154 
class markOrdersAsDelivered_result:
15155 
  """
15156 
  Attributes:
15157 
   - ex
15158 
  """
304 ashish 15159 
 
15160 
  thrift_spec = (
3064 chandransh 15161 
    None, # 0
15162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15163 
  )
15164 
 
3064 chandransh 15165 
  def __init__(self, ex=None,):
15166 
    self.ex = ex
304 ashish 15167 
 
1596 ankur.sing 15168 
  def read(self, iprot):
15169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15171 
      return
15172 
    iprot.readStructBegin()
15173 
    while True:
15174 
      (fname, ftype, fid) = iprot.readFieldBegin()
15175 
      if ftype == TType.STOP:
15176 
        break
3064 chandransh 15177 
      if fid == 1:
15178 
        if ftype == TType.STRUCT:
15179 
          self.ex = TransactionServiceException()
15180 
          self.ex.read(iprot)
15181 
        else:
15182 
          iprot.skip(ftype)
1596 ankur.sing 15183 
      else:
15184 
        iprot.skip(ftype)
15185 
      iprot.readFieldEnd()
15186 
    iprot.readStructEnd()
15187 
 
15188 
  def write(self, oprot):
15189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15191 
      return
3064 chandransh 15192 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15193 
    if self.ex is not None:
3064 chandransh 15194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15195 
      self.ex.write(oprot)
15196 
      oprot.writeFieldEnd()
1596 ankur.sing 15197 
    oprot.writeFieldStop()
15198 
    oprot.writeStructEnd()
15199 
 
3431 rajveer 15200 
  def validate(self):
15201 
    return
15202 
 
15203 
 
1596 ankur.sing 15204 
  def __repr__(self):
15205 
    L = ['%s=%r' % (key, value)
15206 
      for key, value in self.__dict__.iteritems()]
15207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15208 
 
15209 
  def __eq__(self, other):
15210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15211 
 
15212 
  def __ne__(self, other):
15213 
    return not (self == other)
15214 
 
4910 phani.kuma 15215 
class markAsRTOrders_args:
1596 ankur.sing 15216 
  """
15217 
  Attributes:
3064 chandransh 15218 
   - providerId
15219 
   - returnedOrders
1596 ankur.sing 15220 
  """
15221 
 
15222 
  thrift_spec = (
3064 chandransh 15223 
    None, # 0
15224 
    (1, TType.I64, 'providerId', None, None, ), # 1
15225 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15226 
  )
15227 
 
3064 chandransh 15228 
  def __init__(self, providerId=None, returnedOrders=None,):
15229 
    self.providerId = providerId
15230 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15231 
 
15232 
  def read(self, iprot):
15233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15235 
      return
15236 
    iprot.readStructBegin()
15237 
    while True:
15238 
      (fname, ftype, fid) = iprot.readFieldBegin()
15239 
      if ftype == TType.STOP:
15240 
        break
3064 chandransh 15241 
      if fid == 1:
1596 ankur.sing 15242 
        if ftype == TType.I64:
3064 chandransh 15243 
          self.providerId = iprot.readI64();
1596 ankur.sing 15244 
        else:
15245 
          iprot.skip(ftype)
3064 chandransh 15246 
      elif fid == 2:
15247 
        if ftype == TType.MAP:
15248 
          self.returnedOrders = {}
6188 rajveer 15249 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15250 
          for _i331 in xrange(_size327):
15251 
            _key332 = iprot.readString();
15252 
            _val333 = iprot.readString();
15253 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15254 
          iprot.readMapEnd()
15255 
        else:
15256 
          iprot.skip(ftype)
1596 ankur.sing 15257 
      else:
15258 
        iprot.skip(ftype)
15259 
      iprot.readFieldEnd()
15260 
    iprot.readStructEnd()
15261 
 
15262 
  def write(self, oprot):
15263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15265 
      return
4910 phani.kuma 15266 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15267 
    if self.providerId is not None:
3064 chandransh 15268 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15269 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15270 
      oprot.writeFieldEnd()
3431 rajveer 15271 
    if self.returnedOrders is not None:
3064 chandransh 15272 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15273 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15274 
      for kiter334,viter335 in self.returnedOrders.items():
15275 
        oprot.writeString(kiter334)
15276 
        oprot.writeString(viter335)
3064 chandransh 15277 
      oprot.writeMapEnd()
15278 
      oprot.writeFieldEnd()
1596 ankur.sing 15279 
    oprot.writeFieldStop()
15280 
    oprot.writeStructEnd()
15281 
 
3431 rajveer 15282 
  def validate(self):
15283 
    return
15284 
 
15285 
 
1596 ankur.sing 15286 
  def __repr__(self):
15287 
    L = ['%s=%r' % (key, value)
15288 
      for key, value in self.__dict__.iteritems()]
15289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15290 
 
15291 
  def __eq__(self, other):
15292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15293 
 
15294 
  def __ne__(self, other):
15295 
    return not (self == other)
15296 
 
4910 phani.kuma 15297 
class markAsRTOrders_result:
3064 chandransh 15298 
  """
15299 
  Attributes:
15300 
   - ex
15301 
  """
1596 ankur.sing 15302 
 
1627 ankur.sing 15303 
  thrift_spec = (
3064 chandransh 15304 
    None, # 0
15305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15306 
  )
15307 
 
3064 chandransh 15308 
  def __init__(self, ex=None,):
15309 
    self.ex = ex
15310 
 
1627 ankur.sing 15311 
  def read(self, iprot):
15312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15314 
      return
15315 
    iprot.readStructBegin()
15316 
    while True:
15317 
      (fname, ftype, fid) = iprot.readFieldBegin()
15318 
      if ftype == TType.STOP:
15319 
        break
3064 chandransh 15320 
      if fid == 1:
15321 
        if ftype == TType.STRUCT:
15322 
          self.ex = TransactionServiceException()
15323 
          self.ex.read(iprot)
15324 
        else:
15325 
          iprot.skip(ftype)
1627 ankur.sing 15326 
      else:
15327 
        iprot.skip(ftype)
15328 
      iprot.readFieldEnd()
15329 
    iprot.readStructEnd()
15330 
 
15331 
  def write(self, oprot):
15332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15334 
      return
4910 phani.kuma 15335 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15336 
    if self.ex is not None:
3064 chandransh 15337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15338 
      self.ex.write(oprot)
15339 
      oprot.writeFieldEnd()
1627 ankur.sing 15340 
    oprot.writeFieldStop()
15341 
    oprot.writeStructEnd()
15342 
 
3431 rajveer 15343 
  def validate(self):
15344 
    return
15345 
 
15346 
 
1627 ankur.sing 15347 
  def __repr__(self):
15348 
    L = ['%s=%r' % (key, value)
15349 
      for key, value in self.__dict__.iteritems()]
15350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15351 
 
15352 
  def __eq__(self, other):
15353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15354 
 
15355 
  def __ne__(self, other):
15356 
    return not (self == other)
15357 
 
4910 phani.kuma 15358 
class getRTOrders_args:
15359 
  """
15360 
  Attributes:
15361 
   - providerId
15362 
  """
15363 
 
15364 
  thrift_spec = (
15365 
    None, # 0
15366 
    (1, TType.I64, 'providerId', None, None, ), # 1
15367 
  )
15368 
 
15369 
  def __init__(self, providerId=None,):
15370 
    self.providerId = providerId
15371 
 
15372 
  def read(self, iprot):
15373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15375 
      return
15376 
    iprot.readStructBegin()
15377 
    while True:
15378 
      (fname, ftype, fid) = iprot.readFieldBegin()
15379 
      if ftype == TType.STOP:
15380 
        break
15381 
      if fid == 1:
15382 
        if ftype == TType.I64:
15383 
          self.providerId = iprot.readI64();
15384 
        else:
15385 
          iprot.skip(ftype)
15386 
      else:
15387 
        iprot.skip(ftype)
15388 
      iprot.readFieldEnd()
15389 
    iprot.readStructEnd()
15390 
 
15391 
  def write(self, oprot):
15392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15394 
      return
15395 
    oprot.writeStructBegin('getRTOrders_args')
15396 
    if self.providerId is not None:
15397 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15398 
      oprot.writeI64(self.providerId)
15399 
      oprot.writeFieldEnd()
15400 
    oprot.writeFieldStop()
15401 
    oprot.writeStructEnd()
15402 
 
15403 
  def validate(self):
15404 
    return
15405 
 
15406 
 
15407 
  def __repr__(self):
15408 
    L = ['%s=%r' % (key, value)
15409 
      for key, value in self.__dict__.iteritems()]
15410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15411 
 
15412 
  def __eq__(self, other):
15413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15414 
 
15415 
  def __ne__(self, other):
15416 
    return not (self == other)
15417 
 
15418 
class getRTOrders_result:
15419 
  """
15420 
  Attributes:
15421 
   - success
15422 
  """
15423 
 
15424 
  thrift_spec = (
15425 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15426 
  )
15427 
 
15428 
  def __init__(self, success=None,):
15429 
    self.success = success
15430 
 
15431 
  def read(self, iprot):
15432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15434 
      return
15435 
    iprot.readStructBegin()
15436 
    while True:
15437 
      (fname, ftype, fid) = iprot.readFieldBegin()
15438 
      if ftype == TType.STOP:
15439 
        break
15440 
      if fid == 0:
15441 
        if ftype == TType.LIST:
15442 
          self.success = []
6188 rajveer 15443 
          (_etype339, _size336) = iprot.readListBegin()
15444 
          for _i340 in xrange(_size336):
15445 
            _elem341 = Order()
15446 
            _elem341.read(iprot)
15447 
            self.success.append(_elem341)
4910 phani.kuma 15448 
          iprot.readListEnd()
15449 
        else:
15450 
          iprot.skip(ftype)
15451 
      else:
15452 
        iprot.skip(ftype)
15453 
      iprot.readFieldEnd()
15454 
    iprot.readStructEnd()
15455 
 
15456 
  def write(self, oprot):
15457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15459 
      return
15460 
    oprot.writeStructBegin('getRTOrders_result')
15461 
    if self.success is not None:
15462 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15463 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15464 
      for iter342 in self.success:
15465 
        iter342.write(oprot)
4910 phani.kuma 15466 
      oprot.writeListEnd()
15467 
      oprot.writeFieldEnd()
15468 
    oprot.writeFieldStop()
15469 
    oprot.writeStructEnd()
15470 
 
15471 
  def validate(self):
15472 
    return
15473 
 
15474 
 
15475 
  def __repr__(self):
15476 
    L = ['%s=%r' % (key, value)
15477 
      for key, value in self.__dict__.iteritems()]
15478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15479 
 
15480 
  def __eq__(self, other):
15481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15482 
 
15483 
  def __ne__(self, other):
15484 
    return not (self == other)
15485 
 
3064 chandransh 15486 
class updateNonDeliveryReason_args:
1627 ankur.sing 15487 
  """
15488 
  Attributes:
3064 chandransh 15489 
   - providerId
15490 
   - undeliveredOrders
1627 ankur.sing 15491 
  """
15492 
 
15493 
  thrift_spec = (
3064 chandransh 15494 
    None, # 0
15495 
    (1, TType.I64, 'providerId', None, None, ), # 1
15496 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15497 
  )
15498 
 
3064 chandransh 15499 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15500 
    self.providerId = providerId
15501 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15502 
 
15503 
  def read(self, iprot):
15504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15506 
      return
15507 
    iprot.readStructBegin()
15508 
    while True:
15509 
      (fname, ftype, fid) = iprot.readFieldBegin()
15510 
      if ftype == TType.STOP:
15511 
        break
3064 chandransh 15512 
      if fid == 1:
1627 ankur.sing 15513 
        if ftype == TType.I64:
3064 chandransh 15514 
          self.providerId = iprot.readI64();
1627 ankur.sing 15515 
        else:
15516 
          iprot.skip(ftype)
3064 chandransh 15517 
      elif fid == 2:
15518 
        if ftype == TType.MAP:
15519 
          self.undeliveredOrders = {}
6188 rajveer 15520 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15521 
          for _i347 in xrange(_size343):
15522 
            _key348 = iprot.readString();
15523 
            _val349 = iprot.readString();
15524 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15525 
          iprot.readMapEnd()
15526 
        else:
15527 
          iprot.skip(ftype)
1627 ankur.sing 15528 
      else:
15529 
        iprot.skip(ftype)
15530 
      iprot.readFieldEnd()
15531 
    iprot.readStructEnd()
15532 
 
15533 
  def write(self, oprot):
15534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15536 
      return
3064 chandransh 15537 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15538 
    if self.providerId is not None:
3064 chandransh 15539 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15540 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15541 
      oprot.writeFieldEnd()
3431 rajveer 15542 
    if self.undeliveredOrders is not None:
3064 chandransh 15543 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15544 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15545 
      for kiter350,viter351 in self.undeliveredOrders.items():
15546 
        oprot.writeString(kiter350)
15547 
        oprot.writeString(viter351)
3064 chandransh 15548 
      oprot.writeMapEnd()
15549 
      oprot.writeFieldEnd()
1627 ankur.sing 15550 
    oprot.writeFieldStop()
15551 
    oprot.writeStructEnd()
15552 
 
3431 rajveer 15553 
  def validate(self):
15554 
    return
15555 
 
15556 
 
1627 ankur.sing 15557 
  def __repr__(self):
15558 
    L = ['%s=%r' % (key, value)
15559 
      for key, value in self.__dict__.iteritems()]
15560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15561 
 
15562 
  def __eq__(self, other):
15563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15564 
 
15565 
  def __ne__(self, other):
15566 
    return not (self == other)
15567 
 
3064 chandransh 15568 
class updateNonDeliveryReason_result:
1627 ankur.sing 15569 
  """
15570 
  Attributes:
3064 chandransh 15571 
   - ex
1627 ankur.sing 15572 
  """
15573 
 
15574 
  thrift_spec = (
4910 phani.kuma 15575 
    None, # 0
3064 chandransh 15576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15577 
  )
15578 
 
4910 phani.kuma 15579 
  def __init__(self, ex=None,):
3064 chandransh 15580 
    self.ex = ex
1627 ankur.sing 15581 
 
15582 
  def read(self, iprot):
15583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15585 
      return
15586 
    iprot.readStructBegin()
15587 
    while True:
15588 
      (fname, ftype, fid) = iprot.readFieldBegin()
15589 
      if ftype == TType.STOP:
15590 
        break
4910 phani.kuma 15591 
      if fid == 1:
15592 
        if ftype == TType.STRUCT:
15593 
          self.ex = TransactionServiceException()
15594 
          self.ex.read(iprot)
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15607 
    if self.ex is not None:
15608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15609 
      self.ex.write(oprot)
15610 
      oprot.writeFieldEnd()
15611 
    oprot.writeFieldStop()
15612 
    oprot.writeStructEnd()
15613 
 
15614 
  def validate(self):
15615 
    return
15616 
 
15617 
 
15618 
  def __repr__(self):
15619 
    L = ['%s=%r' % (key, value)
15620 
      for key, value in self.__dict__.iteritems()]
15621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15622 
 
15623 
  def __eq__(self, other):
15624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15625 
 
15626 
  def __ne__(self, other):
15627 
    return not (self == other)
15628 
 
15629 
class getNonDeliveredOrdersbyCourier_args:
15630 
  """
15631 
  Attributes:
15632 
   - providerId
15633 
  """
15634 
 
15635 
  thrift_spec = (
15636 
    None, # 0
15637 
    (1, TType.I64, 'providerId', None, None, ), # 1
15638 
  )
15639 
 
15640 
  def __init__(self, providerId=None,):
15641 
    self.providerId = providerId
15642 
 
15643 
  def read(self, iprot):
15644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15646 
      return
15647 
    iprot.readStructBegin()
15648 
    while True:
15649 
      (fname, ftype, fid) = iprot.readFieldBegin()
15650 
      if ftype == TType.STOP:
15651 
        break
15652 
      if fid == 1:
15653 
        if ftype == TType.I64:
15654 
          self.providerId = iprot.readI64();
15655 
        else:
15656 
          iprot.skip(ftype)
15657 
      else:
15658 
        iprot.skip(ftype)
15659 
      iprot.readFieldEnd()
15660 
    iprot.readStructEnd()
15661 
 
15662 
  def write(self, oprot):
15663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15665 
      return
15666 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15667 
    if self.providerId is not None:
15668 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15669 
      oprot.writeI64(self.providerId)
15670 
      oprot.writeFieldEnd()
15671 
    oprot.writeFieldStop()
15672 
    oprot.writeStructEnd()
15673 
 
15674 
  def validate(self):
15675 
    return
15676 
 
15677 
 
15678 
  def __repr__(self):
15679 
    L = ['%s=%r' % (key, value)
15680 
      for key, value in self.__dict__.iteritems()]
15681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15682 
 
15683 
  def __eq__(self, other):
15684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15685 
 
15686 
  def __ne__(self, other):
15687 
    return not (self == other)
15688 
 
15689 
class getNonDeliveredOrdersbyCourier_result:
15690 
  """
15691 
  Attributes:
15692 
   - success
15693 
  """
15694 
 
15695 
  thrift_spec = (
15696 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15697 
  )
15698 
 
15699 
  def __init__(self, success=None,):
15700 
    self.success = success
15701 
 
15702 
  def read(self, iprot):
15703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15705 
      return
15706 
    iprot.readStructBegin()
15707 
    while True:
15708 
      (fname, ftype, fid) = iprot.readFieldBegin()
15709 
      if ftype == TType.STOP:
15710 
        break
4581 phani.kuma 15711 
      if fid == 0:
15712 
        if ftype == TType.LIST:
15713 
          self.success = []
6188 rajveer 15714 
          (_etype355, _size352) = iprot.readListBegin()
15715 
          for _i356 in xrange(_size352):
15716 
            _elem357 = Order()
15717 
            _elem357.read(iprot)
15718 
            self.success.append(_elem357)
4581 phani.kuma 15719 
          iprot.readListEnd()
15720 
        else:
15721 
          iprot.skip(ftype)
4910 phani.kuma 15722 
      else:
15723 
        iprot.skip(ftype)
15724 
      iprot.readFieldEnd()
15725 
    iprot.readStructEnd()
15726 
 
15727 
  def write(self, oprot):
15728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15730 
      return
15731 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15732 
    if self.success is not None:
15733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15735 
      for iter358 in self.success:
15736 
        iter358.write(oprot)
4910 phani.kuma 15737 
      oprot.writeListEnd()
15738 
      oprot.writeFieldEnd()
15739 
    oprot.writeFieldStop()
15740 
    oprot.writeStructEnd()
15741 
 
15742 
  def validate(self):
15743 
    return
15744 
 
15745 
 
15746 
  def __repr__(self):
15747 
    L = ['%s=%r' % (key, value)
15748 
      for key, value in self.__dict__.iteritems()]
15749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15750 
 
15751 
  def __eq__(self, other):
15752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15753 
 
15754 
  def __ne__(self, other):
15755 
    return not (self == other)
15756 
 
15757 
class markOrdersAsLocalConnected_args:
15758 
  """
15759 
  Attributes:
15760 
   - providerId
15761 
   - local_connected_orders
15762 
  """
15763 
 
15764 
  thrift_spec = (
15765 
    None, # 0
15766 
    (1, TType.I64, 'providerId', None, None, ), # 1
15767 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15768 
  )
15769 
 
15770 
  def __init__(self, providerId=None, local_connected_orders=None,):
15771 
    self.providerId = providerId
15772 
    self.local_connected_orders = local_connected_orders
15773 
 
15774 
  def read(self, iprot):
15775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15777 
      return
15778 
    iprot.readStructBegin()
15779 
    while True:
15780 
      (fname, ftype, fid) = iprot.readFieldBegin()
15781 
      if ftype == TType.STOP:
15782 
        break
15783 
      if fid == 1:
15784 
        if ftype == TType.I64:
15785 
          self.providerId = iprot.readI64();
15786 
        else:
15787 
          iprot.skip(ftype)
15788 
      elif fid == 2:
15789 
        if ftype == TType.MAP:
15790 
          self.local_connected_orders = {}
6188 rajveer 15791 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15792 
          for _i363 in xrange(_size359):
15793 
            _key364 = iprot.readString();
15794 
            _val365 = iprot.readString();
15795 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15796 
          iprot.readMapEnd()
15797 
        else:
15798 
          iprot.skip(ftype)
15799 
      else:
15800 
        iprot.skip(ftype)
15801 
      iprot.readFieldEnd()
15802 
    iprot.readStructEnd()
15803 
 
15804 
  def write(self, oprot):
15805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15807 
      return
15808 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15809 
    if self.providerId is not None:
15810 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15811 
      oprot.writeI64(self.providerId)
15812 
      oprot.writeFieldEnd()
15813 
    if self.local_connected_orders is not None:
15814 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15815 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15816 
      for kiter366,viter367 in self.local_connected_orders.items():
15817 
        oprot.writeString(kiter366)
15818 
        oprot.writeString(viter367)
4910 phani.kuma 15819 
      oprot.writeMapEnd()
15820 
      oprot.writeFieldEnd()
15821 
    oprot.writeFieldStop()
15822 
    oprot.writeStructEnd()
15823 
 
15824 
  def validate(self):
15825 
    return
15826 
 
15827 
 
15828 
  def __repr__(self):
15829 
    L = ['%s=%r' % (key, value)
15830 
      for key, value in self.__dict__.iteritems()]
15831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15832 
 
15833 
  def __eq__(self, other):
15834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15835 
 
15836 
  def __ne__(self, other):
15837 
    return not (self == other)
15838 
 
15839 
class markOrdersAsLocalConnected_result:
15840 
  """
15841 
  Attributes:
15842 
   - ex
15843 
  """
15844 
 
15845 
  thrift_spec = (
15846 
    None, # 0
15847 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15848 
  )
15849 
 
15850 
  def __init__(self, ex=None,):
15851 
    self.ex = ex
15852 
 
15853 
  def read(self, iprot):
15854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15856 
      return
15857 
    iprot.readStructBegin()
15858 
    while True:
15859 
      (fname, ftype, fid) = iprot.readFieldBegin()
15860 
      if ftype == TType.STOP:
15861 
        break
15862 
      if fid == 1:
3064 chandransh 15863 
        if ftype == TType.STRUCT:
15864 
          self.ex = TransactionServiceException()
15865 
          self.ex.read(iprot)
1627 ankur.sing 15866 
        else:
15867 
          iprot.skip(ftype)
15868 
      else:
15869 
        iprot.skip(ftype)
15870 
      iprot.readFieldEnd()
15871 
    iprot.readStructEnd()
15872 
 
15873 
  def write(self, oprot):
15874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15876 
      return
4910 phani.kuma 15877 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15878 
    if self.ex is not None:
15879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15880 
      self.ex.write(oprot)
15881 
      oprot.writeFieldEnd()
15882 
    oprot.writeFieldStop()
15883 
    oprot.writeStructEnd()
15884 
 
15885 
  def validate(self):
15886 
    return
15887 
 
15888 
 
15889 
  def __repr__(self):
15890 
    L = ['%s=%r' % (key, value)
15891 
      for key, value in self.__dict__.iteritems()]
15892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15893 
 
15894 
  def __eq__(self, other):
15895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15896 
 
15897 
  def __ne__(self, other):
15898 
    return not (self == other)
15899 
 
15900 
class getOrdersNotLocalConnected_args:
15901 
  """
15902 
  Attributes:
15903 
   - providerId
15904 
  """
15905 
 
15906 
  thrift_spec = (
15907 
    None, # 0
15908 
    (1, TType.I64, 'providerId', None, None, ), # 1
15909 
  )
15910 
 
15911 
  def __init__(self, providerId=None,):
15912 
    self.providerId = providerId
15913 
 
15914 
  def read(self, iprot):
15915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15917 
      return
15918 
    iprot.readStructBegin()
15919 
    while True:
15920 
      (fname, ftype, fid) = iprot.readFieldBegin()
15921 
      if ftype == TType.STOP:
15922 
        break
15923 
      if fid == 1:
15924 
        if ftype == TType.I64:
15925 
          self.providerId = iprot.readI64();
15926 
        else:
15927 
          iprot.skip(ftype)
15928 
      else:
15929 
        iprot.skip(ftype)
15930 
      iprot.readFieldEnd()
15931 
    iprot.readStructEnd()
15932 
 
15933 
  def write(self, oprot):
15934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15936 
      return
15937 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15938 
    if self.providerId is not None:
15939 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15940 
      oprot.writeI64(self.providerId)
15941 
      oprot.writeFieldEnd()
15942 
    oprot.writeFieldStop()
15943 
    oprot.writeStructEnd()
15944 
 
15945 
  def validate(self):
15946 
    return
15947 
 
15948 
 
15949 
  def __repr__(self):
15950 
    L = ['%s=%r' % (key, value)
15951 
      for key, value in self.__dict__.iteritems()]
15952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15953 
 
15954 
  def __eq__(self, other):
15955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15956 
 
15957 
  def __ne__(self, other):
15958 
    return not (self == other)
15959 
 
15960 
class getOrdersNotLocalConnected_result:
15961 
  """
15962 
  Attributes:
15963 
   - success
15964 
  """
15965 
 
15966 
  thrift_spec = (
15967 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15968 
  )
15969 
 
15970 
  def __init__(self, success=None,):
15971 
    self.success = success
15972 
 
15973 
  def read(self, iprot):
15974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15976 
      return
15977 
    iprot.readStructBegin()
15978 
    while True:
15979 
      (fname, ftype, fid) = iprot.readFieldBegin()
15980 
      if ftype == TType.STOP:
15981 
        break
15982 
      if fid == 0:
15983 
        if ftype == TType.LIST:
15984 
          self.success = []
6188 rajveer 15985 
          (_etype371, _size368) = iprot.readListBegin()
15986 
          for _i372 in xrange(_size368):
15987 
            _elem373 = Order()
15988 
            _elem373.read(iprot)
15989 
            self.success.append(_elem373)
4910 phani.kuma 15990 
          iprot.readListEnd()
15991 
        else:
15992 
          iprot.skip(ftype)
15993 
      else:
15994 
        iprot.skip(ftype)
15995 
      iprot.readFieldEnd()
15996 
    iprot.readStructEnd()
15997 
 
15998 
  def write(self, oprot):
15999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16001 
      return
16002 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16003 
    if self.success is not None:
16004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16006 
      for iter374 in self.success:
16007 
        iter374.write(oprot)
4581 phani.kuma 16008 
      oprot.writeListEnd()
16009 
      oprot.writeFieldEnd()
4910 phani.kuma 16010 
    oprot.writeFieldStop()
16011 
    oprot.writeStructEnd()
16012 
 
16013 
  def validate(self):
16014 
    return
16015 
 
16016 
 
16017 
  def __repr__(self):
16018 
    L = ['%s=%r' % (key, value)
16019 
      for key, value in self.__dict__.iteritems()]
16020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16021 
 
16022 
  def __eq__(self, other):
16023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16024 
 
16025 
  def __ne__(self, other):
16026 
    return not (self == other)
16027 
 
16028 
class markOrdersAsDestinationCityReached_args:
16029 
  """
16030 
  Attributes:
16031 
   - providerId
16032 
   - destination_city_reached_orders
16033 
  """
16034 
 
16035 
  thrift_spec = (
16036 
    None, # 0
16037 
    (1, TType.I64, 'providerId', None, None, ), # 1
16038 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16039 
  )
16040 
 
16041 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16042 
    self.providerId = providerId
16043 
    self.destination_city_reached_orders = destination_city_reached_orders
16044 
 
16045 
  def read(self, iprot):
16046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16048 
      return
16049 
    iprot.readStructBegin()
16050 
    while True:
16051 
      (fname, ftype, fid) = iprot.readFieldBegin()
16052 
      if ftype == TType.STOP:
16053 
        break
16054 
      if fid == 1:
16055 
        if ftype == TType.I64:
16056 
          self.providerId = iprot.readI64();
16057 
        else:
16058 
          iprot.skip(ftype)
16059 
      elif fid == 2:
16060 
        if ftype == TType.MAP:
16061 
          self.destination_city_reached_orders = {}
6188 rajveer 16062 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16063 
          for _i379 in xrange(_size375):
16064 
            _key380 = iprot.readString();
16065 
            _val381 = iprot.readString();
16066 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16067 
          iprot.readMapEnd()
16068 
        else:
16069 
          iprot.skip(ftype)
16070 
      else:
16071 
        iprot.skip(ftype)
16072 
      iprot.readFieldEnd()
16073 
    iprot.readStructEnd()
16074 
 
16075 
  def write(self, oprot):
16076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16078 
      return
16079 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16080 
    if self.providerId is not None:
16081 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16082 
      oprot.writeI64(self.providerId)
16083 
      oprot.writeFieldEnd()
16084 
    if self.destination_city_reached_orders is not None:
16085 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16086 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16087 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16088 
        oprot.writeString(kiter382)
16089 
        oprot.writeString(viter383)
4910 phani.kuma 16090 
      oprot.writeMapEnd()
16091 
      oprot.writeFieldEnd()
16092 
    oprot.writeFieldStop()
16093 
    oprot.writeStructEnd()
16094 
 
16095 
  def validate(self):
16096 
    return
16097 
 
16098 
 
16099 
  def __repr__(self):
16100 
    L = ['%s=%r' % (key, value)
16101 
      for key, value in self.__dict__.iteritems()]
16102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16103 
 
16104 
  def __eq__(self, other):
16105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16106 
 
16107 
  def __ne__(self, other):
16108 
    return not (self == other)
16109 
 
16110 
class markOrdersAsDestinationCityReached_result:
16111 
  """
16112 
  Attributes:
16113 
   - ex
16114 
  """
16115 
 
16116 
  thrift_spec = (
16117 
    None, # 0
16118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16119 
  )
16120 
 
16121 
  def __init__(self, ex=None,):
16122 
    self.ex = ex
16123 
 
16124 
  def read(self, iprot):
16125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16127 
      return
16128 
    iprot.readStructBegin()
16129 
    while True:
16130 
      (fname, ftype, fid) = iprot.readFieldBegin()
16131 
      if ftype == TType.STOP:
16132 
        break
16133 
      if fid == 1:
16134 
        if ftype == TType.STRUCT:
16135 
          self.ex = TransactionServiceException()
16136 
          self.ex.read(iprot)
16137 
        else:
16138 
          iprot.skip(ftype)
16139 
      else:
16140 
        iprot.skip(ftype)
16141 
      iprot.readFieldEnd()
16142 
    iprot.readStructEnd()
16143 
 
16144 
  def write(self, oprot):
16145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16147 
      return
16148 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16149 
    if self.ex is not None:
3064 chandransh 16150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16151 
      self.ex.write(oprot)
1627 ankur.sing 16152 
      oprot.writeFieldEnd()
16153 
    oprot.writeFieldStop()
16154 
    oprot.writeStructEnd()
16155 
 
3431 rajveer 16156 
  def validate(self):
16157 
    return
16158 
 
16159 
 
1627 ankur.sing 16160 
  def __repr__(self):
16161 
    L = ['%s=%r' % (key, value)
16162 
      for key, value in self.__dict__.iteritems()]
16163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16164 
 
16165 
  def __eq__(self, other):
16166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16167 
 
16168 
  def __ne__(self, other):
16169 
    return not (self == other)
16170 
 
4910 phani.kuma 16171 
class markOrdersAsFirstDeliveryAttempted_args:
16172 
  """
16173 
  Attributes:
16174 
   - providerId
16175 
   - first_atdl_orders
16176 
  """
16177 
 
16178 
  thrift_spec = (
16179 
    None, # 0
16180 
    (1, TType.I64, 'providerId', None, None, ), # 1
16181 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16182 
  )
16183 
 
16184 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16185 
    self.providerId = providerId
16186 
    self.first_atdl_orders = first_atdl_orders
16187 
 
16188 
  def read(self, iprot):
16189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16191 
      return
16192 
    iprot.readStructBegin()
16193 
    while True:
16194 
      (fname, ftype, fid) = iprot.readFieldBegin()
16195 
      if ftype == TType.STOP:
16196 
        break
16197 
      if fid == 1:
16198 
        if ftype == TType.I64:
16199 
          self.providerId = iprot.readI64();
16200 
        else:
16201 
          iprot.skip(ftype)
16202 
      elif fid == 2:
16203 
        if ftype == TType.MAP:
16204 
          self.first_atdl_orders = {}
6188 rajveer 16205 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16206 
          for _i388 in xrange(_size384):
16207 
            _key389 = iprot.readString();
16208 
            _val390 = iprot.readString();
16209 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16210 
          iprot.readMapEnd()
16211 
        else:
16212 
          iprot.skip(ftype)
16213 
      else:
16214 
        iprot.skip(ftype)
16215 
      iprot.readFieldEnd()
16216 
    iprot.readStructEnd()
16217 
 
16218 
  def write(self, oprot):
16219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16221 
      return
16222 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16223 
    if self.providerId is not None:
16224 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16225 
      oprot.writeI64(self.providerId)
16226 
      oprot.writeFieldEnd()
16227 
    if self.first_atdl_orders is not None:
16228 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16229 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16230 
      for kiter391,viter392 in self.first_atdl_orders.items():
16231 
        oprot.writeString(kiter391)
16232 
        oprot.writeString(viter392)
4910 phani.kuma 16233 
      oprot.writeMapEnd()
16234 
      oprot.writeFieldEnd()
16235 
    oprot.writeFieldStop()
16236 
    oprot.writeStructEnd()
16237 
 
16238 
  def validate(self):
16239 
    return
16240 
 
16241 
 
16242 
  def __repr__(self):
16243 
    L = ['%s=%r' % (key, value)
16244 
      for key, value in self.__dict__.iteritems()]
16245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16246 
 
16247 
  def __eq__(self, other):
16248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16249 
 
16250 
  def __ne__(self, other):
16251 
    return not (self == other)
16252 
 
16253 
class markOrdersAsFirstDeliveryAttempted_result:
16254 
  """
16255 
  Attributes:
16256 
   - ex
16257 
  """
16258 
 
16259 
  thrift_spec = (
16260 
    None, # 0
16261 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16262 
  )
16263 
 
16264 
  def __init__(self, ex=None,):
16265 
    self.ex = ex
16266 
 
16267 
  def read(self, iprot):
16268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16270 
      return
16271 
    iprot.readStructBegin()
16272 
    while True:
16273 
      (fname, ftype, fid) = iprot.readFieldBegin()
16274 
      if ftype == TType.STOP:
16275 
        break
16276 
      if fid == 1:
16277 
        if ftype == TType.STRUCT:
16278 
          self.ex = TransactionServiceException()
16279 
          self.ex.read(iprot)
16280 
        else:
16281 
          iprot.skip(ftype)
16282 
      else:
16283 
        iprot.skip(ftype)
16284 
      iprot.readFieldEnd()
16285 
    iprot.readStructEnd()
16286 
 
16287 
  def write(self, oprot):
16288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16290 
      return
16291 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16292 
    if self.ex is not None:
16293 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16294 
      self.ex.write(oprot)
16295 
      oprot.writeFieldEnd()
16296 
    oprot.writeFieldStop()
16297 
    oprot.writeStructEnd()
16298 
 
16299 
  def validate(self):
16300 
    return
16301 
 
16302 
 
16303 
  def __repr__(self):
16304 
    L = ['%s=%r' % (key, value)
16305 
      for key, value in self.__dict__.iteritems()]
16306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16307 
 
16308 
  def __eq__(self, other):
16309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16310 
 
16311 
  def __ne__(self, other):
16312 
    return not (self == other)
16313 
 
3064 chandransh 16314 
class getUndeliveredOrders_args:
1886 ankur.sing 16315 
  """
16316 
  Attributes:
3064 chandransh 16317 
   - providerId
16318 
   - warehouseId
1886 ankur.sing 16319 
  """
1627 ankur.sing 16320 
 
1886 ankur.sing 16321 
  thrift_spec = (
16322 
    None, # 0
3064 chandransh 16323 
    (1, TType.I64, 'providerId', None, None, ), # 1
16324 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16325 
  )
16326 
 
3064 chandransh 16327 
  def __init__(self, providerId=None, warehouseId=None,):
16328 
    self.providerId = providerId
16329 
    self.warehouseId = warehouseId
1886 ankur.sing 16330 
 
16331 
  def read(self, iprot):
16332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16334 
      return
16335 
    iprot.readStructBegin()
16336 
    while True:
16337 
      (fname, ftype, fid) = iprot.readFieldBegin()
16338 
      if ftype == TType.STOP:
16339 
        break
16340 
      if fid == 1:
16341 
        if ftype == TType.I64:
3064 chandransh 16342 
          self.providerId = iprot.readI64();
1886 ankur.sing 16343 
        else:
16344 
          iprot.skip(ftype)
3064 chandransh 16345 
      elif fid == 2:
16346 
        if ftype == TType.I64:
16347 
          self.warehouseId = iprot.readI64();
16348 
        else:
16349 
          iprot.skip(ftype)
1886 ankur.sing 16350 
      else:
16351 
        iprot.skip(ftype)
16352 
      iprot.readFieldEnd()
16353 
    iprot.readStructEnd()
16354 
 
16355 
  def write(self, oprot):
16356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16358 
      return
3064 chandransh 16359 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16360 
    if self.providerId is not None:
3064 chandransh 16361 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16362 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16363 
      oprot.writeFieldEnd()
3431 rajveer 16364 
    if self.warehouseId is not None:
3064 chandransh 16365 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16366 
      oprot.writeI64(self.warehouseId)
16367 
      oprot.writeFieldEnd()
1886 ankur.sing 16368 
    oprot.writeFieldStop()
16369 
    oprot.writeStructEnd()
16370 
 
3431 rajveer 16371 
  def validate(self):
16372 
    return
16373 
 
16374 
 
1886 ankur.sing 16375 
  def __repr__(self):
16376 
    L = ['%s=%r' % (key, value)
16377 
      for key, value in self.__dict__.iteritems()]
16378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16379 
 
16380 
  def __eq__(self, other):
16381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16382 
 
16383 
  def __ne__(self, other):
16384 
    return not (self == other)
16385 
 
3064 chandransh 16386 
class getUndeliveredOrders_result:
1886 ankur.sing 16387 
  """
16388 
  Attributes:
16389 
   - success
16390 
  """
16391 
 
16392 
  thrift_spec = (
16393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16394 
  )
16395 
 
16396 
  def __init__(self, success=None,):
16397 
    self.success = success
16398 
 
16399 
  def read(self, iprot):
16400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16402 
      return
16403 
    iprot.readStructBegin()
16404 
    while True:
16405 
      (fname, ftype, fid) = iprot.readFieldBegin()
16406 
      if ftype == TType.STOP:
16407 
        break
16408 
      if fid == 0:
16409 
        if ftype == TType.LIST:
16410 
          self.success = []
6188 rajveer 16411 
          (_etype396, _size393) = iprot.readListBegin()
16412 
          for _i397 in xrange(_size393):
16413 
            _elem398 = Order()
16414 
            _elem398.read(iprot)
16415 
            self.success.append(_elem398)
1886 ankur.sing 16416 
          iprot.readListEnd()
16417 
        else:
16418 
          iprot.skip(ftype)
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
3064 chandransh 16428 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16429 
    if self.success is not None:
1886 ankur.sing 16430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16432 
      for iter399 in self.success:
16433 
        iter399.write(oprot)
1886 ankur.sing 16434 
      oprot.writeListEnd()
16435 
      oprot.writeFieldEnd()
16436 
    oprot.writeFieldStop()
16437 
    oprot.writeStructEnd()
16438 
 
3431 rajveer 16439 
  def validate(self):
16440 
    return
16441 
 
16442 
 
1886 ankur.sing 16443 
  def __repr__(self):
16444 
    L = ['%s=%r' % (key, value)
16445 
      for key, value in self.__dict__.iteritems()]
16446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16447 
 
16448 
  def __eq__(self, other):
16449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16450 
 
16451 
  def __ne__(self, other):
16452 
    return not (self == other)
16453 
 
4783 phani.kuma 16454 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16455 
 
16456 
  thrift_spec = (
16457 
  )
16458 
 
16459 
  def read(self, iprot):
16460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16462 
      return
16463 
    iprot.readStructBegin()
16464 
    while True:
16465 
      (fname, ftype, fid) = iprot.readFieldBegin()
16466 
      if ftype == TType.STOP:
16467 
        break
16468 
      else:
16469 
        iprot.skip(ftype)
16470 
      iprot.readFieldEnd()
16471 
    iprot.readStructEnd()
16472 
 
16473 
  def write(self, oprot):
16474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16476 
      return
16477 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16478 
    oprot.writeFieldStop()
16479 
    oprot.writeStructEnd()
16480 
 
16481 
  def validate(self):
16482 
    return
16483 
 
16484 
 
16485 
  def __repr__(self):
16486 
    L = ['%s=%r' % (key, value)
16487 
      for key, value in self.__dict__.iteritems()]
16488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16489 
 
16490 
  def __eq__(self, other):
16491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16492 
 
16493 
  def __ne__(self, other):
16494 
    return not (self == other)
16495 
 
16496 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16497 
  """
16498 
  Attributes:
16499 
   - success
16500 
  """
16501 
 
16502 
  thrift_spec = (
16503 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16504 
  )
16505 
 
16506 
  def __init__(self, success=None,):
16507 
    self.success = success
16508 
 
16509 
  def read(self, iprot):
16510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16512 
      return
16513 
    iprot.readStructBegin()
16514 
    while True:
16515 
      (fname, ftype, fid) = iprot.readFieldBegin()
16516 
      if ftype == TType.STOP:
16517 
        break
16518 
      if fid == 0:
16519 
        if ftype == TType.LIST:
16520 
          self.success = []
6188 rajveer 16521 
          (_etype403, _size400) = iprot.readListBegin()
16522 
          for _i404 in xrange(_size400):
16523 
            _elem405 = Order()
16524 
            _elem405.read(iprot)
16525 
            self.success.append(_elem405)
4783 phani.kuma 16526 
          iprot.readListEnd()
16527 
        else:
16528 
          iprot.skip(ftype)
16529 
      else:
16530 
        iprot.skip(ftype)
16531 
      iprot.readFieldEnd()
16532 
    iprot.readStructEnd()
16533 
 
16534 
  def write(self, oprot):
16535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16537 
      return
16538 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16539 
    if self.success is not None:
16540 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16541 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16542 
      for iter406 in self.success:
16543 
        iter406.write(oprot)
4783 phani.kuma 16544 
      oprot.writeListEnd()
16545 
      oprot.writeFieldEnd()
16546 
    oprot.writeFieldStop()
16547 
    oprot.writeStructEnd()
16548 
 
16549 
  def validate(self):
16550 
    return
16551 
 
16552 
 
16553 
  def __repr__(self):
16554 
    L = ['%s=%r' % (key, value)
16555 
      for key, value in self.__dict__.iteritems()]
16556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16557 
 
16558 
  def __eq__(self, other):
16559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16560 
 
16561 
  def __ne__(self, other):
16562 
    return not (self == other)
16563 
 
2536 chandransh 16564 
class toggleDOAFlag_args:
16565 
  """
16566 
  Attributes:
16567 
   - orderId
16568 
  """
1886 ankur.sing 16569 
 
2536 chandransh 16570 
  thrift_spec = (
16571 
    None, # 0
16572 
    (1, TType.I64, 'orderId', None, None, ), # 1
16573 
  )
16574 
 
16575 
  def __init__(self, orderId=None,):
16576 
    self.orderId = orderId
16577 
 
16578 
  def read(self, iprot):
16579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16581 
      return
16582 
    iprot.readStructBegin()
16583 
    while True:
16584 
      (fname, ftype, fid) = iprot.readFieldBegin()
16585 
      if ftype == TType.STOP:
16586 
        break
16587 
      if fid == 1:
16588 
        if ftype == TType.I64:
16589 
          self.orderId = iprot.readI64();
16590 
        else:
16591 
          iprot.skip(ftype)
16592 
      else:
16593 
        iprot.skip(ftype)
16594 
      iprot.readFieldEnd()
16595 
    iprot.readStructEnd()
16596 
 
16597 
  def write(self, oprot):
16598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16600 
      return
16601 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16602 
    if self.orderId is not None:
2536 chandransh 16603 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16604 
      oprot.writeI64(self.orderId)
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
3431 rajveer 16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
2536 chandransh 16613 
  def __repr__(self):
16614 
    L = ['%s=%r' % (key, value)
16615 
      for key, value in self.__dict__.iteritems()]
16616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16617 
 
16618 
  def __eq__(self, other):
16619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16620 
 
16621 
  def __ne__(self, other):
16622 
    return not (self == other)
16623 
 
16624 
class toggleDOAFlag_result:
16625 
  """
16626 
  Attributes:
16627 
   - success
16628 
   - ex
16629 
  """
16630 
 
16631 
  thrift_spec = (
16632 
    (0, TType.BOOL, 'success', None, None, ), # 0
16633 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16634 
  )
16635 
 
16636 
  def __init__(self, success=None, ex=None,):
16637 
    self.success = success
16638 
    self.ex = ex
16639 
 
16640 
  def read(self, iprot):
16641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16643 
      return
16644 
    iprot.readStructBegin()
16645 
    while True:
16646 
      (fname, ftype, fid) = iprot.readFieldBegin()
16647 
      if ftype == TType.STOP:
16648 
        break
16649 
      if fid == 0:
16650 
        if ftype == TType.BOOL:
16651 
          self.success = iprot.readBool();
16652 
        else:
16653 
          iprot.skip(ftype)
16654 
      elif fid == 1:
16655 
        if ftype == TType.STRUCT:
16656 
          self.ex = TransactionServiceException()
16657 
          self.ex.read(iprot)
16658 
        else:
16659 
          iprot.skip(ftype)
16660 
      else:
16661 
        iprot.skip(ftype)
16662 
      iprot.readFieldEnd()
16663 
    iprot.readStructEnd()
16664 
 
16665 
  def write(self, oprot):
16666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16668 
      return
16669 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16670 
    if self.success is not None:
2536 chandransh 16671 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16672 
      oprot.writeBool(self.success)
16673 
      oprot.writeFieldEnd()
3431 rajveer 16674 
    if self.ex is not None:
2536 chandransh 16675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16676 
      self.ex.write(oprot)
16677 
      oprot.writeFieldEnd()
16678 
    oprot.writeFieldStop()
16679 
    oprot.writeStructEnd()
16680 
 
3431 rajveer 16681 
  def validate(self):
16682 
    return
16683 
 
16684 
 
2536 chandransh 16685 
  def __repr__(self):
16686 
    L = ['%s=%r' % (key, value)
16687 
      for key, value in self.__dict__.iteritems()]
16688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16689 
 
16690 
  def __eq__(self, other):
16691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16692 
 
16693 
  def __ne__(self, other):
16694 
    return not (self == other)
16695 
 
4712 rajveer 16696 
class markOrderAsDelivered_args:
16697 
  """
16698 
  Attributes:
16699 
   - orderId
16700 
   - deliveryTimestamp
16701 
   - receiver
16702 
  """
16703 
 
16704 
  thrift_spec = None
16705 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16706 
    self.orderId = orderId
16707 
    self.deliveryTimestamp = deliveryTimestamp
16708 
    self.receiver = receiver
16709 
 
16710 
  def read(self, iprot):
16711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16713 
      return
16714 
    iprot.readStructBegin()
16715 
    while True:
16716 
      (fname, ftype, fid) = iprot.readFieldBegin()
16717 
      if ftype == TType.STOP:
16718 
        break
16719 
      if fid == 1:
16720 
        if ftype == TType.I64:
16721 
          self.orderId = iprot.readI64();
16722 
        else:
16723 
          iprot.skip(ftype)
16724 
      elif fid == 2:
16725 
        if ftype == TType.I64:
16726 
          self.deliveryTimestamp = iprot.readI64();
16727 
        else:
16728 
          iprot.skip(ftype)
16729 
      elif fid == -1:
16730 
        if ftype == TType.STRING:
16731 
          self.receiver = iprot.readString();
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      else:
16735 
        iprot.skip(ftype)
16736 
      iprot.readFieldEnd()
16737 
    iprot.readStructEnd()
16738 
 
16739 
  def write(self, oprot):
16740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16742 
      return
16743 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16744 
    if self.receiver is not None:
16745 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16746 
      oprot.writeString(self.receiver)
16747 
      oprot.writeFieldEnd()
16748 
    if self.orderId is not None:
16749 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16750 
      oprot.writeI64(self.orderId)
16751 
      oprot.writeFieldEnd()
16752 
    if self.deliveryTimestamp is not None:
16753 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16754 
      oprot.writeI64(self.deliveryTimestamp)
16755 
      oprot.writeFieldEnd()
16756 
    oprot.writeFieldStop()
16757 
    oprot.writeStructEnd()
16758 
 
16759 
  def validate(self):
16760 
    return
16761 
 
16762 
 
16763 
  def __repr__(self):
16764 
    L = ['%s=%r' % (key, value)
16765 
      for key, value in self.__dict__.iteritems()]
16766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16767 
 
16768 
  def __eq__(self, other):
16769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16770 
 
16771 
  def __ne__(self, other):
16772 
    return not (self == other)
16773 
 
16774 
class markOrderAsDelivered_result:
16775 
  """
16776 
  Attributes:
16777 
   - ex
16778 
  """
16779 
 
16780 
  thrift_spec = (
16781 
    None, # 0
16782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16783 
  )
16784 
 
16785 
  def __init__(self, ex=None,):
16786 
    self.ex = ex
16787 
 
16788 
  def read(self, iprot):
16789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16791 
      return
16792 
    iprot.readStructBegin()
16793 
    while True:
16794 
      (fname, ftype, fid) = iprot.readFieldBegin()
16795 
      if ftype == TType.STOP:
16796 
        break
16797 
      if fid == 1:
16798 
        if ftype == TType.STRUCT:
16799 
          self.ex = TransactionServiceException()
16800 
          self.ex.read(iprot)
16801 
        else:
16802 
          iprot.skip(ftype)
16803 
      else:
16804 
        iprot.skip(ftype)
16805 
      iprot.readFieldEnd()
16806 
    iprot.readStructEnd()
16807 
 
16808 
  def write(self, oprot):
16809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16811 
      return
16812 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16813 
    if self.ex is not None:
16814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16815 
      self.ex.write(oprot)
16816 
      oprot.writeFieldEnd()
16817 
    oprot.writeFieldStop()
16818 
    oprot.writeStructEnd()
16819 
 
16820 
  def validate(self):
16821 
    return
16822 
 
16823 
 
16824 
  def __repr__(self):
16825 
    L = ['%s=%r' % (key, value)
16826 
      for key, value in self.__dict__.iteritems()]
16827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16828 
 
16829 
  def __eq__(self, other):
16830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16831 
 
16832 
  def __ne__(self, other):
16833 
    return not (self == other)
16834 
 
5553 rajveer 16835 
class markOrderAsReceivedAtStore_args:
16836 
  """
16837 
  Attributes:
16838 
   - orderId
16839 
   - deliveryTimestamp
16840 
  """
16841 
 
16842 
  thrift_spec = (
16843 
    None, # 0
16844 
    (1, TType.I64, 'orderId', None, None, ), # 1
16845 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16846 
  )
16847 
 
16848 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16849 
    self.orderId = orderId
16850 
    self.deliveryTimestamp = deliveryTimestamp
16851 
 
16852 
  def read(self, iprot):
16853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16855 
      return
16856 
    iprot.readStructBegin()
16857 
    while True:
16858 
      (fname, ftype, fid) = iprot.readFieldBegin()
16859 
      if ftype == TType.STOP:
16860 
        break
16861 
      if fid == 1:
16862 
        if ftype == TType.I64:
16863 
          self.orderId = iprot.readI64();
16864 
        else:
16865 
          iprot.skip(ftype)
16866 
      elif fid == 2:
16867 
        if ftype == TType.I64:
16868 
          self.deliveryTimestamp = iprot.readI64();
16869 
        else:
16870 
          iprot.skip(ftype)
16871 
      else:
16872 
        iprot.skip(ftype)
16873 
      iprot.readFieldEnd()
16874 
    iprot.readStructEnd()
16875 
 
16876 
  def write(self, oprot):
16877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16879 
      return
16880 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16881 
    if self.orderId is not None:
16882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16883 
      oprot.writeI64(self.orderId)
16884 
      oprot.writeFieldEnd()
16885 
    if self.deliveryTimestamp is not None:
16886 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16887 
      oprot.writeI64(self.deliveryTimestamp)
16888 
      oprot.writeFieldEnd()
16889 
    oprot.writeFieldStop()
16890 
    oprot.writeStructEnd()
16891 
 
16892 
  def validate(self):
16893 
    return
16894 
 
16895 
 
16896 
  def __repr__(self):
16897 
    L = ['%s=%r' % (key, value)
16898 
      for key, value in self.__dict__.iteritems()]
16899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16900 
 
16901 
  def __eq__(self, other):
16902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16903 
 
16904 
  def __ne__(self, other):
16905 
    return not (self == other)
16906 
 
16907 
class markOrderAsReceivedAtStore_result:
16908 
  """
16909 
  Attributes:
16910 
   - ex
16911 
  """
16912 
 
16913 
  thrift_spec = (
16914 
    None, # 0
16915 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16916 
  )
16917 
 
16918 
  def __init__(self, ex=None,):
16919 
    self.ex = ex
16920 
 
16921 
  def read(self, iprot):
16922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16924 
      return
16925 
    iprot.readStructBegin()
16926 
    while True:
16927 
      (fname, ftype, fid) = iprot.readFieldBegin()
16928 
      if ftype == TType.STOP:
16929 
        break
16930 
      if fid == 1:
16931 
        if ftype == TType.STRUCT:
16932 
          self.ex = TransactionServiceException()
16933 
          self.ex.read(iprot)
16934 
        else:
16935 
          iprot.skip(ftype)
16936 
      else:
16937 
        iprot.skip(ftype)
16938 
      iprot.readFieldEnd()
16939 
    iprot.readStructEnd()
16940 
 
16941 
  def write(self, oprot):
16942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16944 
      return
16945 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16946 
    if self.ex is not None:
16947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16948 
      self.ex.write(oprot)
16949 
      oprot.writeFieldEnd()
16950 
    oprot.writeFieldStop()
16951 
    oprot.writeStructEnd()
16952 
 
16953 
  def validate(self):
16954 
    return
16955 
 
16956 
 
16957 
  def __repr__(self):
16958 
    L = ['%s=%r' % (key, value)
16959 
      for key, value in self.__dict__.iteritems()]
16960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16961 
 
16962 
  def __eq__(self, other):
16963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16964 
 
16965 
  def __ne__(self, other):
16966 
    return not (self == other)
16967 
 
4454 rajveer 16968 
class markOrderDoaRequestReceived_args:
16969 
  """
16970 
  Attributes:
16971 
   - orderId
16972 
  """
16973 
 
16974 
  thrift_spec = (
16975 
    None, # 0
16976 
    (1, TType.I64, 'orderId', None, None, ), # 1
16977 
  )
16978 
 
16979 
  def __init__(self, orderId=None,):
16980 
    self.orderId = orderId
16981 
 
16982 
  def read(self, iprot):
16983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16985 
      return
16986 
    iprot.readStructBegin()
16987 
    while True:
16988 
      (fname, ftype, fid) = iprot.readFieldBegin()
16989 
      if ftype == TType.STOP:
16990 
        break
16991 
      if fid == 1:
16992 
        if ftype == TType.I64:
16993 
          self.orderId = iprot.readI64();
16994 
        else:
16995 
          iprot.skip(ftype)
16996 
      else:
16997 
        iprot.skip(ftype)
16998 
      iprot.readFieldEnd()
16999 
    iprot.readStructEnd()
17000 
 
17001 
  def write(self, oprot):
17002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17004 
      return
17005 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17006 
    if self.orderId is not None:
17007 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17008 
      oprot.writeI64(self.orderId)
17009 
      oprot.writeFieldEnd()
17010 
    oprot.writeFieldStop()
17011 
    oprot.writeStructEnd()
17012 
 
17013 
  def validate(self):
17014 
    return
17015 
 
17016 
 
17017 
  def __repr__(self):
17018 
    L = ['%s=%r' % (key, value)
17019 
      for key, value in self.__dict__.iteritems()]
17020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17021 
 
17022 
  def __eq__(self, other):
17023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17024 
 
17025 
  def __ne__(self, other):
17026 
    return not (self == other)
17027 
 
17028 
class markOrderDoaRequestReceived_result:
17029 
  """
17030 
  Attributes:
17031 
   - success
17032 
   - ex
17033 
  """
17034 
 
17035 
  thrift_spec = (
17036 
    (0, TType.BOOL, 'success', None, None, ), # 0
17037 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17038 
  )
17039 
 
17040 
  def __init__(self, success=None, ex=None,):
17041 
    self.success = success
17042 
    self.ex = ex
17043 
 
17044 
  def read(self, iprot):
17045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17047 
      return
17048 
    iprot.readStructBegin()
17049 
    while True:
17050 
      (fname, ftype, fid) = iprot.readFieldBegin()
17051 
      if ftype == TType.STOP:
17052 
        break
17053 
      if fid == 0:
17054 
        if ftype == TType.BOOL:
17055 
          self.success = iprot.readBool();
17056 
        else:
17057 
          iprot.skip(ftype)
17058 
      elif fid == 1:
17059 
        if ftype == TType.STRUCT:
17060 
          self.ex = TransactionServiceException()
17061 
          self.ex.read(iprot)
17062 
        else:
17063 
          iprot.skip(ftype)
17064 
      else:
17065 
        iprot.skip(ftype)
17066 
      iprot.readFieldEnd()
17067 
    iprot.readStructEnd()
17068 
 
17069 
  def write(self, oprot):
17070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17072 
      return
17073 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17074 
    if self.success is not None:
17075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17076 
      oprot.writeBool(self.success)
17077 
      oprot.writeFieldEnd()
17078 
    if self.ex is not None:
17079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17080 
      self.ex.write(oprot)
17081 
      oprot.writeFieldEnd()
17082 
    oprot.writeFieldStop()
17083 
    oprot.writeStructEnd()
17084 
 
17085 
  def validate(self):
17086 
    return
17087 
 
17088 
 
17089 
  def __repr__(self):
17090 
    L = ['%s=%r' % (key, value)
17091 
      for key, value in self.__dict__.iteritems()]
17092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17093 
 
17094 
  def __eq__(self, other):
17095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17096 
 
17097 
  def __ne__(self, other):
17098 
    return not (self == other)
17099 
 
17100 
class markOrderDoaRequestAuthorized_args:
17101 
  """
17102 
  Attributes:
17103 
   - orderId
17104 
   - isAuthorized
17105 
  """
17106 
 
17107 
  thrift_spec = (
17108 
    None, # 0
17109 
    (1, TType.I64, 'orderId', None, None, ), # 1
17110 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17111 
  )
17112 
 
17113 
  def __init__(self, orderId=None, isAuthorized=None,):
17114 
    self.orderId = orderId
17115 
    self.isAuthorized = isAuthorized
17116 
 
17117 
  def read(self, iprot):
17118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17120 
      return
17121 
    iprot.readStructBegin()
17122 
    while True:
17123 
      (fname, ftype, fid) = iprot.readFieldBegin()
17124 
      if ftype == TType.STOP:
17125 
        break
17126 
      if fid == 1:
17127 
        if ftype == TType.I64:
17128 
          self.orderId = iprot.readI64();
17129 
        else:
17130 
          iprot.skip(ftype)
17131 
      elif fid == 2:
17132 
        if ftype == TType.BOOL:
17133 
          self.isAuthorized = iprot.readBool();
17134 
        else:
17135 
          iprot.skip(ftype)
17136 
      else:
17137 
        iprot.skip(ftype)
17138 
      iprot.readFieldEnd()
17139 
    iprot.readStructEnd()
17140 
 
17141 
  def write(self, oprot):
17142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17144 
      return
17145 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17146 
    if self.orderId is not None:
17147 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17148 
      oprot.writeI64(self.orderId)
17149 
      oprot.writeFieldEnd()
17150 
    if self.isAuthorized is not None:
17151 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17152 
      oprot.writeBool(self.isAuthorized)
17153 
      oprot.writeFieldEnd()
17154 
    oprot.writeFieldStop()
17155 
    oprot.writeStructEnd()
17156 
 
17157 
  def validate(self):
17158 
    return
17159 
 
17160 
 
17161 
  def __repr__(self):
17162 
    L = ['%s=%r' % (key, value)
17163 
      for key, value in self.__dict__.iteritems()]
17164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17165 
 
17166 
  def __eq__(self, other):
17167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17168 
 
17169 
  def __ne__(self, other):
17170 
    return not (self == other)
17171 
 
17172 
class markOrderDoaRequestAuthorized_result:
17173 
  """
17174 
  Attributes:
17175 
   - success
17176 
   - ex
17177 
  """
17178 
 
17179 
  thrift_spec = (
17180 
    (0, TType.BOOL, 'success', None, None, ), # 0
17181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17182 
  )
17183 
 
17184 
  def __init__(self, success=None, ex=None,):
17185 
    self.success = success
17186 
    self.ex = ex
17187 
 
17188 
  def read(self, iprot):
17189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17191 
      return
17192 
    iprot.readStructBegin()
17193 
    while True:
17194 
      (fname, ftype, fid) = iprot.readFieldBegin()
17195 
      if ftype == TType.STOP:
17196 
        break
17197 
      if fid == 0:
17198 
        if ftype == TType.BOOL:
17199 
          self.success = iprot.readBool();
17200 
        else:
17201 
          iprot.skip(ftype)
17202 
      elif fid == 1:
17203 
        if ftype == TType.STRUCT:
17204 
          self.ex = TransactionServiceException()
17205 
          self.ex.read(iprot)
17206 
        else:
17207 
          iprot.skip(ftype)
17208 
      else:
17209 
        iprot.skip(ftype)
17210 
      iprot.readFieldEnd()
17211 
    iprot.readStructEnd()
17212 
 
17213 
  def write(self, oprot):
17214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17216 
      return
17217 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17218 
    if self.success is not None:
17219 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17220 
      oprot.writeBool(self.success)
17221 
      oprot.writeFieldEnd()
17222 
    if self.ex is not None:
17223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17224 
      self.ex.write(oprot)
17225 
      oprot.writeFieldEnd()
17226 
    oprot.writeFieldStop()
17227 
    oprot.writeStructEnd()
17228 
 
17229 
  def validate(self):
17230 
    return
17231 
 
17232 
 
17233 
  def __repr__(self):
17234 
    L = ['%s=%r' % (key, value)
17235 
      for key, value in self.__dict__.iteritems()]
17236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17237 
 
17238 
  def __eq__(self, other):
17239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17240 
 
17241 
  def __ne__(self, other):
17242 
    return not (self == other)
17243 
 
4488 rajveer 17244 
class markOrderReturnRequestReceived_args:
17245 
  """
17246 
  Attributes:
17247 
   - orderId
17248 
  """
17249 
 
17250 
  thrift_spec = (
17251 
    None, # 0
17252 
    (1, TType.I64, 'orderId', None, None, ), # 1
17253 
  )
17254 
 
17255 
  def __init__(self, orderId=None,):
17256 
    self.orderId = orderId
17257 
 
17258 
  def read(self, iprot):
17259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17261 
      return
17262 
    iprot.readStructBegin()
17263 
    while True:
17264 
      (fname, ftype, fid) = iprot.readFieldBegin()
17265 
      if ftype == TType.STOP:
17266 
        break
17267 
      if fid == 1:
17268 
        if ftype == TType.I64:
17269 
          self.orderId = iprot.readI64();
17270 
        else:
17271 
          iprot.skip(ftype)
17272 
      else:
17273 
        iprot.skip(ftype)
17274 
      iprot.readFieldEnd()
17275 
    iprot.readStructEnd()
17276 
 
17277 
  def write(self, oprot):
17278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17280 
      return
17281 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17282 
    if self.orderId is not None:
17283 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17284 
      oprot.writeI64(self.orderId)
17285 
      oprot.writeFieldEnd()
17286 
    oprot.writeFieldStop()
17287 
    oprot.writeStructEnd()
17288 
 
17289 
  def validate(self):
17290 
    return
17291 
 
17292 
 
17293 
  def __repr__(self):
17294 
    L = ['%s=%r' % (key, value)
17295 
      for key, value in self.__dict__.iteritems()]
17296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17297 
 
17298 
  def __eq__(self, other):
17299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17300 
 
17301 
  def __ne__(self, other):
17302 
    return not (self == other)
17303 
 
17304 
class markOrderReturnRequestReceived_result:
17305 
  """
17306 
  Attributes:
17307 
   - success
17308 
   - ex
17309 
  """
17310 
 
17311 
  thrift_spec = (
17312 
    (0, TType.BOOL, 'success', None, None, ), # 0
17313 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17314 
  )
17315 
 
17316 
  def __init__(self, success=None, ex=None,):
17317 
    self.success = success
17318 
    self.ex = ex
17319 
 
17320 
  def read(self, iprot):
17321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17323 
      return
17324 
    iprot.readStructBegin()
17325 
    while True:
17326 
      (fname, ftype, fid) = iprot.readFieldBegin()
17327 
      if ftype == TType.STOP:
17328 
        break
17329 
      if fid == 0:
17330 
        if ftype == TType.BOOL:
17331 
          self.success = iprot.readBool();
17332 
        else:
17333 
          iprot.skip(ftype)
17334 
      elif fid == 1:
17335 
        if ftype == TType.STRUCT:
17336 
          self.ex = TransactionServiceException()
17337 
          self.ex.read(iprot)
17338 
        else:
17339 
          iprot.skip(ftype)
17340 
      else:
17341 
        iprot.skip(ftype)
17342 
      iprot.readFieldEnd()
17343 
    iprot.readStructEnd()
17344 
 
17345 
  def write(self, oprot):
17346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17348 
      return
17349 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17350 
    if self.success is not None:
17351 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17352 
      oprot.writeBool(self.success)
17353 
      oprot.writeFieldEnd()
17354 
    if self.ex is not None:
17355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17356 
      self.ex.write(oprot)
17357 
      oprot.writeFieldEnd()
17358 
    oprot.writeFieldStop()
17359 
    oprot.writeStructEnd()
17360 
 
17361 
  def validate(self):
17362 
    return
17363 
 
17364 
 
17365 
  def __repr__(self):
17366 
    L = ['%s=%r' % (key, value)
17367 
      for key, value in self.__dict__.iteritems()]
17368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17369 
 
17370 
  def __eq__(self, other):
17371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17372 
 
17373 
  def __ne__(self, other):
17374 
    return not (self == other)
17375 
 
17376 
class markOrderReturnRequestAuthorized_args:
17377 
  """
17378 
  Attributes:
17379 
   - orderId
17380 
   - isAuthorized
17381 
  """
17382 
 
17383 
  thrift_spec = (
17384 
    None, # 0
17385 
    (1, TType.I64, 'orderId', None, None, ), # 1
17386 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17387 
  )
17388 
 
17389 
  def __init__(self, orderId=None, isAuthorized=None,):
17390 
    self.orderId = orderId
17391 
    self.isAuthorized = isAuthorized
17392 
 
17393 
  def read(self, iprot):
17394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17396 
      return
17397 
    iprot.readStructBegin()
17398 
    while True:
17399 
      (fname, ftype, fid) = iprot.readFieldBegin()
17400 
      if ftype == TType.STOP:
17401 
        break
17402 
      if fid == 1:
17403 
        if ftype == TType.I64:
17404 
          self.orderId = iprot.readI64();
17405 
        else:
17406 
          iprot.skip(ftype)
17407 
      elif fid == 2:
17408 
        if ftype == TType.BOOL:
17409 
          self.isAuthorized = iprot.readBool();
17410 
        else:
17411 
          iprot.skip(ftype)
17412 
      else:
17413 
        iprot.skip(ftype)
17414 
      iprot.readFieldEnd()
17415 
    iprot.readStructEnd()
17416 
 
17417 
  def write(self, oprot):
17418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17420 
      return
17421 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17422 
    if self.orderId is not None:
17423 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17424 
      oprot.writeI64(self.orderId)
17425 
      oprot.writeFieldEnd()
17426 
    if self.isAuthorized is not None:
17427 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17428 
      oprot.writeBool(self.isAuthorized)
17429 
      oprot.writeFieldEnd()
17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class markOrderReturnRequestAuthorized_result:
17449 
  """
17450 
  Attributes:
17451 
   - success
17452 
   - ex
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    (0, TType.BOOL, 'success', None, None, ), # 0
17457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17458 
  )
17459 
 
17460 
  def __init__(self, success=None, ex=None,):
17461 
    self.success = success
17462 
    self.ex = ex
17463 
 
17464 
  def read(self, iprot):
17465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17467 
      return
17468 
    iprot.readStructBegin()
17469 
    while True:
17470 
      (fname, ftype, fid) = iprot.readFieldBegin()
17471 
      if ftype == TType.STOP:
17472 
        break
17473 
      if fid == 0:
17474 
        if ftype == TType.BOOL:
17475 
          self.success = iprot.readBool();
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      elif fid == 1:
17479 
        if ftype == TType.STRUCT:
17480 
          self.ex = TransactionServiceException()
17481 
          self.ex.read(iprot)
17482 
        else:
17483 
          iprot.skip(ftype)
17484 
      else:
17485 
        iprot.skip(ftype)
17486 
      iprot.readFieldEnd()
17487 
    iprot.readStructEnd()
17488 
 
17489 
  def write(self, oprot):
17490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17492 
      return
17493 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17494 
    if self.success is not None:
17495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17496 
      oprot.writeBool(self.success)
17497 
      oprot.writeFieldEnd()
17498 
    if self.ex is not None:
17499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17500 
      self.ex.write(oprot)
17501 
      oprot.writeFieldEnd()
17502 
    oprot.writeFieldStop()
17503 
    oprot.writeStructEnd()
17504 
 
17505 
  def validate(self):
17506 
    return
17507 
 
17508 
 
17509 
  def __repr__(self):
17510 
    L = ['%s=%r' % (key, value)
17511 
      for key, value in self.__dict__.iteritems()]
17512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17513 
 
17514 
  def __eq__(self, other):
17515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17516 
 
17517 
  def __ne__(self, other):
17518 
    return not (self == other)
17519 
 
2536 chandransh 17520 
class requestPickupNumber_args:
17521 
  """
17522 
  Attributes:
17523 
   - orderId
4579 rajveer 17524 
   - providerId
2536 chandransh 17525 
  """
17526 
 
17527 
  thrift_spec = (
17528 
    None, # 0
17529 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17530 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17531 
  )
17532 
 
4579 rajveer 17533 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17534 
    self.orderId = orderId
4579 rajveer 17535 
    self.providerId = providerId
2536 chandransh 17536 
 
17537 
  def read(self, iprot):
17538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17540 
      return
17541 
    iprot.readStructBegin()
17542 
    while True:
17543 
      (fname, ftype, fid) = iprot.readFieldBegin()
17544 
      if ftype == TType.STOP:
17545 
        break
17546 
      if fid == 1:
17547 
        if ftype == TType.I64:
17548 
          self.orderId = iprot.readI64();
17549 
        else:
17550 
          iprot.skip(ftype)
4579 rajveer 17551 
      elif fid == 2:
17552 
        if ftype == TType.I64:
17553 
          self.providerId = iprot.readI64();
17554 
        else:
17555 
          iprot.skip(ftype)
2536 chandransh 17556 
      else:
17557 
        iprot.skip(ftype)
17558 
      iprot.readFieldEnd()
17559 
    iprot.readStructEnd()
17560 
 
17561 
  def write(self, oprot):
17562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17564 
      return
17565 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17566 
    if self.orderId is not None:
2536 chandransh 17567 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17568 
      oprot.writeI64(self.orderId)
17569 
      oprot.writeFieldEnd()
4579 rajveer 17570 
    if self.providerId is not None:
17571 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17572 
      oprot.writeI64(self.providerId)
17573 
      oprot.writeFieldEnd()
2536 chandransh 17574 
    oprot.writeFieldStop()
17575 
    oprot.writeStructEnd()
17576 
 
3431 rajveer 17577 
  def validate(self):
17578 
    return
17579 
 
17580 
 
2536 chandransh 17581 
  def __repr__(self):
17582 
    L = ['%s=%r' % (key, value)
17583 
      for key, value in self.__dict__.iteritems()]
17584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17585 
 
17586 
  def __eq__(self, other):
17587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17588 
 
17589 
  def __ne__(self, other):
17590 
    return not (self == other)
17591 
 
17592 
class requestPickupNumber_result:
17593 
  """
17594 
  Attributes:
17595 
   - success
17596 
   - ex
17597 
  """
17598 
 
17599 
  thrift_spec = (
17600 
    (0, TType.BOOL, 'success', None, None, ), # 0
17601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17602 
  )
17603 
 
17604 
  def __init__(self, success=None, ex=None,):
17605 
    self.success = success
17606 
    self.ex = ex
17607 
 
17608 
  def read(self, iprot):
17609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17611 
      return
17612 
    iprot.readStructBegin()
17613 
    while True:
17614 
      (fname, ftype, fid) = iprot.readFieldBegin()
17615 
      if ftype == TType.STOP:
17616 
        break
17617 
      if fid == 0:
17618 
        if ftype == TType.BOOL:
17619 
          self.success = iprot.readBool();
17620 
        else:
17621 
          iprot.skip(ftype)
17622 
      elif fid == 1:
17623 
        if ftype == TType.STRUCT:
17624 
          self.ex = TransactionServiceException()
17625 
          self.ex.read(iprot)
17626 
        else:
17627 
          iprot.skip(ftype)
17628 
      else:
17629 
        iprot.skip(ftype)
17630 
      iprot.readFieldEnd()
17631 
    iprot.readStructEnd()
17632 
 
17633 
  def write(self, oprot):
17634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17636 
      return
17637 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17638 
    if self.success is not None:
2536 chandransh 17639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17640 
      oprot.writeBool(self.success)
17641 
      oprot.writeFieldEnd()
3431 rajveer 17642 
    if self.ex is not None:
2536 chandransh 17643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17644 
      self.ex.write(oprot)
17645 
      oprot.writeFieldEnd()
17646 
    oprot.writeFieldStop()
17647 
    oprot.writeStructEnd()
17648 
 
3431 rajveer 17649 
  def validate(self):
17650 
    return
17651 
 
17652 
 
2536 chandransh 17653 
  def __repr__(self):
17654 
    L = ['%s=%r' % (key, value)
17655 
      for key, value in self.__dict__.iteritems()]
17656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17657 
 
17658 
  def __eq__(self, other):
17659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17660 
 
17661 
  def __ne__(self, other):
17662 
    return not (self == other)
17663 
 
17664 
class authorizePickup_args:
17665 
  """
17666 
  Attributes:
17667 
   - orderId
17668 
   - pickupNumber
4602 rajveer 17669 
   - providerId
2536 chandransh 17670 
  """
17671 
 
17672 
  thrift_spec = (
17673 
    None, # 0
17674 
    (1, TType.I64, 'orderId', None, None, ), # 1
17675 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17676 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17677 
  )
17678 
 
4602 rajveer 17679 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17680 
    self.orderId = orderId
17681 
    self.pickupNumber = pickupNumber
4602 rajveer 17682 
    self.providerId = providerId
2536 chandransh 17683 
 
17684 
  def read(self, iprot):
17685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17687 
      return
17688 
    iprot.readStructBegin()
17689 
    while True:
17690 
      (fname, ftype, fid) = iprot.readFieldBegin()
17691 
      if ftype == TType.STOP:
17692 
        break
17693 
      if fid == 1:
17694 
        if ftype == TType.I64:
17695 
          self.orderId = iprot.readI64();
17696 
        else:
17697 
          iprot.skip(ftype)
17698 
      elif fid == 2:
17699 
        if ftype == TType.STRING:
17700 
          self.pickupNumber = iprot.readString();
17701 
        else:
17702 
          iprot.skip(ftype)
4602 rajveer 17703 
      elif fid == 3:
17704 
        if ftype == TType.I64:
17705 
          self.providerId = iprot.readI64();
17706 
        else:
17707 
          iprot.skip(ftype)
2536 chandransh 17708 
      else:
17709 
        iprot.skip(ftype)
17710 
      iprot.readFieldEnd()
17711 
    iprot.readStructEnd()
17712 
 
17713 
  def write(self, oprot):
17714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17716 
      return
17717 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17718 
    if self.orderId is not None:
2536 chandransh 17719 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17720 
      oprot.writeI64(self.orderId)
17721 
      oprot.writeFieldEnd()
3431 rajveer 17722 
    if self.pickupNumber is not None:
2536 chandransh 17723 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17724 
      oprot.writeString(self.pickupNumber)
17725 
      oprot.writeFieldEnd()
4602 rajveer 17726 
    if self.providerId is not None:
17727 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17728 
      oprot.writeI64(self.providerId)
17729 
      oprot.writeFieldEnd()
2536 chandransh 17730 
    oprot.writeFieldStop()
17731 
    oprot.writeStructEnd()
17732 
 
3431 rajveer 17733 
  def validate(self):
17734 
    return
17735 
 
17736 
 
2536 chandransh 17737 
  def __repr__(self):
17738 
    L = ['%s=%r' % (key, value)
17739 
      for key, value in self.__dict__.iteritems()]
17740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17741 
 
17742 
  def __eq__(self, other):
17743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17744 
 
17745 
  def __ne__(self, other):
17746 
    return not (self == other)
17747 
 
17748 
class authorizePickup_result:
17749 
  """
17750 
  Attributes:
17751 
   - success
17752 
   - ex
17753 
  """
17754 
 
17755 
  thrift_spec = (
17756 
    (0, TType.BOOL, 'success', None, None, ), # 0
17757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17758 
  )
17759 
 
17760 
  def __init__(self, success=None, ex=None,):
17761 
    self.success = success
17762 
    self.ex = ex
17763 
 
17764 
  def read(self, iprot):
17765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17767 
      return
17768 
    iprot.readStructBegin()
17769 
    while True:
17770 
      (fname, ftype, fid) = iprot.readFieldBegin()
17771 
      if ftype == TType.STOP:
17772 
        break
17773 
      if fid == 0:
17774 
        if ftype == TType.BOOL:
17775 
          self.success = iprot.readBool();
17776 
        else:
17777 
          iprot.skip(ftype)
17778 
      elif fid == 1:
17779 
        if ftype == TType.STRUCT:
17780 
          self.ex = TransactionServiceException()
17781 
          self.ex.read(iprot)
17782 
        else:
17783 
          iprot.skip(ftype)
17784 
      else:
17785 
        iprot.skip(ftype)
17786 
      iprot.readFieldEnd()
17787 
    iprot.readStructEnd()
17788 
 
17789 
  def write(self, oprot):
17790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17792 
      return
17793 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17794 
    if self.success is not None:
2536 chandransh 17795 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17796 
      oprot.writeBool(self.success)
17797 
      oprot.writeFieldEnd()
3431 rajveer 17798 
    if self.ex is not None:
2536 chandransh 17799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17800 
      self.ex.write(oprot)
17801 
      oprot.writeFieldEnd()
17802 
    oprot.writeFieldStop()
17803 
    oprot.writeStructEnd()
17804 
 
3431 rajveer 17805 
  def validate(self):
17806 
    return
17807 
 
17808 
 
2536 chandransh 17809 
  def __repr__(self):
17810 
    L = ['%s=%r' % (key, value)
17811 
      for key, value in self.__dict__.iteritems()]
17812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17813 
 
17814 
  def __eq__(self, other):
17815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17816 
 
17817 
  def __ne__(self, other):
17818 
    return not (self == other)
17819 
 
2764 chandransh 17820 
class markDoasAsPickedUp_args:
17821 
  """
17822 
  Attributes:
17823 
   - providerId
17824 
   - pickupDetails
17825 
  """
17826 
 
17827 
  thrift_spec = (
17828 
    None, # 0
17829 
    (1, TType.I64, 'providerId', None, None, ), # 1
17830 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17831 
  )
17832 
 
17833 
  def __init__(self, providerId=None, pickupDetails=None,):
17834 
    self.providerId = providerId
17835 
    self.pickupDetails = pickupDetails
17836 
 
17837 
  def read(self, iprot):
17838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17840 
      return
17841 
    iprot.readStructBegin()
17842 
    while True:
17843 
      (fname, ftype, fid) = iprot.readFieldBegin()
17844 
      if ftype == TType.STOP:
17845 
        break
17846 
      if fid == 1:
17847 
        if ftype == TType.I64:
17848 
          self.providerId = iprot.readI64();
17849 
        else:
17850 
          iprot.skip(ftype)
17851 
      elif fid == 2:
17852 
        if ftype == TType.MAP:
17853 
          self.pickupDetails = {}
6188 rajveer 17854 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17855 
          for _i411 in xrange(_size407):
17856 
            _key412 = iprot.readString();
17857 
            _val413 = iprot.readString();
17858 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17859 
          iprot.readMapEnd()
17860 
        else:
17861 
          iprot.skip(ftype)
17862 
      else:
17863 
        iprot.skip(ftype)
17864 
      iprot.readFieldEnd()
17865 
    iprot.readStructEnd()
17866 
 
17867 
  def write(self, oprot):
17868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17870 
      return
17871 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17872 
    if self.providerId is not None:
2764 chandransh 17873 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17874 
      oprot.writeI64(self.providerId)
17875 
      oprot.writeFieldEnd()
3431 rajveer 17876 
    if self.pickupDetails is not None:
2764 chandransh 17877 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17878 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17879 
      for kiter414,viter415 in self.pickupDetails.items():
17880 
        oprot.writeString(kiter414)
17881 
        oprot.writeString(viter415)
2764 chandransh 17882 
      oprot.writeMapEnd()
17883 
      oprot.writeFieldEnd()
17884 
    oprot.writeFieldStop()
17885 
    oprot.writeStructEnd()
17886 
 
3431 rajveer 17887 
  def validate(self):
17888 
    return
17889 
 
17890 
 
2764 chandransh 17891 
  def __repr__(self):
17892 
    L = ['%s=%r' % (key, value)
17893 
      for key, value in self.__dict__.iteritems()]
17894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17895 
 
17896 
  def __eq__(self, other):
17897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17898 
 
17899 
  def __ne__(self, other):
17900 
    return not (self == other)
17901 
 
17902 
class markDoasAsPickedUp_result:
4910 phani.kuma 17903 
 
17904 
  thrift_spec = (
17905 
  )
17906 
 
17907 
  def read(self, iprot):
17908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17910 
      return
17911 
    iprot.readStructBegin()
17912 
    while True:
17913 
      (fname, ftype, fid) = iprot.readFieldBegin()
17914 
      if ftype == TType.STOP:
17915 
        break
17916 
      else:
17917 
        iprot.skip(ftype)
17918 
      iprot.readFieldEnd()
17919 
    iprot.readStructEnd()
17920 
 
17921 
  def write(self, oprot):
17922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17924 
      return
17925 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17926 
    oprot.writeFieldStop()
17927 
    oprot.writeStructEnd()
17928 
 
17929 
  def validate(self):
17930 
    return
17931 
 
17932 
 
17933 
  def __repr__(self):
17934 
    L = ['%s=%r' % (key, value)
17935 
      for key, value in self.__dict__.iteritems()]
17936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17937 
 
17938 
  def __eq__(self, other):
17939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17940 
 
17941 
  def __ne__(self, other):
17942 
    return not (self == other)
17943 
 
17944 
class getDoasNotPickedUp_args:
2764 chandransh 17945 
  """
17946 
  Attributes:
4910 phani.kuma 17947 
   - providerId
17948 
  """
17949 
 
17950 
  thrift_spec = (
17951 
    None, # 0
17952 
    (1, TType.I64, 'providerId', None, None, ), # 1
17953 
  )
17954 
 
17955 
  def __init__(self, providerId=None,):
17956 
    self.providerId = providerId
17957 
 
17958 
  def read(self, iprot):
17959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17961 
      return
17962 
    iprot.readStructBegin()
17963 
    while True:
17964 
      (fname, ftype, fid) = iprot.readFieldBegin()
17965 
      if ftype == TType.STOP:
17966 
        break
17967 
      if fid == 1:
17968 
        if ftype == TType.I64:
17969 
          self.providerId = iprot.readI64();
17970 
        else:
17971 
          iprot.skip(ftype)
17972 
      else:
17973 
        iprot.skip(ftype)
17974 
      iprot.readFieldEnd()
17975 
    iprot.readStructEnd()
17976 
 
17977 
  def write(self, oprot):
17978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17980 
      return
17981 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17982 
    if self.providerId is not None:
17983 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17984 
      oprot.writeI64(self.providerId)
17985 
      oprot.writeFieldEnd()
17986 
    oprot.writeFieldStop()
17987 
    oprot.writeStructEnd()
17988 
 
17989 
  def validate(self):
17990 
    return
17991 
 
17992 
 
17993 
  def __repr__(self):
17994 
    L = ['%s=%r' % (key, value)
17995 
      for key, value in self.__dict__.iteritems()]
17996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17997 
 
17998 
  def __eq__(self, other):
17999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18000 
 
18001 
  def __ne__(self, other):
18002 
    return not (self == other)
18003 
 
18004 
class getDoasNotPickedUp_result:
18005 
  """
18006 
  Attributes:
2764 chandransh 18007 
   - success
18008 
  """
18009 
 
18010 
  thrift_spec = (
18011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18012 
  )
18013 
 
18014 
  def __init__(self, success=None,):
18015 
    self.success = success
18016 
 
18017 
  def read(self, iprot):
18018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18020 
      return
18021 
    iprot.readStructBegin()
18022 
    while True:
18023 
      (fname, ftype, fid) = iprot.readFieldBegin()
18024 
      if ftype == TType.STOP:
18025 
        break
18026 
      if fid == 0:
18027 
        if ftype == TType.LIST:
18028 
          self.success = []
6188 rajveer 18029 
          (_etype419, _size416) = iprot.readListBegin()
18030 
          for _i420 in xrange(_size416):
18031 
            _elem421 = Order()
18032 
            _elem421.read(iprot)
18033 
            self.success.append(_elem421)
2764 chandransh 18034 
          iprot.readListEnd()
18035 
        else:
18036 
          iprot.skip(ftype)
18037 
      else:
18038 
        iprot.skip(ftype)
18039 
      iprot.readFieldEnd()
18040 
    iprot.readStructEnd()
18041 
 
18042 
  def write(self, oprot):
18043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18045 
      return
4910 phani.kuma 18046 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18047 
    if self.success is not None:
2764 chandransh 18048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18050 
      for iter422 in self.success:
18051 
        iter422.write(oprot)
2764 chandransh 18052 
      oprot.writeListEnd()
18053 
      oprot.writeFieldEnd()
18054 
    oprot.writeFieldStop()
18055 
    oprot.writeStructEnd()
18056 
 
3431 rajveer 18057 
  def validate(self):
18058 
    return
18059 
 
18060 
 
2764 chandransh 18061 
  def __repr__(self):
18062 
    L = ['%s=%r' % (key, value)
18063 
      for key, value in self.__dict__.iteritems()]
18064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18065 
 
18066 
  def __eq__(self, other):
18067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18068 
 
18069 
  def __ne__(self, other):
18070 
    return not (self == other)
18071 
 
4741 phani.kuma 18072 
class markReturnOrdersAsPickedUp_args:
18073 
  """
18074 
  Attributes:
18075 
   - providerId
18076 
   - pickupDetails
18077 
  """
18078 
 
18079 
  thrift_spec = (
18080 
    None, # 0
18081 
    (1, TType.I64, 'providerId', None, None, ), # 1
18082 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18083 
  )
18084 
 
18085 
  def __init__(self, providerId=None, pickupDetails=None,):
18086 
    self.providerId = providerId
18087 
    self.pickupDetails = pickupDetails
18088 
 
18089 
  def read(self, iprot):
18090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18092 
      return
18093 
    iprot.readStructBegin()
18094 
    while True:
18095 
      (fname, ftype, fid) = iprot.readFieldBegin()
18096 
      if ftype == TType.STOP:
18097 
        break
18098 
      if fid == 1:
18099 
        if ftype == TType.I64:
18100 
          self.providerId = iprot.readI64();
18101 
        else:
18102 
          iprot.skip(ftype)
18103 
      elif fid == 2:
18104 
        if ftype == TType.MAP:
18105 
          self.pickupDetails = {}
6188 rajveer 18106 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18107 
          for _i427 in xrange(_size423):
18108 
            _key428 = iprot.readString();
18109 
            _val429 = iprot.readString();
18110 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18111 
          iprot.readMapEnd()
18112 
        else:
18113 
          iprot.skip(ftype)
18114 
      else:
18115 
        iprot.skip(ftype)
18116 
      iprot.readFieldEnd()
18117 
    iprot.readStructEnd()
18118 
 
18119 
  def write(self, oprot):
18120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18122 
      return
18123 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18124 
    if self.providerId is not None:
18125 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18126 
      oprot.writeI64(self.providerId)
18127 
      oprot.writeFieldEnd()
18128 
    if self.pickupDetails is not None:
18129 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18130 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18131 
      for kiter430,viter431 in self.pickupDetails.items():
18132 
        oprot.writeString(kiter430)
18133 
        oprot.writeString(viter431)
4741 phani.kuma 18134 
      oprot.writeMapEnd()
18135 
      oprot.writeFieldEnd()
18136 
    oprot.writeFieldStop()
18137 
    oprot.writeStructEnd()
18138 
 
18139 
  def validate(self):
18140 
    return
18141 
 
18142 
 
18143 
  def __repr__(self):
18144 
    L = ['%s=%r' % (key, value)
18145 
      for key, value in self.__dict__.iteritems()]
18146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18147 
 
18148 
  def __eq__(self, other):
18149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18150 
 
18151 
  def __ne__(self, other):
18152 
    return not (self == other)
18153 
 
18154 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18155 
 
18156 
  thrift_spec = (
18157 
  )
18158 
 
18159 
  def read(self, iprot):
18160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18162 
      return
18163 
    iprot.readStructBegin()
18164 
    while True:
18165 
      (fname, ftype, fid) = iprot.readFieldBegin()
18166 
      if ftype == TType.STOP:
18167 
        break
18168 
      else:
18169 
        iprot.skip(ftype)
18170 
      iprot.readFieldEnd()
18171 
    iprot.readStructEnd()
18172 
 
18173 
  def write(self, oprot):
18174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18176 
      return
18177 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18178 
    oprot.writeFieldStop()
18179 
    oprot.writeStructEnd()
18180 
 
18181 
  def validate(self):
18182 
    return
18183 
 
18184 
 
18185 
  def __repr__(self):
18186 
    L = ['%s=%r' % (key, value)
18187 
      for key, value in self.__dict__.iteritems()]
18188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18189 
 
18190 
  def __eq__(self, other):
18191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18192 
 
18193 
  def __ne__(self, other):
18194 
    return not (self == other)
18195 
 
18196 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18197 
  """
18198 
  Attributes:
4910 phani.kuma 18199 
   - providerId
18200 
  """
18201 
 
18202 
  thrift_spec = (
18203 
    None, # 0
18204 
    (1, TType.I64, 'providerId', None, None, ), # 1
18205 
  )
18206 
 
18207 
  def __init__(self, providerId=None,):
18208 
    self.providerId = providerId
18209 
 
18210 
  def read(self, iprot):
18211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18213 
      return
18214 
    iprot.readStructBegin()
18215 
    while True:
18216 
      (fname, ftype, fid) = iprot.readFieldBegin()
18217 
      if ftype == TType.STOP:
18218 
        break
18219 
      if fid == 1:
18220 
        if ftype == TType.I64:
18221 
          self.providerId = iprot.readI64();
18222 
        else:
18223 
          iprot.skip(ftype)
18224 
      else:
18225 
        iprot.skip(ftype)
18226 
      iprot.readFieldEnd()
18227 
    iprot.readStructEnd()
18228 
 
18229 
  def write(self, oprot):
18230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18232 
      return
18233 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18234 
    if self.providerId is not None:
18235 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18236 
      oprot.writeI64(self.providerId)
18237 
      oprot.writeFieldEnd()
18238 
    oprot.writeFieldStop()
18239 
    oprot.writeStructEnd()
18240 
 
18241 
  def validate(self):
18242 
    return
18243 
 
18244 
 
18245 
  def __repr__(self):
18246 
    L = ['%s=%r' % (key, value)
18247 
      for key, value in self.__dict__.iteritems()]
18248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18249 
 
18250 
  def __eq__(self, other):
18251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18252 
 
18253 
  def __ne__(self, other):
18254 
    return not (self == other)
18255 
 
18256 
class getReturnOrdersNotPickedUp_result:
18257 
  """
18258 
  Attributes:
4741 phani.kuma 18259 
   - success
18260 
  """
18261 
 
18262 
  thrift_spec = (
18263 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18264 
  )
18265 
 
18266 
  def __init__(self, success=None,):
18267 
    self.success = success
18268 
 
18269 
  def read(self, iprot):
18270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18272 
      return
18273 
    iprot.readStructBegin()
18274 
    while True:
18275 
      (fname, ftype, fid) = iprot.readFieldBegin()
18276 
      if ftype == TType.STOP:
18277 
        break
18278 
      if fid == 0:
18279 
        if ftype == TType.LIST:
18280 
          self.success = []
6188 rajveer 18281 
          (_etype435, _size432) = iprot.readListBegin()
18282 
          for _i436 in xrange(_size432):
18283 
            _elem437 = Order()
18284 
            _elem437.read(iprot)
18285 
            self.success.append(_elem437)
4741 phani.kuma 18286 
          iprot.readListEnd()
18287 
        else:
18288 
          iprot.skip(ftype)
18289 
      else:
18290 
        iprot.skip(ftype)
18291 
      iprot.readFieldEnd()
18292 
    iprot.readStructEnd()
18293 
 
18294 
  def write(self, oprot):
18295 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18296 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18297 
      return
4910 phani.kuma 18298 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18299 
    if self.success is not None:
18300 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18301 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18302 
      for iter438 in self.success:
18303 
        iter438.write(oprot)
4741 phani.kuma 18304 
      oprot.writeListEnd()
18305 
      oprot.writeFieldEnd()
18306 
    oprot.writeFieldStop()
18307 
    oprot.writeStructEnd()
18308 
 
18309 
  def validate(self):
18310 
    return
18311 
 
18312 
 
18313 
  def __repr__(self):
18314 
    L = ['%s=%r' % (key, value)
18315 
      for key, value in self.__dict__.iteritems()]
18316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18317 
 
18318 
  def __eq__(self, other):
18319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18320 
 
18321 
  def __ne__(self, other):
18322 
    return not (self == other)
18323 
 
2616 chandransh 18324 
class receiveReturn_args:
2591 chandransh 18325 
  """
18326 
  Attributes:
18327 
   - orderId
4479 rajveer 18328 
   - receiveCondition
2591 chandransh 18329 
  """
2536 chandransh 18330 
 
2591 chandransh 18331 
  thrift_spec = (
18332 
    None, # 0
18333 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18334 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18335 
  )
18336 
 
4479 rajveer 18337 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18338 
    self.orderId = orderId
4479 rajveer 18339 
    self.receiveCondition = receiveCondition
2591 chandransh 18340 
 
18341 
  def read(self, iprot):
18342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18344 
      return
18345 
    iprot.readStructBegin()
18346 
    while True:
18347 
      (fname, ftype, fid) = iprot.readFieldBegin()
18348 
      if ftype == TType.STOP:
18349 
        break
18350 
      if fid == 1:
18351 
        if ftype == TType.I64:
18352 
          self.orderId = iprot.readI64();
18353 
        else:
18354 
          iprot.skip(ftype)
4479 rajveer 18355 
      elif fid == 2:
18356 
        if ftype == TType.I64:
18357 
          self.receiveCondition = iprot.readI64();
18358 
        else:
18359 
          iprot.skip(ftype)
2591 chandransh 18360 
      else:
18361 
        iprot.skip(ftype)
18362 
      iprot.readFieldEnd()
18363 
    iprot.readStructEnd()
18364 
 
18365 
  def write(self, oprot):
18366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18368 
      return
2616 chandransh 18369 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18370 
    if self.orderId is not None:
2591 chandransh 18371 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18372 
      oprot.writeI64(self.orderId)
18373 
      oprot.writeFieldEnd()
4479 rajveer 18374 
    if self.receiveCondition is not None:
18375 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18376 
      oprot.writeI64(self.receiveCondition)
18377 
      oprot.writeFieldEnd()
2591 chandransh 18378 
    oprot.writeFieldStop()
18379 
    oprot.writeStructEnd()
18380 
 
3431 rajveer 18381 
  def validate(self):
18382 
    return
18383 
 
18384 
 
2591 chandransh 18385 
  def __repr__(self):
18386 
    L = ['%s=%r' % (key, value)
18387 
      for key, value in self.__dict__.iteritems()]
18388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18389 
 
18390 
  def __eq__(self, other):
18391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18392 
 
18393 
  def __ne__(self, other):
18394 
    return not (self == other)
18395 
 
2616 chandransh 18396 
class receiveReturn_result:
2591 chandransh 18397 
  """
18398 
  Attributes:
18399 
   - success
18400 
   - ex
18401 
  """
18402 
 
18403 
  thrift_spec = (
18404 
    (0, TType.BOOL, 'success', None, None, ), # 0
18405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18406 
  )
18407 
 
18408 
  def __init__(self, success=None, ex=None,):
18409 
    self.success = success
18410 
    self.ex = ex
18411 
 
18412 
  def read(self, iprot):
18413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18415 
      return
18416 
    iprot.readStructBegin()
18417 
    while True:
18418 
      (fname, ftype, fid) = iprot.readFieldBegin()
18419 
      if ftype == TType.STOP:
18420 
        break
18421 
      if fid == 0:
18422 
        if ftype == TType.BOOL:
18423 
          self.success = iprot.readBool();
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      elif fid == 1:
18427 
        if ftype == TType.STRUCT:
18428 
          self.ex = TransactionServiceException()
18429 
          self.ex.read(iprot)
18430 
        else:
18431 
          iprot.skip(ftype)
18432 
      else:
18433 
        iprot.skip(ftype)
18434 
      iprot.readFieldEnd()
18435 
    iprot.readStructEnd()
18436 
 
18437 
  def write(self, oprot):
18438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18440 
      return
2616 chandransh 18441 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18442 
    if self.success is not None:
2591 chandransh 18443 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18444 
      oprot.writeBool(self.success)
18445 
      oprot.writeFieldEnd()
3431 rajveer 18446 
    if self.ex is not None:
2591 chandransh 18447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18448 
      self.ex.write(oprot)
18449 
      oprot.writeFieldEnd()
18450 
    oprot.writeFieldStop()
18451 
    oprot.writeStructEnd()
18452 
 
3431 rajveer 18453 
  def validate(self):
18454 
    return
18455 
 
18456 
 
2591 chandransh 18457 
  def __repr__(self):
18458 
    L = ['%s=%r' % (key, value)
18459 
      for key, value in self.__dict__.iteritems()]
18460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18461 
 
18462 
  def __eq__(self, other):
18463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18464 
 
18465 
  def __ne__(self, other):
18466 
    return not (self == other)
18467 
 
18468 
class validateDoa_args:
18469 
  """
18470 
  Attributes:
18471 
   - orderId
18472 
   - isValid
18473 
  """
18474 
 
18475 
  thrift_spec = (
18476 
    None, # 0
18477 
    (1, TType.I64, 'orderId', None, None, ), # 1
18478 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18479 
  )
18480 
 
18481 
  def __init__(self, orderId=None, isValid=None,):
18482 
    self.orderId = orderId
18483 
    self.isValid = isValid
18484 
 
18485 
  def read(self, iprot):
18486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18488 
      return
18489 
    iprot.readStructBegin()
18490 
    while True:
18491 
      (fname, ftype, fid) = iprot.readFieldBegin()
18492 
      if ftype == TType.STOP:
18493 
        break
18494 
      if fid == 1:
18495 
        if ftype == TType.I64:
18496 
          self.orderId = iprot.readI64();
18497 
        else:
18498 
          iprot.skip(ftype)
18499 
      elif fid == 2:
18500 
        if ftype == TType.BOOL:
18501 
          self.isValid = iprot.readBool();
18502 
        else:
18503 
          iprot.skip(ftype)
18504 
      else:
18505 
        iprot.skip(ftype)
18506 
      iprot.readFieldEnd()
18507 
    iprot.readStructEnd()
18508 
 
18509 
  def write(self, oprot):
18510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18512 
      return
18513 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18514 
    if self.orderId is not None:
2591 chandransh 18515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18516 
      oprot.writeI64(self.orderId)
18517 
      oprot.writeFieldEnd()
3431 rajveer 18518 
    if self.isValid is not None:
2591 chandransh 18519 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18520 
      oprot.writeBool(self.isValid)
18521 
      oprot.writeFieldEnd()
18522 
    oprot.writeFieldStop()
18523 
    oprot.writeStructEnd()
18524 
 
3431 rajveer 18525 
  def validate(self):
18526 
    return
18527 
 
18528 
 
2591 chandransh 18529 
  def __repr__(self):
18530 
    L = ['%s=%r' % (key, value)
18531 
      for key, value in self.__dict__.iteritems()]
18532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18533 
 
18534 
  def __eq__(self, other):
18535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18536 
 
18537 
  def __ne__(self, other):
18538 
    return not (self == other)
18539 
 
18540 
class validateDoa_result:
18541 
  """
18542 
  Attributes:
18543 
   - success
18544 
   - ex
18545 
  """
18546 
 
18547 
  thrift_spec = (
18548 
    (0, TType.BOOL, 'success', None, None, ), # 0
18549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18550 
  )
18551 
 
18552 
  def __init__(self, success=None, ex=None,):
18553 
    self.success = success
18554 
    self.ex = ex
18555 
 
18556 
  def read(self, iprot):
18557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18559 
      return
18560 
    iprot.readStructBegin()
18561 
    while True:
18562 
      (fname, ftype, fid) = iprot.readFieldBegin()
18563 
      if ftype == TType.STOP:
18564 
        break
18565 
      if fid == 0:
18566 
        if ftype == TType.BOOL:
18567 
          self.success = iprot.readBool();
18568 
        else:
18569 
          iprot.skip(ftype)
18570 
      elif fid == 1:
18571 
        if ftype == TType.STRUCT:
18572 
          self.ex = TransactionServiceException()
18573 
          self.ex.read(iprot)
18574 
        else:
18575 
          iprot.skip(ftype)
18576 
      else:
18577 
        iprot.skip(ftype)
18578 
      iprot.readFieldEnd()
18579 
    iprot.readStructEnd()
18580 
 
18581 
  def write(self, oprot):
18582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18584 
      return
18585 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18586 
    if self.success is not None:
2591 chandransh 18587 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18588 
      oprot.writeBool(self.success)
18589 
      oprot.writeFieldEnd()
3431 rajveer 18590 
    if self.ex is not None:
2591 chandransh 18591 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18592 
      self.ex.write(oprot)
18593 
      oprot.writeFieldEnd()
18594 
    oprot.writeFieldStop()
18595 
    oprot.writeStructEnd()
18596 
 
3431 rajveer 18597 
  def validate(self):
18598 
    return
18599 
 
18600 
 
2591 chandransh 18601 
  def __repr__(self):
18602 
    L = ['%s=%r' % (key, value)
18603 
      for key, value in self.__dict__.iteritems()]
18604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18605 
 
18606 
  def __eq__(self, other):
18607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18608 
 
18609 
  def __ne__(self, other):
18610 
    return not (self == other)
18611 
 
4495 rajveer 18612 
class validateReturnProduct_args:
18613 
  """
18614 
  Attributes:
18615 
   - orderId
18616 
   - isUsable
18617 
  """
18618 
 
18619 
  thrift_spec = (
18620 
    None, # 0
18621 
    (1, TType.I64, 'orderId', None, None, ), # 1
18622 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18623 
  )
18624 
 
18625 
  def __init__(self, orderId=None, isUsable=None,):
18626 
    self.orderId = orderId
18627 
    self.isUsable = isUsable
18628 
 
18629 
  def read(self, iprot):
18630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18632 
      return
18633 
    iprot.readStructBegin()
18634 
    while True:
18635 
      (fname, ftype, fid) = iprot.readFieldBegin()
18636 
      if ftype == TType.STOP:
18637 
        break
18638 
      if fid == 1:
18639 
        if ftype == TType.I64:
18640 
          self.orderId = iprot.readI64();
18641 
        else:
18642 
          iprot.skip(ftype)
18643 
      elif fid == 2:
18644 
        if ftype == TType.BOOL:
18645 
          self.isUsable = iprot.readBool();
18646 
        else:
18647 
          iprot.skip(ftype)
18648 
      else:
18649 
        iprot.skip(ftype)
18650 
      iprot.readFieldEnd()
18651 
    iprot.readStructEnd()
18652 
 
18653 
  def write(self, oprot):
18654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18656 
      return
18657 
    oprot.writeStructBegin('validateReturnProduct_args')
18658 
    if self.orderId is not None:
18659 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18660 
      oprot.writeI64(self.orderId)
18661 
      oprot.writeFieldEnd()
18662 
    if self.isUsable is not None:
18663 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18664 
      oprot.writeBool(self.isUsable)
18665 
      oprot.writeFieldEnd()
18666 
    oprot.writeFieldStop()
18667 
    oprot.writeStructEnd()
18668 
 
18669 
  def validate(self):
18670 
    return
18671 
 
18672 
 
18673 
  def __repr__(self):
18674 
    L = ['%s=%r' % (key, value)
18675 
      for key, value in self.__dict__.iteritems()]
18676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18677 
 
18678 
  def __eq__(self, other):
18679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18680 
 
18681 
  def __ne__(self, other):
18682 
    return not (self == other)
18683 
 
18684 
class validateReturnProduct_result:
18685 
  """
18686 
  Attributes:
18687 
   - success
18688 
   - ex
18689 
  """
18690 
 
18691 
  thrift_spec = (
18692 
    (0, TType.BOOL, 'success', None, None, ), # 0
18693 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18694 
  )
18695 
 
18696 
  def __init__(self, success=None, ex=None,):
18697 
    self.success = success
18698 
    self.ex = ex
18699 
 
18700 
  def read(self, iprot):
18701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18703 
      return
18704 
    iprot.readStructBegin()
18705 
    while True:
18706 
      (fname, ftype, fid) = iprot.readFieldBegin()
18707 
      if ftype == TType.STOP:
18708 
        break
18709 
      if fid == 0:
18710 
        if ftype == TType.BOOL:
18711 
          self.success = iprot.readBool();
18712 
        else:
18713 
          iprot.skip(ftype)
18714 
      elif fid == 1:
18715 
        if ftype == TType.STRUCT:
18716 
          self.ex = TransactionServiceException()
18717 
          self.ex.read(iprot)
18718 
        else:
18719 
          iprot.skip(ftype)
18720 
      else:
18721 
        iprot.skip(ftype)
18722 
      iprot.readFieldEnd()
18723 
    iprot.readStructEnd()
18724 
 
18725 
  def write(self, oprot):
18726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18728 
      return
18729 
    oprot.writeStructBegin('validateReturnProduct_result')
18730 
    if self.success is not None:
18731 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18732 
      oprot.writeBool(self.success)
18733 
      oprot.writeFieldEnd()
18734 
    if self.ex is not None:
18735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18736 
      self.ex.write(oprot)
18737 
      oprot.writeFieldEnd()
18738 
    oprot.writeFieldStop()
18739 
    oprot.writeStructEnd()
18740 
 
18741 
  def validate(self):
18742 
    return
18743 
 
18744 
 
18745 
  def __repr__(self):
18746 
    L = ['%s=%r' % (key, value)
18747 
      for key, value in self.__dict__.iteritems()]
18748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18749 
 
18750 
  def __eq__(self, other):
18751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18752 
 
18753 
  def __ne__(self, other):
18754 
    return not (self == other)
18755 
 
2616 chandransh 18756 
class reshipOrder_args:
18757 
  """
18758 
  Attributes:
18759 
   - orderId
18760 
  """
2591 chandransh 18761 
 
2616 chandransh 18762 
  thrift_spec = (
18763 
    None, # 0
18764 
    (1, TType.I64, 'orderId', None, None, ), # 1
18765 
  )
18766 
 
18767 
  def __init__(self, orderId=None,):
18768 
    self.orderId = orderId
18769 
 
18770 
  def read(self, iprot):
18771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18773 
      return
18774 
    iprot.readStructBegin()
18775 
    while True:
18776 
      (fname, ftype, fid) = iprot.readFieldBegin()
18777 
      if ftype == TType.STOP:
18778 
        break
18779 
      if fid == 1:
18780 
        if ftype == TType.I64:
18781 
          self.orderId = iprot.readI64();
18782 
        else:
18783 
          iprot.skip(ftype)
18784 
      else:
18785 
        iprot.skip(ftype)
18786 
      iprot.readFieldEnd()
18787 
    iprot.readStructEnd()
18788 
 
18789 
  def write(self, oprot):
18790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18792 
      return
18793 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18794 
    if self.orderId is not None:
2616 chandransh 18795 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18796 
      oprot.writeI64(self.orderId)
18797 
      oprot.writeFieldEnd()
18798 
    oprot.writeFieldStop()
18799 
    oprot.writeStructEnd()
18800 
 
3431 rajveer 18801 
  def validate(self):
18802 
    return
18803 
 
18804 
 
2616 chandransh 18805 
  def __repr__(self):
18806 
    L = ['%s=%r' % (key, value)
18807 
      for key, value in self.__dict__.iteritems()]
18808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18809 
 
18810 
  def __eq__(self, other):
18811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18812 
 
18813 
  def __ne__(self, other):
18814 
    return not (self == other)
18815 
 
18816 
class reshipOrder_result:
18817 
  """
18818 
  Attributes:
18819 
   - success
18820 
   - ex
18821 
  """
18822 
 
18823 
  thrift_spec = (
18824 
    (0, TType.I64, 'success', None, None, ), # 0
18825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18826 
  )
18827 
 
18828 
  def __init__(self, success=None, ex=None,):
18829 
    self.success = success
18830 
    self.ex = ex
18831 
 
18832 
  def read(self, iprot):
18833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18835 
      return
18836 
    iprot.readStructBegin()
18837 
    while True:
18838 
      (fname, ftype, fid) = iprot.readFieldBegin()
18839 
      if ftype == TType.STOP:
18840 
        break
18841 
      if fid == 0:
18842 
        if ftype == TType.I64:
18843 
          self.success = iprot.readI64();
18844 
        else:
18845 
          iprot.skip(ftype)
18846 
      elif fid == 1:
18847 
        if ftype == TType.STRUCT:
18848 
          self.ex = TransactionServiceException()
18849 
          self.ex.read(iprot)
18850 
        else:
18851 
          iprot.skip(ftype)
18852 
      else:
18853 
        iprot.skip(ftype)
18854 
      iprot.readFieldEnd()
18855 
    iprot.readStructEnd()
18856 
 
18857 
  def write(self, oprot):
18858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18860 
      return
18861 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18862 
    if self.success is not None:
2616 chandransh 18863 
      oprot.writeFieldBegin('success', TType.I64, 0)
18864 
      oprot.writeI64(self.success)
18865 
      oprot.writeFieldEnd()
3431 rajveer 18866 
    if self.ex is not None:
2616 chandransh 18867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18868 
      self.ex.write(oprot)
18869 
      oprot.writeFieldEnd()
18870 
    oprot.writeFieldStop()
18871 
    oprot.writeStructEnd()
18872 
 
3431 rajveer 18873 
  def validate(self):
18874 
    return
18875 
 
18876 
 
2616 chandransh 18877 
  def __repr__(self):
18878 
    L = ['%s=%r' % (key, value)
18879 
      for key, value in self.__dict__.iteritems()]
18880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18881 
 
18882 
  def __eq__(self, other):
18883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18884 
 
18885 
  def __ne__(self, other):
18886 
    return not (self == other)
18887 
 
18888 
class refundOrder_args:
18889 
  """
18890 
  Attributes:
18891 
   - orderId
3226 chandransh 18892 
   - refundedBy
18893 
   - reason
2616 chandransh 18894 
  """
18895 
 
18896 
  thrift_spec = (
18897 
    None, # 0
18898 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18899 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18900 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18901 
  )
18902 
 
3226 chandransh 18903 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18904 
    self.orderId = orderId
3226 chandransh 18905 
    self.refundedBy = refundedBy
18906 
    self.reason = reason
2616 chandransh 18907 
 
18908 
  def read(self, iprot):
18909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18911 
      return
18912 
    iprot.readStructBegin()
18913 
    while True:
18914 
      (fname, ftype, fid) = iprot.readFieldBegin()
18915 
      if ftype == TType.STOP:
18916 
        break
18917 
      if fid == 1:
18918 
        if ftype == TType.I64:
18919 
          self.orderId = iprot.readI64();
18920 
        else:
18921 
          iprot.skip(ftype)
3226 chandransh 18922 
      elif fid == 2:
18923 
        if ftype == TType.STRING:
18924 
          self.refundedBy = iprot.readString();
18925 
        else:
18926 
          iprot.skip(ftype)
18927 
      elif fid == 3:
18928 
        if ftype == TType.STRING:
18929 
          self.reason = iprot.readString();
18930 
        else:
18931 
          iprot.skip(ftype)
2616 chandransh 18932 
      else:
18933 
        iprot.skip(ftype)
18934 
      iprot.readFieldEnd()
18935 
    iprot.readStructEnd()
18936 
 
18937 
  def write(self, oprot):
18938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18940 
      return
18941 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18942 
    if self.orderId is not None:
2616 chandransh 18943 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18944 
      oprot.writeI64(self.orderId)
18945 
      oprot.writeFieldEnd()
3431 rajveer 18946 
    if self.refundedBy is not None:
3226 chandransh 18947 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18948 
      oprot.writeString(self.refundedBy)
18949 
      oprot.writeFieldEnd()
3431 rajveer 18950 
    if self.reason is not None:
3226 chandransh 18951 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18952 
      oprot.writeString(self.reason)
18953 
      oprot.writeFieldEnd()
2616 chandransh 18954 
    oprot.writeFieldStop()
18955 
    oprot.writeStructEnd()
18956 
 
3431 rajveer 18957 
  def validate(self):
18958 
    return
18959 
 
18960 
 
2616 chandransh 18961 
  def __repr__(self):
18962 
    L = ['%s=%r' % (key, value)
18963 
      for key, value in self.__dict__.iteritems()]
18964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18965 
 
18966 
  def __eq__(self, other):
18967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18968 
 
18969 
  def __ne__(self, other):
18970 
    return not (self == other)
18971 
 
18972 
class refundOrder_result:
18973 
  """
18974 
  Attributes:
18975 
   - success
18976 
   - ex
18977 
  """
18978 
 
18979 
  thrift_spec = (
18980 
    (0, TType.BOOL, 'success', None, None, ), # 0
18981 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18982 
  )
18983 
 
18984 
  def __init__(self, success=None, ex=None,):
18985 
    self.success = success
18986 
    self.ex = ex
18987 
 
18988 
  def read(self, iprot):
18989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18991 
      return
18992 
    iprot.readStructBegin()
18993 
    while True:
18994 
      (fname, ftype, fid) = iprot.readFieldBegin()
18995 
      if ftype == TType.STOP:
18996 
        break
18997 
      if fid == 0:
18998 
        if ftype == TType.BOOL:
18999 
          self.success = iprot.readBool();
19000 
        else:
19001 
          iprot.skip(ftype)
19002 
      elif fid == 1:
19003 
        if ftype == TType.STRUCT:
19004 
          self.ex = TransactionServiceException()
19005 
          self.ex.read(iprot)
19006 
        else:
19007 
          iprot.skip(ftype)
19008 
      else:
19009 
        iprot.skip(ftype)
19010 
      iprot.readFieldEnd()
19011 
    iprot.readStructEnd()
19012 
 
19013 
  def write(self, oprot):
19014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19016 
      return
19017 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19018 
    if self.success is not None:
2616 chandransh 19019 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19020 
      oprot.writeBool(self.success)
19021 
      oprot.writeFieldEnd()
3431 rajveer 19022 
    if self.ex is not None:
2616 chandransh 19023 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19024 
      self.ex.write(oprot)
19025 
      oprot.writeFieldEnd()
19026 
    oprot.writeFieldStop()
19027 
    oprot.writeStructEnd()
19028 
 
3431 rajveer 19029 
  def validate(self):
19030 
    return
19031 
 
19032 
 
2616 chandransh 19033 
  def __repr__(self):
19034 
    L = ['%s=%r' % (key, value)
19035 
      for key, value in self.__dict__.iteritems()]
19036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19037 
 
19038 
  def __eq__(self, other):
19039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19040 
 
19041 
  def __ne__(self, other):
19042 
    return not (self == other)
19043 
 
2690 chandransh 19044 
class getReturnOrders_args:
19045 
  """
19046 
  Attributes:
19047 
   - warehouseId
19048 
   - fromDate
19049 
   - toDate
19050 
  """
2616 chandransh 19051 
 
2690 chandransh 19052 
  thrift_spec = (
19053 
    None, # 0
19054 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19055 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19056 
    (3, TType.I64, 'toDate', None, None, ), # 3
19057 
  )
19058 
 
19059 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19060 
    self.warehouseId = warehouseId
19061 
    self.fromDate = fromDate
19062 
    self.toDate = toDate
19063 
 
19064 
  def read(self, iprot):
19065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19067 
      return
19068 
    iprot.readStructBegin()
19069 
    while True:
19070 
      (fname, ftype, fid) = iprot.readFieldBegin()
19071 
      if ftype == TType.STOP:
19072 
        break
19073 
      if fid == 1:
19074 
        if ftype == TType.I64:
19075 
          self.warehouseId = iprot.readI64();
19076 
        else:
19077 
          iprot.skip(ftype)
19078 
      elif fid == 2:
19079 
        if ftype == TType.I64:
19080 
          self.fromDate = iprot.readI64();
19081 
        else:
19082 
          iprot.skip(ftype)
19083 
      elif fid == 3:
19084 
        if ftype == TType.I64:
19085 
          self.toDate = iprot.readI64();
19086 
        else:
19087 
          iprot.skip(ftype)
19088 
      else:
19089 
        iprot.skip(ftype)
19090 
      iprot.readFieldEnd()
19091 
    iprot.readStructEnd()
19092 
 
19093 
  def write(self, oprot):
19094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19096 
      return
19097 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19098 
    if self.warehouseId is not None:
2690 chandransh 19099 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19100 
      oprot.writeI64(self.warehouseId)
19101 
      oprot.writeFieldEnd()
3431 rajveer 19102 
    if self.fromDate is not None:
2690 chandransh 19103 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19104 
      oprot.writeI64(self.fromDate)
19105 
      oprot.writeFieldEnd()
3431 rajveer 19106 
    if self.toDate is not None:
2690 chandransh 19107 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19108 
      oprot.writeI64(self.toDate)
19109 
      oprot.writeFieldEnd()
19110 
    oprot.writeFieldStop()
19111 
    oprot.writeStructEnd()
19112 
 
3431 rajveer 19113 
  def validate(self):
19114 
    return
19115 
 
19116 
 
2690 chandransh 19117 
  def __repr__(self):
19118 
    L = ['%s=%r' % (key, value)
19119 
      for key, value in self.__dict__.iteritems()]
19120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19121 
 
19122 
  def __eq__(self, other):
19123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19124 
 
19125 
  def __ne__(self, other):
19126 
    return not (self == other)
19127 
 
19128 
class getReturnOrders_result:
19129 
  """
19130 
  Attributes:
19131 
   - success
19132 
  """
19133 
 
19134 
  thrift_spec = (
19135 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19136 
  )
19137 
 
19138 
  def __init__(self, success=None,):
19139 
    self.success = success
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      if fid == 0:
19151 
        if ftype == TType.LIST:
19152 
          self.success = []
6188 rajveer 19153 
          (_etype442, _size439) = iprot.readListBegin()
19154 
          for _i443 in xrange(_size439):
19155 
            _elem444 = ReturnOrder()
19156 
            _elem444.read(iprot)
19157 
            self.success.append(_elem444)
2690 chandransh 19158 
          iprot.readListEnd()
19159 
        else:
19160 
          iprot.skip(ftype)
19161 
      else:
19162 
        iprot.skip(ftype)
19163 
      iprot.readFieldEnd()
19164 
    iprot.readStructEnd()
19165 
 
19166 
  def write(self, oprot):
19167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19169 
      return
19170 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19171 
    if self.success is not None:
2690 chandransh 19172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19174 
      for iter445 in self.success:
19175 
        iter445.write(oprot)
2690 chandransh 19176 
      oprot.writeListEnd()
19177 
      oprot.writeFieldEnd()
19178 
    oprot.writeFieldStop()
19179 
    oprot.writeStructEnd()
19180 
 
3431 rajveer 19181 
  def validate(self):
19182 
    return
19183 
 
19184 
 
2690 chandransh 19185 
  def __repr__(self):
19186 
    L = ['%s=%r' % (key, value)
19187 
      for key, value in self.__dict__.iteritems()]
19188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19189 
 
19190 
  def __eq__(self, other):
19191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19192 
 
19193 
  def __ne__(self, other):
19194 
    return not (self == other)
19195 
 
5481 phani.kuma 19196 
class getAllReturnOrders_args:
19197 
  """
19198 
  Attributes:
19199 
   - onlyNotProcessed
19200 
   - fromDate
19201 
   - toDate
19202 
  """
19203 
 
19204 
  thrift_spec = (
19205 
    None, # 0
19206 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19207 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19208 
    (3, TType.I64, 'toDate', None, None, ), # 3
19209 
  )
19210 
 
19211 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19212 
    self.onlyNotProcessed = onlyNotProcessed
19213 
    self.fromDate = fromDate
19214 
    self.toDate = toDate
19215 
 
19216 
  def read(self, iprot):
19217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19219 
      return
19220 
    iprot.readStructBegin()
19221 
    while True:
19222 
      (fname, ftype, fid) = iprot.readFieldBegin()
19223 
      if ftype == TType.STOP:
19224 
        break
19225 
      if fid == 1:
19226 
        if ftype == TType.BOOL:
19227 
          self.onlyNotProcessed = iprot.readBool();
19228 
        else:
19229 
          iprot.skip(ftype)
19230 
      elif fid == 2:
19231 
        if ftype == TType.I64:
19232 
          self.fromDate = iprot.readI64();
19233 
        else:
19234 
          iprot.skip(ftype)
19235 
      elif fid == 3:
19236 
        if ftype == TType.I64:
19237 
          self.toDate = iprot.readI64();
19238 
        else:
19239 
          iprot.skip(ftype)
19240 
      else:
19241 
        iprot.skip(ftype)
19242 
      iprot.readFieldEnd()
19243 
    iprot.readStructEnd()
19244 
 
19245 
  def write(self, oprot):
19246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19248 
      return
19249 
    oprot.writeStructBegin('getAllReturnOrders_args')
19250 
    if self.onlyNotProcessed is not None:
19251 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19252 
      oprot.writeBool(self.onlyNotProcessed)
19253 
      oprot.writeFieldEnd()
19254 
    if self.fromDate is not None:
19255 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19256 
      oprot.writeI64(self.fromDate)
19257 
      oprot.writeFieldEnd()
19258 
    if self.toDate is not None:
19259 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19260 
      oprot.writeI64(self.toDate)
19261 
      oprot.writeFieldEnd()
19262 
    oprot.writeFieldStop()
19263 
    oprot.writeStructEnd()
19264 
 
19265 
  def validate(self):
19266 
    return
19267 
 
19268 
 
19269 
  def __repr__(self):
19270 
    L = ['%s=%r' % (key, value)
19271 
      for key, value in self.__dict__.iteritems()]
19272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19273 
 
19274 
  def __eq__(self, other):
19275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19276 
 
19277 
  def __ne__(self, other):
19278 
    return not (self == other)
19279 
 
19280 
class getAllReturnOrders_result:
19281 
  """
19282 
  Attributes:
19283 
   - success
19284 
  """
19285 
 
19286 
  thrift_spec = (
19287 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19288 
  )
19289 
 
19290 
  def __init__(self, success=None,):
19291 
    self.success = success
19292 
 
19293 
  def read(self, iprot):
19294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19296 
      return
19297 
    iprot.readStructBegin()
19298 
    while True:
19299 
      (fname, ftype, fid) = iprot.readFieldBegin()
19300 
      if ftype == TType.STOP:
19301 
        break
19302 
      if fid == 0:
19303 
        if ftype == TType.LIST:
19304 
          self.success = []
6188 rajveer 19305 
          (_etype449, _size446) = iprot.readListBegin()
19306 
          for _i450 in xrange(_size446):
19307 
            _elem451 = ReturnOrder()
19308 
            _elem451.read(iprot)
19309 
            self.success.append(_elem451)
5481 phani.kuma 19310 
          iprot.readListEnd()
19311 
        else:
19312 
          iprot.skip(ftype)
19313 
      else:
19314 
        iprot.skip(ftype)
19315 
      iprot.readFieldEnd()
19316 
    iprot.readStructEnd()
19317 
 
19318 
  def write(self, oprot):
19319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19321 
      return
19322 
    oprot.writeStructBegin('getAllReturnOrders_result')
19323 
    if self.success is not None:
19324 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19325 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19326 
      for iter452 in self.success:
19327 
        iter452.write(oprot)
5481 phani.kuma 19328 
      oprot.writeListEnd()
19329 
      oprot.writeFieldEnd()
19330 
    oprot.writeFieldStop()
19331 
    oprot.writeStructEnd()
19332 
 
19333 
  def validate(self):
19334 
    return
19335 
 
19336 
 
19337 
  def __repr__(self):
19338 
    L = ['%s=%r' % (key, value)
19339 
      for key, value in self.__dict__.iteritems()]
19340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19341 
 
19342 
  def __eq__(self, other):
19343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19344 
 
19345 
  def __ne__(self, other):
19346 
    return not (self == other)
19347 
 
2700 chandransh 19348 
class getReturnOrder_args:
19349 
  """
19350 
  Attributes:
19351 
   - id
19352 
  """
19353 
 
19354 
  thrift_spec = (
19355 
    None, # 0
19356 
    (1, TType.I64, 'id', None, None, ), # 1
19357 
  )
19358 
 
19359 
  def __init__(self, id=None,):
19360 
    self.id = id
19361 
 
19362 
  def read(self, iprot):
19363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19365 
      return
19366 
    iprot.readStructBegin()
19367 
    while True:
19368 
      (fname, ftype, fid) = iprot.readFieldBegin()
19369 
      if ftype == TType.STOP:
19370 
        break
19371 
      if fid == 1:
19372 
        if ftype == TType.I64:
19373 
          self.id = iprot.readI64();
19374 
        else:
19375 
          iprot.skip(ftype)
19376 
      else:
19377 
        iprot.skip(ftype)
19378 
      iprot.readFieldEnd()
19379 
    iprot.readStructEnd()
19380 
 
19381 
  def write(self, oprot):
19382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19384 
      return
19385 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19386 
    if self.id is not None:
2700 chandransh 19387 
      oprot.writeFieldBegin('id', TType.I64, 1)
19388 
      oprot.writeI64(self.id)
19389 
      oprot.writeFieldEnd()
19390 
    oprot.writeFieldStop()
19391 
    oprot.writeStructEnd()
19392 
 
3431 rajveer 19393 
  def validate(self):
19394 
    return
19395 
 
19396 
 
2700 chandransh 19397 
  def __repr__(self):
19398 
    L = ['%s=%r' % (key, value)
19399 
      for key, value in self.__dict__.iteritems()]
19400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19401 
 
19402 
  def __eq__(self, other):
19403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19404 
 
19405 
  def __ne__(self, other):
19406 
    return not (self == other)
19407 
 
19408 
class getReturnOrder_result:
19409 
  """
19410 
  Attributes:
19411 
   - success
19412 
   - ex
19413 
  """
19414 
 
19415 
  thrift_spec = (
19416 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19418 
  )
19419 
 
19420 
  def __init__(self, success=None, ex=None,):
19421 
    self.success = success
19422 
    self.ex = ex
19423 
 
19424 
  def read(self, iprot):
19425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19427 
      return
19428 
    iprot.readStructBegin()
19429 
    while True:
19430 
      (fname, ftype, fid) = iprot.readFieldBegin()
19431 
      if ftype == TType.STOP:
19432 
        break
19433 
      if fid == 0:
19434 
        if ftype == TType.STRUCT:
19435 
          self.success = ReturnOrder()
19436 
          self.success.read(iprot)
19437 
        else:
19438 
          iprot.skip(ftype)
19439 
      elif fid == 1:
19440 
        if ftype == TType.STRUCT:
19441 
          self.ex = TransactionServiceException()
19442 
          self.ex.read(iprot)
19443 
        else:
19444 
          iprot.skip(ftype)
19445 
      else:
19446 
        iprot.skip(ftype)
19447 
      iprot.readFieldEnd()
19448 
    iprot.readStructEnd()
19449 
 
19450 
  def write(self, oprot):
19451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19453 
      return
19454 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19455 
    if self.success is not None:
2700 chandransh 19456 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19457 
      self.success.write(oprot)
19458 
      oprot.writeFieldEnd()
3431 rajveer 19459 
    if self.ex is not None:
2700 chandransh 19460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19461 
      self.ex.write(oprot)
19462 
      oprot.writeFieldEnd()
19463 
    oprot.writeFieldStop()
19464 
    oprot.writeStructEnd()
19465 
 
3431 rajveer 19466 
  def validate(self):
19467 
    return
19468 
 
19469 
 
2700 chandransh 19470 
  def __repr__(self):
19471 
    L = ['%s=%r' % (key, value)
19472 
      for key, value in self.__dict__.iteritems()]
19473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19474 
 
19475 
  def __eq__(self, other):
19476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19477 
 
19478 
  def __ne__(self, other):
19479 
    return not (self == other)
19480 
 
2690 chandransh 19481 
class processReturn_args:
19482 
  """
19483 
  Attributes:
19484 
   - returnOrderId
19485 
  """
19486 
 
19487 
  thrift_spec = (
19488 
    None, # 0
19489 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19490 
  )
19491 
 
19492 
  def __init__(self, returnOrderId=None,):
19493 
    self.returnOrderId = returnOrderId
19494 
 
19495 
  def read(self, iprot):
19496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19498 
      return
19499 
    iprot.readStructBegin()
19500 
    while True:
19501 
      (fname, ftype, fid) = iprot.readFieldBegin()
19502 
      if ftype == TType.STOP:
19503 
        break
19504 
      if fid == 1:
19505 
        if ftype == TType.I64:
19506 
          self.returnOrderId = iprot.readI64();
19507 
        else:
19508 
          iprot.skip(ftype)
19509 
      else:
19510 
        iprot.skip(ftype)
19511 
      iprot.readFieldEnd()
19512 
    iprot.readStructEnd()
19513 
 
19514 
  def write(self, oprot):
19515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19517 
      return
19518 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19519 
    if self.returnOrderId is not None:
2690 chandransh 19520 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19521 
      oprot.writeI64(self.returnOrderId)
19522 
      oprot.writeFieldEnd()
19523 
    oprot.writeFieldStop()
19524 
    oprot.writeStructEnd()
19525 
 
3431 rajveer 19526 
  def validate(self):
19527 
    return
19528 
 
19529 
 
2690 chandransh 19530 
  def __repr__(self):
19531 
    L = ['%s=%r' % (key, value)
19532 
      for key, value in self.__dict__.iteritems()]
19533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19534 
 
19535 
  def __eq__(self, other):
19536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19537 
 
19538 
  def __ne__(self, other):
19539 
    return not (self == other)
19540 
 
19541 
class processReturn_result:
19542 
  """
19543 
  Attributes:
19544 
   - ex
19545 
  """
19546 
 
19547 
  thrift_spec = (
19548 
    None, # 0
19549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19550 
  )
19551 
 
19552 
  def __init__(self, ex=None,):
19553 
    self.ex = ex
19554 
 
19555 
  def read(self, iprot):
19556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19558 
      return
19559 
    iprot.readStructBegin()
19560 
    while True:
19561 
      (fname, ftype, fid) = iprot.readFieldBegin()
19562 
      if ftype == TType.STOP:
19563 
        break
19564 
      if fid == 1:
19565 
        if ftype == TType.STRUCT:
19566 
          self.ex = TransactionServiceException()
19567 
          self.ex.read(iprot)
19568 
        else:
19569 
          iprot.skip(ftype)
19570 
      else:
19571 
        iprot.skip(ftype)
19572 
      iprot.readFieldEnd()
19573 
    iprot.readStructEnd()
19574 
 
19575 
  def write(self, oprot):
19576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19578 
      return
19579 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19580 
    if self.ex is not None:
2690 chandransh 19581 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19582 
      self.ex.write(oprot)
19583 
      oprot.writeFieldEnd()
19584 
    oprot.writeFieldStop()
19585 
    oprot.writeStructEnd()
19586 
 
3431 rajveer 19587 
  def validate(self):
19588 
    return
19589 
 
19590 
 
2690 chandransh 19591 
  def __repr__(self):
19592 
    L = ['%s=%r' % (key, value)
19593 
      for key, value in self.__dict__.iteritems()]
19594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19595 
 
19596 
  def __eq__(self, other):
19597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19598 
 
19599 
  def __ne__(self, other):
19600 
    return not (self == other)
19601 
 
3451 chandransh 19602 
class updateWeight_args:
19603 
  """
19604 
  Attributes:
19605 
   - orderId
19606 
   - weight
19607 
  """
19608 
 
19609 
  thrift_spec = (
19610 
    None, # 0
19611 
    (1, TType.I64, 'orderId', None, None, ), # 1
19612 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19613 
  )
19614 
 
19615 
  def __init__(self, orderId=None, weight=None,):
19616 
    self.orderId = orderId
19617 
    self.weight = weight
19618 
 
19619 
  def read(self, iprot):
19620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19622 
      return
19623 
    iprot.readStructBegin()
19624 
    while True:
19625 
      (fname, ftype, fid) = iprot.readFieldBegin()
19626 
      if ftype == TType.STOP:
19627 
        break
19628 
      if fid == 1:
19629 
        if ftype == TType.I64:
19630 
          self.orderId = iprot.readI64();
19631 
        else:
19632 
          iprot.skip(ftype)
19633 
      elif fid == 2:
19634 
        if ftype == TType.DOUBLE:
19635 
          self.weight = iprot.readDouble();
19636 
        else:
19637 
          iprot.skip(ftype)
19638 
      else:
19639 
        iprot.skip(ftype)
19640 
      iprot.readFieldEnd()
19641 
    iprot.readStructEnd()
19642 
 
19643 
  def write(self, oprot):
19644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19646 
      return
19647 
    oprot.writeStructBegin('updateWeight_args')
19648 
    if self.orderId is not None:
19649 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19650 
      oprot.writeI64(self.orderId)
19651 
      oprot.writeFieldEnd()
19652 
    if self.weight is not None:
19653 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19654 
      oprot.writeDouble(self.weight)
19655 
      oprot.writeFieldEnd()
19656 
    oprot.writeFieldStop()
19657 
    oprot.writeStructEnd()
19658 
 
19659 
  def validate(self):
19660 
    return
19661 
 
19662 
 
19663 
  def __repr__(self):
19664 
    L = ['%s=%r' % (key, value)
19665 
      for key, value in self.__dict__.iteritems()]
19666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19667 
 
19668 
  def __eq__(self, other):
19669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19670 
 
19671 
  def __ne__(self, other):
19672 
    return not (self == other)
19673 
 
19674 
class updateWeight_result:
19675 
  """
19676 
  Attributes:
19677 
   - success
19678 
   - ex
19679 
  """
19680 
 
19681 
  thrift_spec = (
19682 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19683 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19684 
  )
19685 
 
19686 
  def __init__(self, success=None, ex=None,):
19687 
    self.success = success
19688 
    self.ex = ex
19689 
 
19690 
  def read(self, iprot):
19691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19693 
      return
19694 
    iprot.readStructBegin()
19695 
    while True:
19696 
      (fname, ftype, fid) = iprot.readFieldBegin()
19697 
      if ftype == TType.STOP:
19698 
        break
19699 
      if fid == 0:
19700 
        if ftype == TType.STRUCT:
19701 
          self.success = Order()
19702 
          self.success.read(iprot)
19703 
        else:
19704 
          iprot.skip(ftype)
19705 
      elif fid == 1:
19706 
        if ftype == TType.STRUCT:
19707 
          self.ex = TransactionServiceException()
19708 
          self.ex.read(iprot)
19709 
        else:
19710 
          iprot.skip(ftype)
19711 
      else:
19712 
        iprot.skip(ftype)
19713 
      iprot.readFieldEnd()
19714 
    iprot.readStructEnd()
19715 
 
19716 
  def write(self, oprot):
19717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19719 
      return
19720 
    oprot.writeStructBegin('updateWeight_result')
19721 
    if self.success is not None:
19722 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19723 
      self.success.write(oprot)
19724 
      oprot.writeFieldEnd()
19725 
    if self.ex is not None:
19726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19727 
      self.ex.write(oprot)
19728 
      oprot.writeFieldEnd()
19729 
    oprot.writeFieldStop()
19730 
    oprot.writeStructEnd()
19731 
 
19732 
  def validate(self):
19733 
    return
19734 
 
19735 
 
19736 
  def __repr__(self):
19737 
    L = ['%s=%r' % (key, value)
19738 
      for key, value in self.__dict__.iteritems()]
19739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19740 
 
19741 
  def __eq__(self, other):
19742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19743 
 
19744 
  def __ne__(self, other):
19745 
    return not (self == other)
3469 chandransh 19746 
 
19747 
class changeItem_args:
19748 
  """
19749 
  Attributes:
19750 
   - orderId
19751 
   - itemId
19752 
  """
19753 
 
19754 
  thrift_spec = (
19755 
    None, # 0
19756 
    (1, TType.I64, 'orderId', None, None, ), # 1
19757 
    (2, TType.I64, 'itemId', None, None, ), # 2
19758 
  )
19759 
 
19760 
  def __init__(self, orderId=None, itemId=None,):
19761 
    self.orderId = orderId
19762 
    self.itemId = itemId
19763 
 
19764 
  def read(self, iprot):
19765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19767 
      return
19768 
    iprot.readStructBegin()
19769 
    while True:
19770 
      (fname, ftype, fid) = iprot.readFieldBegin()
19771 
      if ftype == TType.STOP:
19772 
        break
19773 
      if fid == 1:
19774 
        if ftype == TType.I64:
19775 
          self.orderId = iprot.readI64();
19776 
        else:
19777 
          iprot.skip(ftype)
19778 
      elif fid == 2:
19779 
        if ftype == TType.I64:
19780 
          self.itemId = iprot.readI64();
19781 
        else:
19782 
          iprot.skip(ftype)
19783 
      else:
19784 
        iprot.skip(ftype)
19785 
      iprot.readFieldEnd()
19786 
    iprot.readStructEnd()
19787 
 
19788 
  def write(self, oprot):
19789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19791 
      return
19792 
    oprot.writeStructBegin('changeItem_args')
19793 
    if self.orderId is not None:
19794 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19795 
      oprot.writeI64(self.orderId)
19796 
      oprot.writeFieldEnd()
19797 
    if self.itemId is not None:
19798 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19799 
      oprot.writeI64(self.itemId)
19800 
      oprot.writeFieldEnd()
19801 
    oprot.writeFieldStop()
19802 
    oprot.writeStructEnd()
19803 
 
19804 
  def validate(self):
19805 
    return
19806 
 
19807 
 
19808 
  def __repr__(self):
19809 
    L = ['%s=%r' % (key, value)
19810 
      for key, value in self.__dict__.iteritems()]
19811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19812 
 
19813 
  def __eq__(self, other):
19814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19815 
 
19816 
  def __ne__(self, other):
19817 
    return not (self == other)
19818 
 
19819 
class changeItem_result:
19820 
  """
19821 
  Attributes:
19822 
   - success
19823 
   - ex
19824 
  """
19825 
 
19826 
  thrift_spec = (
19827 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19828 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19829 
  )
19830 
 
19831 
  def __init__(self, success=None, ex=None,):
19832 
    self.success = success
19833 
    self.ex = ex
19834 
 
19835 
  def read(self, iprot):
19836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19838 
      return
19839 
    iprot.readStructBegin()
19840 
    while True:
19841 
      (fname, ftype, fid) = iprot.readFieldBegin()
19842 
      if ftype == TType.STOP:
19843 
        break
19844 
      if fid == 0:
19845 
        if ftype == TType.STRUCT:
19846 
          self.success = Order()
19847 
          self.success.read(iprot)
19848 
        else:
19849 
          iprot.skip(ftype)
19850 
      elif fid == 1:
19851 
        if ftype == TType.STRUCT:
19852 
          self.ex = TransactionServiceException()
19853 
          self.ex.read(iprot)
19854 
        else:
19855 
          iprot.skip(ftype)
19856 
      else:
19857 
        iprot.skip(ftype)
19858 
      iprot.readFieldEnd()
19859 
    iprot.readStructEnd()
19860 
 
19861 
  def write(self, oprot):
19862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19864 
      return
19865 
    oprot.writeStructBegin('changeItem_result')
19866 
    if self.success is not None:
19867 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19868 
      self.success.write(oprot)
19869 
      oprot.writeFieldEnd()
19870 
    if self.ex is not None:
19871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19872 
      self.ex.write(oprot)
19873 
      oprot.writeFieldEnd()
19874 
    oprot.writeFieldStop()
19875 
    oprot.writeStructEnd()
19876 
 
19877 
  def validate(self):
19878 
    return
19879 
 
19880 
 
19881 
  def __repr__(self):
19882 
    L = ['%s=%r' % (key, value)
19883 
      for key, value in self.__dict__.iteritems()]
19884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19885 
 
19886 
  def __eq__(self, other):
19887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19888 
 
19889 
  def __ne__(self, other):
19890 
    return not (self == other)
19891 
 
19892 
class shiftToWarehouse_args:
19893 
  """
19894 
  Attributes:
19895 
   - orderId
19896 
   - warehouseId
19897 
  """
19898 
 
19899 
  thrift_spec = (
19900 
    None, # 0
19901 
    (1, TType.I64, 'orderId', None, None, ), # 1
19902 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19903 
  )
19904 
 
19905 
  def __init__(self, orderId=None, warehouseId=None,):
19906 
    self.orderId = orderId
19907 
    self.warehouseId = warehouseId
19908 
 
19909 
  def read(self, iprot):
19910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19912 
      return
19913 
    iprot.readStructBegin()
19914 
    while True:
19915 
      (fname, ftype, fid) = iprot.readFieldBegin()
19916 
      if ftype == TType.STOP:
19917 
        break
19918 
      if fid == 1:
19919 
        if ftype == TType.I64:
19920 
          self.orderId = iprot.readI64();
19921 
        else:
19922 
          iprot.skip(ftype)
19923 
      elif fid == 2:
19924 
        if ftype == TType.I64:
19925 
          self.warehouseId = iprot.readI64();
19926 
        else:
19927 
          iprot.skip(ftype)
19928 
      else:
19929 
        iprot.skip(ftype)
19930 
      iprot.readFieldEnd()
19931 
    iprot.readStructEnd()
19932 
 
19933 
  def write(self, oprot):
19934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19936 
      return
19937 
    oprot.writeStructBegin('shiftToWarehouse_args')
19938 
    if self.orderId is not None:
19939 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19940 
      oprot.writeI64(self.orderId)
19941 
      oprot.writeFieldEnd()
19942 
    if self.warehouseId is not None:
19943 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19944 
      oprot.writeI64(self.warehouseId)
19945 
      oprot.writeFieldEnd()
19946 
    oprot.writeFieldStop()
19947 
    oprot.writeStructEnd()
19948 
 
19949 
  def validate(self):
19950 
    return
19951 
 
19952 
 
19953 
  def __repr__(self):
19954 
    L = ['%s=%r' % (key, value)
19955 
      for key, value in self.__dict__.iteritems()]
19956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19957 
 
19958 
  def __eq__(self, other):
19959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19960 
 
19961 
  def __ne__(self, other):
19962 
    return not (self == other)
19963 
 
19964 
class shiftToWarehouse_result:
19965 
  """
19966 
  Attributes:
19967 
   - success
19968 
   - ex
19969 
  """
19970 
 
19971 
  thrift_spec = (
19972 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19973 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19974 
  )
19975 
 
19976 
  def __init__(self, success=None, ex=None,):
19977 
    self.success = success
19978 
    self.ex = ex
19979 
 
19980 
  def read(self, iprot):
19981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19983 
      return
19984 
    iprot.readStructBegin()
19985 
    while True:
19986 
      (fname, ftype, fid) = iprot.readFieldBegin()
19987 
      if ftype == TType.STOP:
19988 
        break
19989 
      if fid == 0:
19990 
        if ftype == TType.STRUCT:
19991 
          self.success = Order()
19992 
          self.success.read(iprot)
19993 
        else:
19994 
          iprot.skip(ftype)
19995 
      elif fid == 1:
19996 
        if ftype == TType.STRUCT:
19997 
          self.ex = TransactionServiceException()
19998 
          self.ex.read(iprot)
19999 
        else:
20000 
          iprot.skip(ftype)
20001 
      else:
20002 
        iprot.skip(ftype)
20003 
      iprot.readFieldEnd()
20004 
    iprot.readStructEnd()
20005 
 
20006 
  def write(self, oprot):
20007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20009 
      return
20010 
    oprot.writeStructBegin('shiftToWarehouse_result')
20011 
    if self.success is not None:
20012 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20013 
      self.success.write(oprot)
20014 
      oprot.writeFieldEnd()
20015 
    if self.ex is not None:
20016 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20017 
      self.ex.write(oprot)
20018 
      oprot.writeFieldEnd()
20019 
    oprot.writeFieldStop()
20020 
    oprot.writeStructEnd()
20021 
 
20022 
  def validate(self):
20023 
    return
20024 
 
20025 
 
20026 
  def __repr__(self):
20027 
    L = ['%s=%r' % (key, value)
20028 
      for key, value in self.__dict__.iteritems()]
20029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20030 
 
20031 
  def __eq__(self, other):
20032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20033 
 
20034 
  def __ne__(self, other):
20035 
    return not (self == other)
3553 chandransh 20036 
 
20037 
class addDelayReason_args:
20038 
  """
20039 
  Attributes:
20040 
   - orderId
20041 
   - delayReason
3986 chandransh 20042 
   - furtherDelay
4647 rajveer 20043 
   - delayReasonText
3553 chandransh 20044 
  """
20045 
 
20046 
  thrift_spec = (
20047 
    None, # 0
20048 
    (1, TType.I64, 'orderId', None, None, ), # 1
20049 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20050 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20051 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20052 
  )
20053 
 
4647 rajveer 20054 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20055 
    self.orderId = orderId
20056 
    self.delayReason = delayReason
3986 chandransh 20057 
    self.furtherDelay = furtherDelay
4647 rajveer 20058 
    self.delayReasonText = delayReasonText
3553 chandransh 20059 
 
20060 
  def read(self, iprot):
20061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20063 
      return
20064 
    iprot.readStructBegin()
20065 
    while True:
20066 
      (fname, ftype, fid) = iprot.readFieldBegin()
20067 
      if ftype == TType.STOP:
20068 
        break
20069 
      if fid == 1:
20070 
        if ftype == TType.I64:
20071 
          self.orderId = iprot.readI64();
20072 
        else:
20073 
          iprot.skip(ftype)
20074 
      elif fid == 2:
20075 
        if ftype == TType.I32:
20076 
          self.delayReason = iprot.readI32();
20077 
        else:
20078 
          iprot.skip(ftype)
3986 chandransh 20079 
      elif fid == 3:
20080 
        if ftype == TType.I64:
20081 
          self.furtherDelay = iprot.readI64();
20082 
        else:
20083 
          iprot.skip(ftype)
4647 rajveer 20084 
      elif fid == 4:
20085 
        if ftype == TType.STRING:
20086 
          self.delayReasonText = iprot.readString();
20087 
        else:
20088 
          iprot.skip(ftype)
3553 chandransh 20089 
      else:
20090 
        iprot.skip(ftype)
20091 
      iprot.readFieldEnd()
20092 
    iprot.readStructEnd()
20093 
 
20094 
  def write(self, oprot):
20095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20097 
      return
20098 
    oprot.writeStructBegin('addDelayReason_args')
20099 
    if self.orderId is not None:
20100 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20101 
      oprot.writeI64(self.orderId)
20102 
      oprot.writeFieldEnd()
20103 
    if self.delayReason is not None:
20104 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20105 
      oprot.writeI32(self.delayReason)
20106 
      oprot.writeFieldEnd()
3986 chandransh 20107 
    if self.furtherDelay is not None:
20108 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20109 
      oprot.writeI64(self.furtherDelay)
20110 
      oprot.writeFieldEnd()
4647 rajveer 20111 
    if self.delayReasonText is not None:
20112 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20113 
      oprot.writeString(self.delayReasonText)
20114 
      oprot.writeFieldEnd()
3553 chandransh 20115 
    oprot.writeFieldStop()
20116 
    oprot.writeStructEnd()
20117 
 
20118 
  def validate(self):
20119 
    return
20120 
 
20121 
 
20122 
  def __repr__(self):
20123 
    L = ['%s=%r' % (key, value)
20124 
      for key, value in self.__dict__.iteritems()]
20125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20126 
 
20127 
  def __eq__(self, other):
20128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20129 
 
20130 
  def __ne__(self, other):
20131 
    return not (self == other)
20132 
 
20133 
class addDelayReason_result:
20134 
  """
20135 
  Attributes:
20136 
   - success
20137 
   - ex
20138 
  """
20139 
 
20140 
  thrift_spec = (
20141 
    (0, TType.BOOL, 'success', None, None, ), # 0
20142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20143 
  )
20144 
 
20145 
  def __init__(self, success=None, ex=None,):
20146 
    self.success = success
20147 
    self.ex = ex
20148 
 
20149 
  def read(self, iprot):
20150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20152 
      return
20153 
    iprot.readStructBegin()
20154 
    while True:
20155 
      (fname, ftype, fid) = iprot.readFieldBegin()
20156 
      if ftype == TType.STOP:
20157 
        break
20158 
      if fid == 0:
20159 
        if ftype == TType.BOOL:
20160 
          self.success = iprot.readBool();
20161 
        else:
20162 
          iprot.skip(ftype)
20163 
      elif fid == 1:
20164 
        if ftype == TType.STRUCT:
20165 
          self.ex = TransactionServiceException()
20166 
          self.ex.read(iprot)
20167 
        else:
20168 
          iprot.skip(ftype)
20169 
      else:
20170 
        iprot.skip(ftype)
20171 
      iprot.readFieldEnd()
20172 
    iprot.readStructEnd()
20173 
 
20174 
  def write(self, oprot):
20175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20177 
      return
20178 
    oprot.writeStructBegin('addDelayReason_result')
20179 
    if self.success is not None:
20180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20181 
      oprot.writeBool(self.success)
20182 
      oprot.writeFieldEnd()
20183 
    if self.ex is not None:
20184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20185 
      self.ex.write(oprot)
20186 
      oprot.writeFieldEnd()
20187 
    oprot.writeFieldStop()
20188 
    oprot.writeStructEnd()
20189 
 
20190 
  def validate(self):
20191 
    return
20192 
 
20193 
 
20194 
  def __repr__(self):
20195 
    L = ['%s=%r' % (key, value)
20196 
      for key, value in self.__dict__.iteritems()]
20197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20198 
 
20199 
  def __eq__(self, other):
20200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20201 
 
20202 
  def __ne__(self, other):
20203 
    return not (self == other)
3956 chandransh 20204 
 
20205 
class reconcileCodCollection_args:
20206 
  """
20207 
  Attributes:
20208 
   - collectedAmountMap
20209 
   - xferBy
20210 
   - xferTxnId
20211 
   - xferDate
20212 
  """
20213 
 
20214 
  thrift_spec = (
20215 
    None, # 0
20216 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20217 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20218 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20219 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20220 
  )
20221 
 
20222 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20223 
    self.collectedAmountMap = collectedAmountMap
20224 
    self.xferBy = xferBy
20225 
    self.xferTxnId = xferTxnId
20226 
    self.xferDate = xferDate
20227 
 
20228 
  def read(self, iprot):
20229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20231 
      return
20232 
    iprot.readStructBegin()
20233 
    while True:
20234 
      (fname, ftype, fid) = iprot.readFieldBegin()
20235 
      if ftype == TType.STOP:
20236 
        break
20237 
      if fid == 1:
20238 
        if ftype == TType.MAP:
20239 
          self.collectedAmountMap = {}
6188 rajveer 20240 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20241 
          for _i457 in xrange(_size453):
20242 
            _key458 = iprot.readString();
20243 
            _val459 = iprot.readDouble();
20244 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20245 
          iprot.readMapEnd()
20246 
        else:
20247 
          iprot.skip(ftype)
20248 
      elif fid == 2:
20249 
        if ftype == TType.STRING:
20250 
          self.xferBy = iprot.readString();
20251 
        else:
20252 
          iprot.skip(ftype)
20253 
      elif fid == 3:
20254 
        if ftype == TType.STRING:
20255 
          self.xferTxnId = iprot.readString();
20256 
        else:
20257 
          iprot.skip(ftype)
20258 
      elif fid == 4:
20259 
        if ftype == TType.I64:
20260 
          self.xferDate = iprot.readI64();
20261 
        else:
20262 
          iprot.skip(ftype)
20263 
      else:
20264 
        iprot.skip(ftype)
20265 
      iprot.readFieldEnd()
20266 
    iprot.readStructEnd()
20267 
 
20268 
  def write(self, oprot):
20269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20271 
      return
20272 
    oprot.writeStructBegin('reconcileCodCollection_args')
20273 
    if self.collectedAmountMap is not None:
20274 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20275 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20276 
      for kiter460,viter461 in self.collectedAmountMap.items():
20277 
        oprot.writeString(kiter460)
20278 
        oprot.writeDouble(viter461)
3956 chandransh 20279 
      oprot.writeMapEnd()
20280 
      oprot.writeFieldEnd()
20281 
    if self.xferBy is not None:
20282 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20283 
      oprot.writeString(self.xferBy)
20284 
      oprot.writeFieldEnd()
20285 
    if self.xferTxnId is not None:
20286 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20287 
      oprot.writeString(self.xferTxnId)
20288 
      oprot.writeFieldEnd()
20289 
    if self.xferDate is not None:
20290 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20291 
      oprot.writeI64(self.xferDate)
20292 
      oprot.writeFieldEnd()
20293 
    oprot.writeFieldStop()
20294 
    oprot.writeStructEnd()
20295 
 
20296 
  def validate(self):
20297 
    return
20298 
 
20299 
 
20300 
  def __repr__(self):
20301 
    L = ['%s=%r' % (key, value)
20302 
      for key, value in self.__dict__.iteritems()]
20303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20304 
 
20305 
  def __eq__(self, other):
20306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20307 
 
20308 
  def __ne__(self, other):
20309 
    return not (self == other)
20310 
 
20311 
class reconcileCodCollection_result:
20312 
  """
20313 
  Attributes:
20314 
   - success
20315 
   - ex
20316 
  """
20317 
 
20318 
  thrift_spec = (
20319 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20320 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20321 
  )
20322 
 
20323 
  def __init__(self, success=None, ex=None,):
20324 
    self.success = success
20325 
    self.ex = ex
20326 
 
20327 
  def read(self, iprot):
20328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20330 
      return
20331 
    iprot.readStructBegin()
20332 
    while True:
20333 
      (fname, ftype, fid) = iprot.readFieldBegin()
20334 
      if ftype == TType.STOP:
20335 
        break
20336 
      if fid == 0:
20337 
        if ftype == TType.MAP:
20338 
          self.success = {}
6188 rajveer 20339 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20340 
          for _i466 in xrange(_size462):
20341 
            _key467 = iprot.readString();
20342 
            _val468 = iprot.readString();
20343 
            self.success[_key467] = _val468
3956 chandransh 20344 
          iprot.readMapEnd()
20345 
        else:
20346 
          iprot.skip(ftype)
20347 
      elif fid == 1:
20348 
        if ftype == TType.STRUCT:
20349 
          self.ex = TransactionServiceException()
20350 
          self.ex.read(iprot)
20351 
        else:
20352 
          iprot.skip(ftype)
20353 
      else:
20354 
        iprot.skip(ftype)
20355 
      iprot.readFieldEnd()
20356 
    iprot.readStructEnd()
20357 
 
20358 
  def write(self, oprot):
20359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20361 
      return
20362 
    oprot.writeStructBegin('reconcileCodCollection_result')
20363 
    if self.success is not None:
20364 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20365 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20366 
      for kiter469,viter470 in self.success.items():
20367 
        oprot.writeString(kiter469)
20368 
        oprot.writeString(viter470)
3956 chandransh 20369 
      oprot.writeMapEnd()
20370 
      oprot.writeFieldEnd()
20371 
    if self.ex is not None:
20372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20373 
      self.ex.write(oprot)
20374 
      oprot.writeFieldEnd()
20375 
    oprot.writeFieldStop()
20376 
    oprot.writeStructEnd()
20377 
 
20378 
  def validate(self):
20379 
    return
20380 
 
20381 
 
20382 
  def __repr__(self):
20383 
    L = ['%s=%r' % (key, value)
20384 
      for key, value in self.__dict__.iteritems()]
20385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20386 
 
20387 
  def __eq__(self, other):
20388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20389 
 
20390 
  def __ne__(self, other):
20391 
    return not (self == other)
4008 mandeep.dh 20392 
 
20393 
class getTransactionsRequiringExtraProcessing_args:
20394 
  """
20395 
  Attributes:
20396 
   - category
20397 
  """
20398 
 
20399 
  thrift_spec = (
20400 
    None, # 0
20401 
    (1, TType.I32, 'category', None, None, ), # 1
20402 
  )
20403 
 
20404 
  def __init__(self, category=None,):
20405 
    self.category = category
20406 
 
20407 
  def read(self, iprot):
20408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20410 
      return
20411 
    iprot.readStructBegin()
20412 
    while True:
20413 
      (fname, ftype, fid) = iprot.readFieldBegin()
20414 
      if ftype == TType.STOP:
20415 
        break
20416 
      if fid == 1:
20417 
        if ftype == TType.I32:
20418 
          self.category = iprot.readI32();
20419 
        else:
20420 
          iprot.skip(ftype)
20421 
      else:
20422 
        iprot.skip(ftype)
20423 
      iprot.readFieldEnd()
20424 
    iprot.readStructEnd()
20425 
 
20426 
  def write(self, oprot):
20427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20429 
      return
20430 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20431 
    if self.category is not None:
20432 
      oprot.writeFieldBegin('category', TType.I32, 1)
20433 
      oprot.writeI32(self.category)
20434 
      oprot.writeFieldEnd()
20435 
    oprot.writeFieldStop()
20436 
    oprot.writeStructEnd()
20437 
 
20438 
  def validate(self):
20439 
    return
20440 
 
20441 
 
20442 
  def __repr__(self):
20443 
    L = ['%s=%r' % (key, value)
20444 
      for key, value in self.__dict__.iteritems()]
20445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20446 
 
20447 
  def __eq__(self, other):
20448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20449 
 
20450 
  def __ne__(self, other):
20451 
    return not (self == other)
20452 
 
20453 
class getTransactionsRequiringExtraProcessing_result:
20454 
  """
20455 
  Attributes:
20456 
   - success
20457 
  """
20458 
 
20459 
  thrift_spec = (
20460 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20461 
  )
20462 
 
20463 
  def __init__(self, success=None,):
20464 
    self.success = success
20465 
 
20466 
  def read(self, iprot):
20467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20469 
      return
20470 
    iprot.readStructBegin()
20471 
    while True:
20472 
      (fname, ftype, fid) = iprot.readFieldBegin()
20473 
      if ftype == TType.STOP:
20474 
        break
20475 
      if fid == 0:
20476 
        if ftype == TType.LIST:
20477 
          self.success = []
6188 rajveer 20478 
          (_etype474, _size471) = iprot.readListBegin()
20479 
          for _i475 in xrange(_size471):
20480 
            _elem476 = iprot.readI64();
20481 
            self.success.append(_elem476)
4008 mandeep.dh 20482 
          iprot.readListEnd()
20483 
        else:
20484 
          iprot.skip(ftype)
20485 
      else:
20486 
        iprot.skip(ftype)
20487 
      iprot.readFieldEnd()
20488 
    iprot.readStructEnd()
20489 
 
20490 
  def write(self, oprot):
20491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20493 
      return
20494 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20495 
    if self.success is not None:
20496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20497 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20498 
      for iter477 in self.success:
20499 
        oprot.writeI64(iter477)
4008 mandeep.dh 20500 
      oprot.writeListEnd()
20501 
      oprot.writeFieldEnd()
20502 
    oprot.writeFieldStop()
20503 
    oprot.writeStructEnd()
20504 
 
20505 
  def validate(self):
20506 
    return
20507 
 
20508 
 
20509 
  def __repr__(self):
20510 
    L = ['%s=%r' % (key, value)
20511 
      for key, value in self.__dict__.iteritems()]
20512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20513 
 
20514 
  def __eq__(self, other):
20515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20516 
 
20517 
  def __ne__(self, other):
20518 
    return not (self == other)
20519 
 
20520 
class markTransactionAsProcessed_args:
20521 
  """
20522 
  Attributes:
20523 
   - transactionId
20524 
   - category
20525 
  """
20526 
 
20527 
  thrift_spec = (
20528 
    None, # 0
20529 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20530 
    (2, TType.I32, 'category', None, None, ), # 2
20531 
  )
20532 
 
20533 
  def __init__(self, transactionId=None, category=None,):
20534 
    self.transactionId = transactionId
20535 
    self.category = category
20536 
 
20537 
  def read(self, iprot):
20538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20540 
      return
20541 
    iprot.readStructBegin()
20542 
    while True:
20543 
      (fname, ftype, fid) = iprot.readFieldBegin()
20544 
      if ftype == TType.STOP:
20545 
        break
20546 
      if fid == 1:
20547 
        if ftype == TType.I64:
20548 
          self.transactionId = iprot.readI64();
20549 
        else:
20550 
          iprot.skip(ftype)
20551 
      elif fid == 2:
20552 
        if ftype == TType.I32:
20553 
          self.category = iprot.readI32();
20554 
        else:
20555 
          iprot.skip(ftype)
20556 
      else:
20557 
        iprot.skip(ftype)
20558 
      iprot.readFieldEnd()
20559 
    iprot.readStructEnd()
20560 
 
20561 
  def write(self, oprot):
20562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20564 
      return
20565 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20566 
    if self.transactionId is not None:
20567 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20568 
      oprot.writeI64(self.transactionId)
20569 
      oprot.writeFieldEnd()
20570 
    if self.category is not None:
20571 
      oprot.writeFieldBegin('category', TType.I32, 2)
20572 
      oprot.writeI32(self.category)
20573 
      oprot.writeFieldEnd()
20574 
    oprot.writeFieldStop()
20575 
    oprot.writeStructEnd()
20576 
 
20577 
  def validate(self):
20578 
    return
20579 
 
20580 
 
20581 
  def __repr__(self):
20582 
    L = ['%s=%r' % (key, value)
20583 
      for key, value in self.__dict__.iteritems()]
20584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20585 
 
20586 
  def __eq__(self, other):
20587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20588 
 
20589 
  def __ne__(self, other):
20590 
    return not (self == other)
20591 
 
20592 
class markTransactionAsProcessed_result:
20593 
 
20594 
  thrift_spec = (
20595 
  )
20596 
 
20597 
  def read(self, iprot):
20598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20600 
      return
20601 
    iprot.readStructBegin()
20602 
    while True:
20603 
      (fname, ftype, fid) = iprot.readFieldBegin()
20604 
      if ftype == TType.STOP:
20605 
        break
20606 
      else:
20607 
        iprot.skip(ftype)
20608 
      iprot.readFieldEnd()
20609 
    iprot.readStructEnd()
20610 
 
20611 
  def write(self, oprot):
20612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20614 
      return
20615 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20616 
    oprot.writeFieldStop()
20617 
    oprot.writeStructEnd()
20618 
 
20619 
  def validate(self):
20620 
    return
20621 
 
20622 
 
20623 
  def __repr__(self):
20624 
    L = ['%s=%r' % (key, value)
20625 
      for key, value in self.__dict__.iteritems()]
20626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20627 
 
20628 
  def __eq__(self, other):
20629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20630 
 
20631 
  def __ne__(self, other):
20632 
    return not (self == other)
4018 chandransh 20633 
 
20634 
class getItemWiseRiskyOrdersCount_args:
20635 
 
20636 
  thrift_spec = (
20637 
  )
20638 
 
20639 
  def read(self, iprot):
20640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20642 
      return
20643 
    iprot.readStructBegin()
20644 
    while True:
20645 
      (fname, ftype, fid) = iprot.readFieldBegin()
20646 
      if ftype == TType.STOP:
20647 
        break
20648 
      else:
20649 
        iprot.skip(ftype)
20650 
      iprot.readFieldEnd()
20651 
    iprot.readStructEnd()
20652 
 
20653 
  def write(self, oprot):
20654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20656 
      return
20657 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20658 
    oprot.writeFieldStop()
20659 
    oprot.writeStructEnd()
20660 
 
20661 
  def validate(self):
20662 
    return
20663 
 
20664 
 
20665 
  def __repr__(self):
20666 
    L = ['%s=%r' % (key, value)
20667 
      for key, value in self.__dict__.iteritems()]
20668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20669 
 
20670 
  def __eq__(self, other):
20671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20672 
 
20673 
  def __ne__(self, other):
20674 
    return not (self == other)
20675 
 
20676 
class getItemWiseRiskyOrdersCount_result:
20677 
  """
20678 
  Attributes:
20679 
   - success
20680 
  """
20681 
 
20682 
  thrift_spec = (
20683 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20684 
  )
20685 
 
20686 
  def __init__(self, success=None,):
20687 
    self.success = success
20688 
 
20689 
  def read(self, iprot):
20690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20692 
      return
20693 
    iprot.readStructBegin()
20694 
    while True:
20695 
      (fname, ftype, fid) = iprot.readFieldBegin()
20696 
      if ftype == TType.STOP:
20697 
        break
20698 
      if fid == 0:
20699 
        if ftype == TType.MAP:
20700 
          self.success = {}
6188 rajveer 20701 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20702 
          for _i482 in xrange(_size478):
20703 
            _key483 = iprot.readI64();
20704 
            _val484 = iprot.readI64();
20705 
            self.success[_key483] = _val484
4018 chandransh 20706 
          iprot.readMapEnd()
20707 
        else:
20708 
          iprot.skip(ftype)
20709 
      else:
20710 
        iprot.skip(ftype)
20711 
      iprot.readFieldEnd()
20712 
    iprot.readStructEnd()
20713 
 
20714 
  def write(self, oprot):
20715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20717 
      return
20718 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20719 
    if self.success is not None:
20720 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20721 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20722 
      for kiter485,viter486 in self.success.items():
20723 
        oprot.writeI64(kiter485)
20724 
        oprot.writeI64(viter486)
4018 chandransh 20725 
      oprot.writeMapEnd()
20726 
      oprot.writeFieldEnd()
20727 
    oprot.writeFieldStop()
20728 
    oprot.writeStructEnd()
20729 
 
20730 
  def validate(self):
20731 
    return
20732 
 
20733 
 
20734 
  def __repr__(self):
20735 
    L = ['%s=%r' % (key, value)
20736 
      for key, value in self.__dict__.iteritems()]
20737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20738 
 
20739 
  def __eq__(self, other):
20740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20741 
 
20742 
  def __ne__(self, other):
20743 
    return not (self == other)
4247 rajveer 20744 
 
4295 varun.gupt 20745 
class getOrdersForItemIds_args:
20746 
  """
20747 
  Attributes:
20748 
   - itemIds
20749 
  """
20750 
 
20751 
  thrift_spec = (
20752 
    None, # 0
20753 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20754 
  )
20755 
 
20756 
  def __init__(self, itemIds=None,):
20757 
    self.itemIds = itemIds
20758 
 
20759 
  def read(self, iprot):
20760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20762 
      return
20763 
    iprot.readStructBegin()
20764 
    while True:
20765 
      (fname, ftype, fid) = iprot.readFieldBegin()
20766 
      if ftype == TType.STOP:
20767 
        break
20768 
      if fid == 1:
20769 
        if ftype == TType.LIST:
20770 
          self.itemIds = []
6188 rajveer 20771 
          (_etype490, _size487) = iprot.readListBegin()
20772 
          for _i491 in xrange(_size487):
20773 
            _elem492 = iprot.readI64();
20774 
            self.itemIds.append(_elem492)
4295 varun.gupt 20775 
          iprot.readListEnd()
20776 
        else:
20777 
          iprot.skip(ftype)
20778 
      else:
20779 
        iprot.skip(ftype)
20780 
      iprot.readFieldEnd()
20781 
    iprot.readStructEnd()
20782 
 
20783 
  def write(self, oprot):
20784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20786 
      return
20787 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20788 
    if self.itemIds is not None:
20789 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20790 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20791 
      for iter493 in self.itemIds:
20792 
        oprot.writeI64(iter493)
4295 varun.gupt 20793 
      oprot.writeListEnd()
20794 
      oprot.writeFieldEnd()
20795 
    oprot.writeFieldStop()
20796 
    oprot.writeStructEnd()
20797 
 
20798 
  def validate(self):
20799 
    return
20800 
 
20801 
 
20802 
  def __repr__(self):
20803 
    L = ['%s=%r' % (key, value)
20804 
      for key, value in self.__dict__.iteritems()]
20805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20806 
 
20807 
  def __eq__(self, other):
20808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20809 
 
20810 
  def __ne__(self, other):
20811 
    return not (self == other)
20812 
 
20813 
class getOrdersForItemIds_result:
20814 
  """
20815 
  Attributes:
20816 
   - success
20817 
  """
20818 
 
20819 
  thrift_spec = (
20820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20821 
  )
20822 
 
20823 
  def __init__(self, success=None,):
20824 
    self.success = success
20825 
 
20826 
  def read(self, iprot):
20827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20829 
      return
20830 
    iprot.readStructBegin()
20831 
    while True:
20832 
      (fname, ftype, fid) = iprot.readFieldBegin()
20833 
      if ftype == TType.STOP:
20834 
        break
20835 
      if fid == 0:
20836 
        if ftype == TType.LIST:
20837 
          self.success = []
6188 rajveer 20838 
          (_etype497, _size494) = iprot.readListBegin()
20839 
          for _i498 in xrange(_size494):
20840 
            _elem499 = Order()
20841 
            _elem499.read(iprot)
20842 
            self.success.append(_elem499)
4295 varun.gupt 20843 
          iprot.readListEnd()
20844 
        else:
20845 
          iprot.skip(ftype)
20846 
      else:
20847 
        iprot.skip(ftype)
20848 
      iprot.readFieldEnd()
20849 
    iprot.readStructEnd()
20850 
 
20851 
  def write(self, oprot):
20852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20854 
      return
20855 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20856 
    if self.success is not None:
20857 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20858 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20859 
      for iter500 in self.success:
20860 
        iter500.write(oprot)
4295 varun.gupt 20861 
      oprot.writeListEnd()
20862 
      oprot.writeFieldEnd()
20863 
    oprot.writeFieldStop()
20864 
    oprot.writeStructEnd()
20865 
 
20866 
  def validate(self):
20867 
    return
20868 
 
20869 
 
20870 
  def __repr__(self):
20871 
    L = ['%s=%r' % (key, value)
20872 
      for key, value in self.__dict__.iteritems()]
20873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20874 
 
20875 
  def __eq__(self, other):
20876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20877 
 
20878 
  def __ne__(self, other):
20879 
    return not (self == other)
20880 
 
4247 rajveer 20881 
class markOrderCancellationRequestReceived_args:
20882 
  """
20883 
  Attributes:
20884 
   - orderId
20885 
  """
20886 
 
20887 
  thrift_spec = (
20888 
    None, # 0
20889 
    (1, TType.I64, 'orderId', None, None, ), # 1
20890 
  )
20891 
 
20892 
  def __init__(self, orderId=None,):
20893 
    self.orderId = orderId
20894 
 
20895 
  def read(self, iprot):
20896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20898 
      return
20899 
    iprot.readStructBegin()
20900 
    while True:
20901 
      (fname, ftype, fid) = iprot.readFieldBegin()
20902 
      if ftype == TType.STOP:
20903 
        break
20904 
      if fid == 1:
20905 
        if ftype == TType.I64:
20906 
          self.orderId = iprot.readI64();
20907 
        else:
20908 
          iprot.skip(ftype)
20909 
      else:
20910 
        iprot.skip(ftype)
20911 
      iprot.readFieldEnd()
20912 
    iprot.readStructEnd()
20913 
 
20914 
  def write(self, oprot):
20915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20917 
      return
20918 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20919 
    if self.orderId is not None:
20920 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20921 
      oprot.writeI64(self.orderId)
20922 
      oprot.writeFieldEnd()
20923 
    oprot.writeFieldStop()
20924 
    oprot.writeStructEnd()
20925 
 
20926 
  def validate(self):
20927 
    return
20928 
 
20929 
 
20930 
  def __repr__(self):
20931 
    L = ['%s=%r' % (key, value)
20932 
      for key, value in self.__dict__.iteritems()]
20933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20934 
 
20935 
  def __eq__(self, other):
20936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20937 
 
20938 
  def __ne__(self, other):
20939 
    return not (self == other)
20940 
 
20941 
class markOrderCancellationRequestReceived_result:
20942 
  """
20943 
  Attributes:
20944 
   - ex
20945 
  """
20946 
 
20947 
  thrift_spec = (
20948 
    None, # 0
20949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20950 
  )
20951 
 
20952 
  def __init__(self, ex=None,):
20953 
    self.ex = ex
20954 
 
20955 
  def read(self, iprot):
20956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20958 
      return
20959 
    iprot.readStructBegin()
20960 
    while True:
20961 
      (fname, ftype, fid) = iprot.readFieldBegin()
20962 
      if ftype == TType.STOP:
20963 
        break
20964 
      if fid == 1:
20965 
        if ftype == TType.STRUCT:
20966 
          self.ex = TransactionServiceException()
20967 
          self.ex.read(iprot)
20968 
        else:
20969 
          iprot.skip(ftype)
20970 
      else:
20971 
        iprot.skip(ftype)
20972 
      iprot.readFieldEnd()
20973 
    iprot.readStructEnd()
20974 
 
20975 
  def write(self, oprot):
20976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20978 
      return
20979 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20980 
    if self.ex is not None:
20981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20982 
      self.ex.write(oprot)
20983 
      oprot.writeFieldEnd()
20984 
    oprot.writeFieldStop()
20985 
    oprot.writeStructEnd()
20986 
 
20987 
  def validate(self):
20988 
    return
20989 
 
20990 
 
20991 
  def __repr__(self):
20992 
    L = ['%s=%r' % (key, value)
20993 
      for key, value in self.__dict__.iteritems()]
20994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20995 
 
20996 
  def __eq__(self, other):
20997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20998 
 
20999 
  def __ne__(self, other):
21000 
    return not (self == other)
21001 
 
21002 
class markOrderCancellationRequestConfirmed_args:
21003 
  """
21004 
  Attributes:
21005 
   - orderId
21006 
  """
21007 
 
21008 
  thrift_spec = (
21009 
    None, # 0
21010 
    (1, TType.I64, 'orderId', None, None, ), # 1
21011 
  )
21012 
 
21013 
  def __init__(self, orderId=None,):
21014 
    self.orderId = orderId
21015 
 
21016 
  def read(self, iprot):
21017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21019 
      return
21020 
    iprot.readStructBegin()
21021 
    while True:
21022 
      (fname, ftype, fid) = iprot.readFieldBegin()
21023 
      if ftype == TType.STOP:
21024 
        break
21025 
      if fid == 1:
21026 
        if ftype == TType.I64:
21027 
          self.orderId = iprot.readI64();
21028 
        else:
21029 
          iprot.skip(ftype)
21030 
      else:
21031 
        iprot.skip(ftype)
21032 
      iprot.readFieldEnd()
21033 
    iprot.readStructEnd()
21034 
 
21035 
  def write(self, oprot):
21036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21038 
      return
21039 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21040 
    if self.orderId is not None:
21041 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21042 
      oprot.writeI64(self.orderId)
21043 
      oprot.writeFieldEnd()
21044 
    oprot.writeFieldStop()
21045 
    oprot.writeStructEnd()
21046 
 
21047 
  def validate(self):
21048 
    return
21049 
 
21050 
 
21051 
  def __repr__(self):
21052 
    L = ['%s=%r' % (key, value)
21053 
      for key, value in self.__dict__.iteritems()]
21054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21055 
 
21056 
  def __eq__(self, other):
21057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21058 
 
21059 
  def __ne__(self, other):
21060 
    return not (self == other)
21061 
 
21062 
class markOrderCancellationRequestConfirmed_result:
21063 
  """
21064 
  Attributes:
21065 
   - ex
21066 
  """
21067 
 
21068 
  thrift_spec = (
21069 
    None, # 0
21070 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21071 
  )
21072 
 
21073 
  def __init__(self, ex=None,):
21074 
    self.ex = ex
21075 
 
21076 
  def read(self, iprot):
21077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21079 
      return
21080 
    iprot.readStructBegin()
21081 
    while True:
21082 
      (fname, ftype, fid) = iprot.readFieldBegin()
21083 
      if ftype == TType.STOP:
21084 
        break
21085 
      if fid == 1:
21086 
        if ftype == TType.STRUCT:
21087 
          self.ex = TransactionServiceException()
21088 
          self.ex.read(iprot)
21089 
        else:
21090 
          iprot.skip(ftype)
21091 
      else:
21092 
        iprot.skip(ftype)
21093 
      iprot.readFieldEnd()
21094 
    iprot.readStructEnd()
21095 
 
21096 
  def write(self, oprot):
21097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21099 
      return
21100 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21101 
    if self.ex is not None:
21102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21103 
      self.ex.write(oprot)
21104 
      oprot.writeFieldEnd()
21105 
    oprot.writeFieldStop()
21106 
    oprot.writeStructEnd()
21107 
 
21108 
  def validate(self):
21109 
    return
21110 
 
21111 
 
21112 
  def __repr__(self):
21113 
    L = ['%s=%r' % (key, value)
21114 
      for key, value in self.__dict__.iteritems()]
21115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21116 
 
21117 
  def __eq__(self, other):
21118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21119 
 
21120 
  def __ne__(self, other):
21121 
    return not (self == other)
21122 
 
21123 
class markOrderCancellationRequestDenied_args:
21124 
  """
21125 
  Attributes:
21126 
   - orderId
21127 
  """
21128 
 
21129 
  thrift_spec = (
21130 
    None, # 0
21131 
    (1, TType.I64, 'orderId', None, None, ), # 1
21132 
  )
21133 
 
21134 
  def __init__(self, orderId=None,):
21135 
    self.orderId = orderId
21136 
 
21137 
  def read(self, iprot):
21138 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21139 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21140 
      return
21141 
    iprot.readStructBegin()
21142 
    while True:
21143 
      (fname, ftype, fid) = iprot.readFieldBegin()
21144 
      if ftype == TType.STOP:
21145 
        break
21146 
      if fid == 1:
21147 
        if ftype == TType.I64:
21148 
          self.orderId = iprot.readI64();
21149 
        else:
21150 
          iprot.skip(ftype)
21151 
      else:
21152 
        iprot.skip(ftype)
21153 
      iprot.readFieldEnd()
21154 
    iprot.readStructEnd()
21155 
 
21156 
  def write(self, oprot):
21157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21159 
      return
21160 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21161 
    if self.orderId is not None:
21162 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21163 
      oprot.writeI64(self.orderId)
21164 
      oprot.writeFieldEnd()
21165 
    oprot.writeFieldStop()
21166 
    oprot.writeStructEnd()
21167 
 
21168 
  def validate(self):
21169 
    return
21170 
 
21171 
 
21172 
  def __repr__(self):
21173 
    L = ['%s=%r' % (key, value)
21174 
      for key, value in self.__dict__.iteritems()]
21175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21176 
 
21177 
  def __eq__(self, other):
21178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21179 
 
21180 
  def __ne__(self, other):
21181 
    return not (self == other)
21182 
 
21183 
class markOrderCancellationRequestDenied_result:
21184 
  """
21185 
  Attributes:
21186 
   - ex
21187 
  """
21188 
 
21189 
  thrift_spec = (
21190 
    None, # 0
21191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21192 
  )
21193 
 
21194 
  def __init__(self, ex=None,):
21195 
    self.ex = ex
21196 
 
21197 
  def read(self, iprot):
21198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21200 
      return
21201 
    iprot.readStructBegin()
21202 
    while True:
21203 
      (fname, ftype, fid) = iprot.readFieldBegin()
21204 
      if ftype == TType.STOP:
21205 
        break
21206 
      if fid == 1:
21207 
        if ftype == TType.STRUCT:
21208 
          self.ex = TransactionServiceException()
21209 
          self.ex.read(iprot)
21210 
        else:
21211 
          iprot.skip(ftype)
21212 
      else:
21213 
        iprot.skip(ftype)
21214 
      iprot.readFieldEnd()
21215 
    iprot.readStructEnd()
21216 
 
21217 
  def write(self, oprot):
21218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21220 
      return
21221 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21222 
    if self.ex is not None:
21223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21224 
      self.ex.write(oprot)
21225 
      oprot.writeFieldEnd()
21226 
    oprot.writeFieldStop()
21227 
    oprot.writeStructEnd()
21228 
 
21229 
  def validate(self):
21230 
    return
21231 
 
21232 
 
21233 
  def __repr__(self):
21234 
    L = ['%s=%r' % (key, value)
21235 
      for key, value in self.__dict__.iteritems()]
21236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21237 
 
21238 
  def __eq__(self, other):
21239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21240 
 
21241 
  def __ne__(self, other):
21242 
    return not (self == other)
21243 
 
4258 rajveer 21244 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21245 
  """
21246 
  Attributes:
4258 rajveer 21247 
   - transactionId
4247 rajveer 21248 
  """
21249 
 
21250 
  thrift_spec = (
21251 
    None, # 0
4258 rajveer 21252 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21253 
  )
21254 
 
4258 rajveer 21255 
  def __init__(self, transactionId=None,):
21256 
    self.transactionId = transactionId
4247 rajveer 21257 
 
21258 
  def read(self, iprot):
21259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21261 
      return
21262 
    iprot.readStructBegin()
21263 
    while True:
21264 
      (fname, ftype, fid) = iprot.readFieldBegin()
21265 
      if ftype == TType.STOP:
21266 
        break
21267 
      if fid == 1:
21268 
        if ftype == TType.I64:
4258 rajveer 21269 
          self.transactionId = iprot.readI64();
4247 rajveer 21270 
        else:
21271 
          iprot.skip(ftype)
21272 
      else:
21273 
        iprot.skip(ftype)
21274 
      iprot.readFieldEnd()
21275 
    iprot.readStructEnd()
21276 
 
21277 
  def write(self, oprot):
21278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21280 
      return
4258 rajveer 21281 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21282 
    if self.transactionId is not None:
21283 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21284 
      oprot.writeI64(self.transactionId)
4247 rajveer 21285 
      oprot.writeFieldEnd()
21286 
    oprot.writeFieldStop()
21287 
    oprot.writeStructEnd()
21288 
 
21289 
  def validate(self):
21290 
    return
21291 
 
21292 
 
21293 
  def __repr__(self):
21294 
    L = ['%s=%r' % (key, value)
21295 
      for key, value in self.__dict__.iteritems()]
21296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21297 
 
21298 
  def __eq__(self, other):
21299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21300 
 
21301 
  def __ne__(self, other):
21302 
    return not (self == other)
21303 
 
4258 rajveer 21304 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21305 
  """
21306 
  Attributes:
21307 
   - ex
21308 
  """
21309 
 
21310 
  thrift_spec = (
21311 
    None, # 0
21312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21313 
  )
21314 
 
21315 
  def __init__(self, ex=None,):
21316 
    self.ex = ex
21317 
 
21318 
  def read(self, iprot):
21319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21321 
      return
21322 
    iprot.readStructBegin()
21323 
    while True:
21324 
      (fname, ftype, fid) = iprot.readFieldBegin()
21325 
      if ftype == TType.STOP:
21326 
        break
21327 
      if fid == 1:
21328 
        if ftype == TType.STRUCT:
21329 
          self.ex = TransactionServiceException()
21330 
          self.ex.read(iprot)
21331 
        else:
21332 
          iprot.skip(ftype)
21333 
      else:
21334 
        iprot.skip(ftype)
21335 
      iprot.readFieldEnd()
21336 
    iprot.readStructEnd()
21337 
 
21338 
  def write(self, oprot):
21339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21341 
      return
4258 rajveer 21342 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21343 
    if self.ex is not None:
21344 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21345 
      self.ex.write(oprot)
21346 
      oprot.writeFieldEnd()
21347 
    oprot.writeFieldStop()
21348 
    oprot.writeStructEnd()
21349 
 
21350 
  def validate(self):
21351 
    return
21352 
 
21353 
 
21354 
  def __repr__(self):
21355 
    L = ['%s=%r' % (key, value)
21356 
      for key, value in self.__dict__.iteritems()]
21357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21358 
 
21359 
  def __eq__(self, other):
21360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21361 
 
21362 
  def __ne__(self, other):
21363 
    return not (self == other)
4259 anupam.sin 21364 
 
21365 
class refundTransaction_args:
21366 
  """
21367 
  Attributes:
21368 
   - transactionId
21369 
   - refundedBy
21370 
   - reason
21371 
  """
21372 
 
21373 
  thrift_spec = (
21374 
    None, # 0
21375 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21376 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21377 
    (3, TType.STRING, 'reason', None, None, ), # 3
21378 
  )
21379 
 
21380 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21381 
    self.transactionId = transactionId
21382 
    self.refundedBy = refundedBy
21383 
    self.reason = reason
21384 
 
21385 
  def read(self, iprot):
21386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21388 
      return
21389 
    iprot.readStructBegin()
21390 
    while True:
21391 
      (fname, ftype, fid) = iprot.readFieldBegin()
21392 
      if ftype == TType.STOP:
21393 
        break
21394 
      if fid == 1:
21395 
        if ftype == TType.I64:
21396 
          self.transactionId = iprot.readI64();
21397 
        else:
21398 
          iprot.skip(ftype)
21399 
      elif fid == 2:
21400 
        if ftype == TType.STRING:
21401 
          self.refundedBy = iprot.readString();
21402 
        else:
21403 
          iprot.skip(ftype)
21404 
      elif fid == 3:
21405 
        if ftype == TType.STRING:
21406 
          self.reason = iprot.readString();
21407 
        else:
21408 
          iprot.skip(ftype)
21409 
      else:
21410 
        iprot.skip(ftype)
21411 
      iprot.readFieldEnd()
21412 
    iprot.readStructEnd()
21413 
 
21414 
  def write(self, oprot):
21415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21417 
      return
21418 
    oprot.writeStructBegin('refundTransaction_args')
21419 
    if self.transactionId is not None:
21420 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21421 
      oprot.writeI64(self.transactionId)
21422 
      oprot.writeFieldEnd()
21423 
    if self.refundedBy is not None:
21424 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21425 
      oprot.writeString(self.refundedBy)
21426 
      oprot.writeFieldEnd()
21427 
    if self.reason is not None:
21428 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21429 
      oprot.writeString(self.reason)
21430 
      oprot.writeFieldEnd()
21431 
    oprot.writeFieldStop()
21432 
    oprot.writeStructEnd()
21433 
 
21434 
  def validate(self):
21435 
    return
21436 
 
21437 
 
21438 
  def __repr__(self):
21439 
    L = ['%s=%r' % (key, value)
21440 
      for key, value in self.__dict__.iteritems()]
21441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21442 
 
21443 
  def __eq__(self, other):
21444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21445 
 
21446 
  def __ne__(self, other):
21447 
    return not (self == other)
21448 
 
21449 
class refundTransaction_result:
21450 
  """
21451 
  Attributes:
21452 
   - ex
21453 
  """
21454 
 
21455 
  thrift_spec = (
21456 
    None, # 0
21457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21458 
  )
21459 
 
21460 
  def __init__(self, ex=None,):
21461 
    self.ex = ex
21462 
 
21463 
  def read(self, iprot):
21464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21466 
      return
21467 
    iprot.readStructBegin()
21468 
    while True:
21469 
      (fname, ftype, fid) = iprot.readFieldBegin()
21470 
      if ftype == TType.STOP:
21471 
        break
21472 
      if fid == 1:
21473 
        if ftype == TType.STRUCT:
21474 
          self.ex = TransactionServiceException()
21475 
          self.ex.read(iprot)
21476 
        else:
21477 
          iprot.skip(ftype)
21478 
      else:
21479 
        iprot.skip(ftype)
21480 
      iprot.readFieldEnd()
21481 
    iprot.readStructEnd()
21482 
 
21483 
  def write(self, oprot):
21484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21486 
      return
21487 
    oprot.writeStructBegin('refundTransaction_result')
21488 
    if self.ex is not None:
21489 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21490 
      self.ex.write(oprot)
21491 
      oprot.writeFieldEnd()
21492 
    oprot.writeFieldStop()
21493 
    oprot.writeStructEnd()
21494 
 
21495 
  def validate(self):
21496 
    return
21497 
 
21498 
 
21499 
  def __repr__(self):
21500 
    L = ['%s=%r' % (key, value)
21501 
      for key, value in self.__dict__.iteritems()]
21502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21503 
 
21504 
  def __eq__(self, other):
21505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21506 
 
21507 
  def __ne__(self, other):
21508 
    return not (self == other)
4285 rajveer 21509 
 
4324 mandeep.dh 21510 
class updateShipmentAddress_args:
21511 
  """
21512 
  Attributes:
21513 
   - orderId
21514 
   - addressId
21515 
  """
21516 
 
21517 
  thrift_spec = (
21518 
    None, # 0
21519 
    (1, TType.I64, 'orderId', None, None, ), # 1
21520 
    (2, TType.I64, 'addressId', None, None, ), # 2
21521 
  )
21522 
 
21523 
  def __init__(self, orderId=None, addressId=None,):
21524 
    self.orderId = orderId
21525 
    self.addressId = addressId
21526 
 
21527 
  def read(self, iprot):
21528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21530 
      return
21531 
    iprot.readStructBegin()
21532 
    while True:
21533 
      (fname, ftype, fid) = iprot.readFieldBegin()
21534 
      if ftype == TType.STOP:
21535 
        break
21536 
      if fid == 1:
21537 
        if ftype == TType.I64:
21538 
          self.orderId = iprot.readI64();
21539 
        else:
21540 
          iprot.skip(ftype)
21541 
      elif fid == 2:
21542 
        if ftype == TType.I64:
21543 
          self.addressId = iprot.readI64();
21544 
        else:
21545 
          iprot.skip(ftype)
21546 
      else:
21547 
        iprot.skip(ftype)
21548 
      iprot.readFieldEnd()
21549 
    iprot.readStructEnd()
21550 
 
21551 
  def write(self, oprot):
21552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21554 
      return
21555 
    oprot.writeStructBegin('updateShipmentAddress_args')
21556 
    if self.orderId is not None:
21557 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21558 
      oprot.writeI64(self.orderId)
21559 
      oprot.writeFieldEnd()
21560 
    if self.addressId is not None:
21561 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21562 
      oprot.writeI64(self.addressId)
21563 
      oprot.writeFieldEnd()
21564 
    oprot.writeFieldStop()
21565 
    oprot.writeStructEnd()
21566 
 
21567 
  def validate(self):
21568 
    return
21569 
 
21570 
 
21571 
  def __repr__(self):
21572 
    L = ['%s=%r' % (key, value)
21573 
      for key, value in self.__dict__.iteritems()]
21574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21575 
 
21576 
  def __eq__(self, other):
21577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21578 
 
21579 
  def __ne__(self, other):
21580 
    return not (self == other)
21581 
 
21582 
class updateShipmentAddress_result:
21583 
  """
21584 
  Attributes:
21585 
   - ex
21586 
  """
21587 
 
21588 
  thrift_spec = (
21589 
    None, # 0
21590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21591 
  )
21592 
 
21593 
  def __init__(self, ex=None,):
21594 
    self.ex = ex
21595 
 
21596 
  def read(self, iprot):
21597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21599 
      return
21600 
    iprot.readStructBegin()
21601 
    while True:
21602 
      (fname, ftype, fid) = iprot.readFieldBegin()
21603 
      if ftype == TType.STOP:
21604 
        break
21605 
      if fid == 1:
21606 
        if ftype == TType.STRUCT:
21607 
          self.ex = TransactionServiceException()
21608 
          self.ex.read(iprot)
21609 
        else:
21610 
          iprot.skip(ftype)
21611 
      else:
21612 
        iprot.skip(ftype)
21613 
      iprot.readFieldEnd()
21614 
    iprot.readStructEnd()
21615 
 
21616 
  def write(self, oprot):
21617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21619 
      return
21620 
    oprot.writeStructBegin('updateShipmentAddress_result')
21621 
    if self.ex is not None:
21622 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21623 
      self.ex.write(oprot)
21624 
      oprot.writeFieldEnd()
21625 
    oprot.writeFieldStop()
21626 
    oprot.writeStructEnd()
21627 
 
21628 
  def validate(self):
21629 
    return
21630 
 
21631 
 
21632 
  def __repr__(self):
21633 
    L = ['%s=%r' % (key, value)
21634 
      for key, value in self.__dict__.iteritems()]
21635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21636 
 
21637 
  def __eq__(self, other):
21638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21639 
 
21640 
  def __ne__(self, other):
21641 
    return not (self == other)
21642 
 
4285 rajveer 21643 
class acceptOrdersForItemId_args:
21644 
  """
21645 
  Attributes:
21646 
   - itemId
21647 
   - inventory
21648 
  """
21649 
 
21650 
  thrift_spec = (
21651 
    None, # 0
21652 
    (1, TType.I64, 'itemId', None, None, ), # 1
21653 
    (2, TType.I64, 'inventory', None, None, ), # 2
21654 
  )
21655 
 
21656 
  def __init__(self, itemId=None, inventory=None,):
21657 
    self.itemId = itemId
21658 
    self.inventory = inventory
21659 
 
21660 
  def read(self, iprot):
21661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21663 
      return
21664 
    iprot.readStructBegin()
21665 
    while True:
21666 
      (fname, ftype, fid) = iprot.readFieldBegin()
21667 
      if ftype == TType.STOP:
21668 
        break
21669 
      if fid == 1:
21670 
        if ftype == TType.I64:
21671 
          self.itemId = iprot.readI64();
21672 
        else:
21673 
          iprot.skip(ftype)
21674 
      elif fid == 2:
21675 
        if ftype == TType.I64:
21676 
          self.inventory = iprot.readI64();
21677 
        else:
21678 
          iprot.skip(ftype)
21679 
      else:
21680 
        iprot.skip(ftype)
21681 
      iprot.readFieldEnd()
21682 
    iprot.readStructEnd()
21683 
 
21684 
  def write(self, oprot):
21685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21687 
      return
21688 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21689 
    if self.itemId is not None:
21690 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21691 
      oprot.writeI64(self.itemId)
21692 
      oprot.writeFieldEnd()
21693 
    if self.inventory is not None:
21694 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21695 
      oprot.writeI64(self.inventory)
21696 
      oprot.writeFieldEnd()
21697 
    oprot.writeFieldStop()
21698 
    oprot.writeStructEnd()
21699 
 
21700 
  def validate(self):
21701 
    return
21702 
 
21703 
 
21704 
  def __repr__(self):
21705 
    L = ['%s=%r' % (key, value)
21706 
      for key, value in self.__dict__.iteritems()]
21707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21708 
 
21709 
  def __eq__(self, other):
21710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21711 
 
21712 
  def __ne__(self, other):
21713 
    return not (self == other)
21714 
 
21715 
class acceptOrdersForItemId_result:
21716 
  """
21717 
  Attributes:
21718 
   - success
21719 
   - ex
21720 
  """
21721 
 
21722 
  thrift_spec = (
21723 
    (0, TType.BOOL, 'success', None, None, ), # 0
21724 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21725 
  )
21726 
 
21727 
  def __init__(self, success=None, ex=None,):
21728 
    self.success = success
21729 
    self.ex = ex
21730 
 
21731 
  def read(self, iprot):
21732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21734 
      return
21735 
    iprot.readStructBegin()
21736 
    while True:
21737 
      (fname, ftype, fid) = iprot.readFieldBegin()
21738 
      if ftype == TType.STOP:
21739 
        break
21740 
      if fid == 0:
21741 
        if ftype == TType.BOOL:
21742 
          self.success = iprot.readBool();
21743 
        else:
21744 
          iprot.skip(ftype)
21745 
      elif fid == 1:
21746 
        if ftype == TType.STRUCT:
21747 
          self.ex = TransactionServiceException()
21748 
          self.ex.read(iprot)
21749 
        else:
21750 
          iprot.skip(ftype)
21751 
      else:
21752 
        iprot.skip(ftype)
21753 
      iprot.readFieldEnd()
21754 
    iprot.readStructEnd()
21755 
 
21756 
  def write(self, oprot):
21757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21759 
      return
21760 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21761 
    if self.success is not None:
21762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21763 
      oprot.writeBool(self.success)
21764 
      oprot.writeFieldEnd()
21765 
    if self.ex is not None:
21766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21767 
      self.ex.write(oprot)
21768 
      oprot.writeFieldEnd()
21769 
    oprot.writeFieldStop()
21770 
    oprot.writeStructEnd()
21771 
 
21772 
  def validate(self):
21773 
    return
21774 
 
21775 
 
21776 
  def __repr__(self):
21777 
    L = ['%s=%r' % (key, value)
21778 
      for key, value in self.__dict__.iteritems()]
21779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21780 
 
21781 
  def __eq__(self, other):
21782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21783 
 
21784 
  def __ne__(self, other):
21785 
    return not (self == other)
4303 rajveer 21786 
 
21787 
class markOrdersAsPORaised_args:
21788 
  """
21789 
  Attributes:
21790 
   - vendorId
21791 
   - itemId
21792 
   - quantity
21793 
   - estimate
4369 rajveer 21794 
   - isReminder
4303 rajveer 21795 
  """
21796 
 
21797 
  thrift_spec = (
21798 
    None, # 0
21799 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21800 
    (2, TType.I64, 'itemId', None, None, ), # 2
21801 
    (3, TType.I64, 'quantity', None, None, ), # 3
21802 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21803 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21804 
  )
21805 
 
4369 rajveer 21806 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21807 
    self.vendorId = vendorId
21808 
    self.itemId = itemId
21809 
    self.quantity = quantity
21810 
    self.estimate = estimate
4369 rajveer 21811 
    self.isReminder = isReminder
4303 rajveer 21812 
 
21813 
  def read(self, iprot):
21814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21816 
      return
21817 
    iprot.readStructBegin()
21818 
    while True:
21819 
      (fname, ftype, fid) = iprot.readFieldBegin()
21820 
      if ftype == TType.STOP:
21821 
        break
21822 
      if fid == 1:
21823 
        if ftype == TType.I64:
21824 
          self.vendorId = iprot.readI64();
21825 
        else:
21826 
          iprot.skip(ftype)
21827 
      elif fid == 2:
21828 
        if ftype == TType.I64:
21829 
          self.itemId = iprot.readI64();
21830 
        else:
21831 
          iprot.skip(ftype)
21832 
      elif fid == 3:
21833 
        if ftype == TType.I64:
21834 
          self.quantity = iprot.readI64();
21835 
        else:
21836 
          iprot.skip(ftype)
21837 
      elif fid == 4:
21838 
        if ftype == TType.I64:
21839 
          self.estimate = iprot.readI64();
21840 
        else:
21841 
          iprot.skip(ftype)
4369 rajveer 21842 
      elif fid == 5:
21843 
        if ftype == TType.BOOL:
21844 
          self.isReminder = iprot.readBool();
21845 
        else:
21846 
          iprot.skip(ftype)
4303 rajveer 21847 
      else:
21848 
        iprot.skip(ftype)
21849 
      iprot.readFieldEnd()
21850 
    iprot.readStructEnd()
21851 
 
21852 
  def write(self, oprot):
21853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21855 
      return
21856 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21857 
    if self.vendorId is not None:
21858 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21859 
      oprot.writeI64(self.vendorId)
21860 
      oprot.writeFieldEnd()
21861 
    if self.itemId is not None:
21862 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21863 
      oprot.writeI64(self.itemId)
21864 
      oprot.writeFieldEnd()
21865 
    if self.quantity is not None:
21866 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21867 
      oprot.writeI64(self.quantity)
21868 
      oprot.writeFieldEnd()
21869 
    if self.estimate is not None:
21870 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21871 
      oprot.writeI64(self.estimate)
21872 
      oprot.writeFieldEnd()
4369 rajveer 21873 
    if self.isReminder is not None:
21874 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21875 
      oprot.writeBool(self.isReminder)
21876 
      oprot.writeFieldEnd()
4303 rajveer 21877 
    oprot.writeFieldStop()
21878 
    oprot.writeStructEnd()
21879 
 
21880 
  def validate(self):
21881 
    return
21882 
 
21883 
 
21884 
  def __repr__(self):
21885 
    L = ['%s=%r' % (key, value)
21886 
      for key, value in self.__dict__.iteritems()]
21887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21888 
 
21889 
  def __eq__(self, other):
21890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21891 
 
21892 
  def __ne__(self, other):
21893 
    return not (self == other)
21894 
 
21895 
class markOrdersAsPORaised_result:
21896 
  """
21897 
  Attributes:
21898 
   - ex
21899 
  """
21900 
 
21901 
  thrift_spec = (
21902 
    None, # 0
21903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21904 
  )
21905 
 
21906 
  def __init__(self, ex=None,):
21907 
    self.ex = ex
21908 
 
21909 
  def read(self, iprot):
21910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21912 
      return
21913 
    iprot.readStructBegin()
21914 
    while True:
21915 
      (fname, ftype, fid) = iprot.readFieldBegin()
21916 
      if ftype == TType.STOP:
21917 
        break
21918 
      if fid == 1:
21919 
        if ftype == TType.STRUCT:
21920 
          self.ex = TransactionServiceException()
21921 
          self.ex.read(iprot)
21922 
        else:
21923 
          iprot.skip(ftype)
21924 
      else:
21925 
        iprot.skip(ftype)
21926 
      iprot.readFieldEnd()
21927 
    iprot.readStructEnd()
21928 
 
21929 
  def write(self, oprot):
21930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21932 
      return
21933 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21934 
    if self.ex is not None:
21935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21936 
      self.ex.write(oprot)
21937 
      oprot.writeFieldEnd()
21938 
    oprot.writeFieldStop()
21939 
    oprot.writeStructEnd()
21940 
 
21941 
  def validate(self):
21942 
    return
21943 
 
21944 
 
21945 
  def __repr__(self):
21946 
    L = ['%s=%r' % (key, value)
21947 
      for key, value in self.__dict__.iteritems()]
21948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21949 
 
21950 
  def __eq__(self, other):
21951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21952 
 
21953 
  def __ne__(self, other):
21954 
    return not (self == other)
21955 
 
21956 
class markOrdersAsReversalInitiated_args:
21957 
  """
21958 
  Attributes:
21959 
   - vendorId
21960 
   - itemId
21961 
   - quantity
21962 
   - estimate
4369 rajveer 21963 
   - isReminder
4303 rajveer 21964 
  """
21965 
 
21966 
  thrift_spec = (
21967 
    None, # 0
21968 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21969 
    (2, TType.I64, 'itemId', None, None, ), # 2
21970 
    (3, TType.I64, 'quantity', None, None, ), # 3
21971 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21972 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21973 
  )
21974 
 
4369 rajveer 21975 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21976 
    self.vendorId = vendorId
21977 
    self.itemId = itemId
21978 
    self.quantity = quantity
21979 
    self.estimate = estimate
4369 rajveer 21980 
    self.isReminder = isReminder
4303 rajveer 21981 
 
21982 
  def read(self, iprot):
21983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21985 
      return
21986 
    iprot.readStructBegin()
21987 
    while True:
21988 
      (fname, ftype, fid) = iprot.readFieldBegin()
21989 
      if ftype == TType.STOP:
21990 
        break
21991 
      if fid == 1:
21992 
        if ftype == TType.I64:
21993 
          self.vendorId = iprot.readI64();
21994 
        else:
21995 
          iprot.skip(ftype)
21996 
      elif fid == 2:
21997 
        if ftype == TType.I64:
21998 
          self.itemId = iprot.readI64();
21999 
        else:
22000 
          iprot.skip(ftype)
22001 
      elif fid == 3:
22002 
        if ftype == TType.I64:
22003 
          self.quantity = iprot.readI64();
22004 
        else:
22005 
          iprot.skip(ftype)
22006 
      elif fid == 4:
22007 
        if ftype == TType.I64:
22008 
          self.estimate = iprot.readI64();
22009 
        else:
22010 
          iprot.skip(ftype)
4369 rajveer 22011 
      elif fid == 5:
22012 
        if ftype == TType.BOOL:
22013 
          self.isReminder = iprot.readBool();
22014 
        else:
22015 
          iprot.skip(ftype)
4303 rajveer 22016 
      else:
22017 
        iprot.skip(ftype)
22018 
      iprot.readFieldEnd()
22019 
    iprot.readStructEnd()
22020 
 
22021 
  def write(self, oprot):
22022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22024 
      return
22025 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22026 
    if self.vendorId is not None:
22027 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22028 
      oprot.writeI64(self.vendorId)
22029 
      oprot.writeFieldEnd()
22030 
    if self.itemId is not None:
22031 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22032 
      oprot.writeI64(self.itemId)
22033 
      oprot.writeFieldEnd()
22034 
    if self.quantity is not None:
22035 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22036 
      oprot.writeI64(self.quantity)
22037 
      oprot.writeFieldEnd()
22038 
    if self.estimate is not None:
22039 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22040 
      oprot.writeI64(self.estimate)
22041 
      oprot.writeFieldEnd()
4369 rajveer 22042 
    if self.isReminder is not None:
22043 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22044 
      oprot.writeBool(self.isReminder)
22045 
      oprot.writeFieldEnd()
4303 rajveer 22046 
    oprot.writeFieldStop()
22047 
    oprot.writeStructEnd()
22048 
 
22049 
  def validate(self):
22050 
    return
22051 
 
22052 
 
22053 
  def __repr__(self):
22054 
    L = ['%s=%r' % (key, value)
22055 
      for key, value in self.__dict__.iteritems()]
22056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22057 
 
22058 
  def __eq__(self, other):
22059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22060 
 
22061 
  def __ne__(self, other):
22062 
    return not (self == other)
22063 
 
22064 
class markOrdersAsReversalInitiated_result:
22065 
  """
22066 
  Attributes:
22067 
   - ex
22068 
  """
22069 
 
22070 
  thrift_spec = (
22071 
    None, # 0
22072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22073 
  )
22074 
 
22075 
  def __init__(self, ex=None,):
22076 
    self.ex = ex
22077 
 
22078 
  def read(self, iprot):
22079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22081 
      return
22082 
    iprot.readStructBegin()
22083 
    while True:
22084 
      (fname, ftype, fid) = iprot.readFieldBegin()
22085 
      if ftype == TType.STOP:
22086 
        break
22087 
      if fid == 1:
22088 
        if ftype == TType.STRUCT:
22089 
          self.ex = TransactionServiceException()
22090 
          self.ex.read(iprot)
22091 
        else:
22092 
          iprot.skip(ftype)
22093 
      else:
22094 
        iprot.skip(ftype)
22095 
      iprot.readFieldEnd()
22096 
    iprot.readStructEnd()
22097 
 
22098 
  def write(self, oprot):
22099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22101 
      return
22102 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22103 
    if self.ex is not None:
22104 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22105 
      self.ex.write(oprot)
22106 
      oprot.writeFieldEnd()
22107 
    oprot.writeFieldStop()
22108 
    oprot.writeStructEnd()
22109 
 
22110 
  def validate(self):
22111 
    return
22112 
 
22113 
 
22114 
  def __repr__(self):
22115 
    L = ['%s=%r' % (key, value)
22116 
      for key, value in self.__dict__.iteritems()]
22117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22118 
 
22119 
  def __eq__(self, other):
22120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22121 
 
22122 
  def __ne__(self, other):
22123 
    return not (self == other)
22124 
 
22125 
class markOrdersAsNotAvailabke_args:
22126 
  """
22127 
  Attributes:
22128 
   - vendorId
22129 
   - itemId
22130 
   - quantity
22131 
   - estimate
4369 rajveer 22132 
   - isReminder
4303 rajveer 22133 
  """
22134 
 
22135 
  thrift_spec = (
22136 
    None, # 0
22137 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22138 
    (2, TType.I64, 'itemId', None, None, ), # 2
22139 
    (3, TType.I64, 'quantity', None, None, ), # 3
22140 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22141 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22142 
  )
22143 
 
4369 rajveer 22144 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22145 
    self.vendorId = vendorId
22146 
    self.itemId = itemId
22147 
    self.quantity = quantity
22148 
    self.estimate = estimate
4369 rajveer 22149 
    self.isReminder = isReminder
4303 rajveer 22150 
 
22151 
  def read(self, iprot):
22152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22154 
      return
22155 
    iprot.readStructBegin()
22156 
    while True:
22157 
      (fname, ftype, fid) = iprot.readFieldBegin()
22158 
      if ftype == TType.STOP:
22159 
        break
22160 
      if fid == 1:
22161 
        if ftype == TType.I64:
22162 
          self.vendorId = iprot.readI64();
22163 
        else:
22164 
          iprot.skip(ftype)
22165 
      elif fid == 2:
22166 
        if ftype == TType.I64:
22167 
          self.itemId = iprot.readI64();
22168 
        else:
22169 
          iprot.skip(ftype)
22170 
      elif fid == 3:
22171 
        if ftype == TType.I64:
22172 
          self.quantity = iprot.readI64();
22173 
        else:
22174 
          iprot.skip(ftype)
22175 
      elif fid == 4:
22176 
        if ftype == TType.I64:
22177 
          self.estimate = iprot.readI64();
22178 
        else:
22179 
          iprot.skip(ftype)
4369 rajveer 22180 
      elif fid == 5:
22181 
        if ftype == TType.BOOL:
22182 
          self.isReminder = iprot.readBool();
22183 
        else:
22184 
          iprot.skip(ftype)
4303 rajveer 22185 
      else:
22186 
        iprot.skip(ftype)
22187 
      iprot.readFieldEnd()
22188 
    iprot.readStructEnd()
22189 
 
22190 
  def write(self, oprot):
22191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22193 
      return
22194 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22195 
    if self.vendorId is not None:
22196 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22197 
      oprot.writeI64(self.vendorId)
22198 
      oprot.writeFieldEnd()
22199 
    if self.itemId is not None:
22200 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22201 
      oprot.writeI64(self.itemId)
22202 
      oprot.writeFieldEnd()
22203 
    if self.quantity is not None:
22204 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22205 
      oprot.writeI64(self.quantity)
22206 
      oprot.writeFieldEnd()
22207 
    if self.estimate is not None:
22208 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22209 
      oprot.writeI64(self.estimate)
22210 
      oprot.writeFieldEnd()
4369 rajveer 22211 
    if self.isReminder is not None:
22212 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22213 
      oprot.writeBool(self.isReminder)
22214 
      oprot.writeFieldEnd()
4303 rajveer 22215 
    oprot.writeFieldStop()
22216 
    oprot.writeStructEnd()
22217 
 
22218 
  def validate(self):
22219 
    return
22220 
 
22221 
 
22222 
  def __repr__(self):
22223 
    L = ['%s=%r' % (key, value)
22224 
      for key, value in self.__dict__.iteritems()]
22225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22226 
 
22227 
  def __eq__(self, other):
22228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22229 
 
22230 
  def __ne__(self, other):
22231 
    return not (self == other)
22232 
 
22233 
class markOrdersAsNotAvailabke_result:
22234 
  """
22235 
  Attributes:
22236 
   - ex
22237 
  """
22238 
 
22239 
  thrift_spec = (
22240 
    None, # 0
22241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22242 
  )
22243 
 
22244 
  def __init__(self, ex=None,):
22245 
    self.ex = ex
22246 
 
22247 
  def read(self, iprot):
22248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22250 
      return
22251 
    iprot.readStructBegin()
22252 
    while True:
22253 
      (fname, ftype, fid) = iprot.readFieldBegin()
22254 
      if ftype == TType.STOP:
22255 
        break
22256 
      if fid == 1:
22257 
        if ftype == TType.STRUCT:
22258 
          self.ex = TransactionServiceException()
22259 
          self.ex.read(iprot)
22260 
        else:
22261 
          iprot.skip(ftype)
22262 
      else:
22263 
        iprot.skip(ftype)
22264 
      iprot.readFieldEnd()
22265 
    iprot.readStructEnd()
22266 
 
22267 
  def write(self, oprot):
22268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22270 
      return
22271 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22272 
    if self.ex is not None:
22273 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22274 
      self.ex.write(oprot)
22275 
      oprot.writeFieldEnd()
22276 
    oprot.writeFieldStop()
22277 
    oprot.writeStructEnd()
22278 
 
22279 
  def validate(self):
22280 
    return
22281 
 
22282 
 
22283 
  def __repr__(self):
22284 
    L = ['%s=%r' % (key, value)
22285 
      for key, value in self.__dict__.iteritems()]
22286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22287 
 
22288 
  def __eq__(self, other):
22289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22290 
 
22291 
  def __ne__(self, other):
22292 
    return not (self == other)
4369 rajveer 22293 
 
22294 
class markOrdersAsTimeout_args:
22295 
  """
22296 
  Attributes:
22297 
   - vendorId
22298 
  """
22299 
 
22300 
  thrift_spec = (
22301 
    None, # 0
22302 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22303 
  )
22304 
 
22305 
  def __init__(self, vendorId=None,):
22306 
    self.vendorId = vendorId
22307 
 
22308 
  def read(self, iprot):
22309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22311 
      return
22312 
    iprot.readStructBegin()
22313 
    while True:
22314 
      (fname, ftype, fid) = iprot.readFieldBegin()
22315 
      if ftype == TType.STOP:
22316 
        break
22317 
      if fid == 1:
22318 
        if ftype == TType.I64:
22319 
          self.vendorId = iprot.readI64();
22320 
        else:
22321 
          iprot.skip(ftype)
22322 
      else:
22323 
        iprot.skip(ftype)
22324 
      iprot.readFieldEnd()
22325 
    iprot.readStructEnd()
22326 
 
22327 
  def write(self, oprot):
22328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22330 
      return
22331 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22332 
    if self.vendorId is not None:
22333 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22334 
      oprot.writeI64(self.vendorId)
22335 
      oprot.writeFieldEnd()
22336 
    oprot.writeFieldStop()
22337 
    oprot.writeStructEnd()
22338 
 
22339 
  def validate(self):
22340 
    return
22341 
 
22342 
 
22343 
  def __repr__(self):
22344 
    L = ['%s=%r' % (key, value)
22345 
      for key, value in self.__dict__.iteritems()]
22346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22347 
 
22348 
  def __eq__(self, other):
22349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22350 
 
22351 
  def __ne__(self, other):
22352 
    return not (self == other)
22353 
 
22354 
class markOrdersAsTimeout_result:
22355 
  """
22356 
  Attributes:
22357 
   - success
22358 
   - ex
22359 
  """
22360 
 
22361 
  thrift_spec = (
22362 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22364 
  )
22365 
 
22366 
  def __init__(self, success=None, ex=None,):
22367 
    self.success = success
22368 
    self.ex = ex
22369 
 
22370 
  def read(self, iprot):
22371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22373 
      return
22374 
    iprot.readStructBegin()
22375 
    while True:
22376 
      (fname, ftype, fid) = iprot.readFieldBegin()
22377 
      if ftype == TType.STOP:
22378 
        break
22379 
      if fid == 0:
22380 
        if ftype == TType.MAP:
22381 
          self.success = {}
6188 rajveer 22382 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22383 
          for _i505 in xrange(_size501):
22384 
            _key506 = iprot.readI32();
22385 
            _val507 = TimeoutSummary()
22386 
            _val507.read(iprot)
22387 
            self.success[_key506] = _val507
4369 rajveer 22388 
          iprot.readMapEnd()
22389 
        else:
22390 
          iprot.skip(ftype)
22391 
      elif fid == 1:
22392 
        if ftype == TType.STRUCT:
22393 
          self.ex = TransactionServiceException()
22394 
          self.ex.read(iprot)
22395 
        else:
22396 
          iprot.skip(ftype)
22397 
      else:
22398 
        iprot.skip(ftype)
22399 
      iprot.readFieldEnd()
22400 
    iprot.readStructEnd()
22401 
 
22402 
  def write(self, oprot):
22403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22405 
      return
22406 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22407 
    if self.success is not None:
22408 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22409 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22410 
      for kiter508,viter509 in self.success.items():
22411 
        oprot.writeI32(kiter508)
22412 
        viter509.write(oprot)
4369 rajveer 22413 
      oprot.writeMapEnd()
22414 
      oprot.writeFieldEnd()
22415 
    if self.ex is not None:
22416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22417 
      self.ex.write(oprot)
22418 
      oprot.writeFieldEnd()
22419 
    oprot.writeFieldStop()
22420 
    oprot.writeStructEnd()
22421 
 
22422 
  def validate(self):
22423 
    return
22424 
 
22425 
 
22426 
  def __repr__(self):
22427 
    L = ['%s=%r' % (key, value)
22428 
      for key, value in self.__dict__.iteritems()]
22429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22430 
 
22431 
  def __eq__(self, other):
22432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22433 
 
22434 
  def __ne__(self, other):
22435 
    return not (self == other)
4386 anupam.sin 22436 
 
4662 rajveer 22437 
class markOrderAsLostInTransit_args:
22438 
  """
22439 
  Attributes:
22440 
   - orderId
22441 
  """
22442 
 
22443 
  thrift_spec = (
22444 
    None, # 0
22445 
    (1, TType.I64, 'orderId', None, None, ), # 1
22446 
  )
22447 
 
22448 
  def __init__(self, orderId=None,):
22449 
    self.orderId = orderId
22450 
 
22451 
  def read(self, iprot):
22452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22454 
      return
22455 
    iprot.readStructBegin()
22456 
    while True:
22457 
      (fname, ftype, fid) = iprot.readFieldBegin()
22458 
      if ftype == TType.STOP:
22459 
        break
22460 
      if fid == 1:
22461 
        if ftype == TType.I64:
22462 
          self.orderId = iprot.readI64();
22463 
        else:
22464 
          iprot.skip(ftype)
22465 
      else:
22466 
        iprot.skip(ftype)
22467 
      iprot.readFieldEnd()
22468 
    iprot.readStructEnd()
22469 
 
22470 
  def write(self, oprot):
22471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22473 
      return
22474 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22475 
    if self.orderId is not None:
22476 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22477 
      oprot.writeI64(self.orderId)
22478 
      oprot.writeFieldEnd()
22479 
    oprot.writeFieldStop()
22480 
    oprot.writeStructEnd()
22481 
 
22482 
  def validate(self):
22483 
    return
22484 
 
22485 
 
22486 
  def __repr__(self):
22487 
    L = ['%s=%r' % (key, value)
22488 
      for key, value in self.__dict__.iteritems()]
22489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22490 
 
22491 
  def __eq__(self, other):
22492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22493 
 
22494 
  def __ne__(self, other):
22495 
    return not (self == other)
22496 
 
22497 
class markOrderAsLostInTransit_result:
22498 
  """
22499 
  Attributes:
22500 
   - success
22501 
   - ex
22502 
  """
22503 
 
22504 
  thrift_spec = (
22505 
    (0, TType.BOOL, 'success', None, None, ), # 0
22506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22507 
  )
22508 
 
22509 
  def __init__(self, success=None, ex=None,):
22510 
    self.success = success
22511 
    self.ex = ex
22512 
 
22513 
  def read(self, iprot):
22514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22516 
      return
22517 
    iprot.readStructBegin()
22518 
    while True:
22519 
      (fname, ftype, fid) = iprot.readFieldBegin()
22520 
      if ftype == TType.STOP:
22521 
        break
22522 
      if fid == 0:
22523 
        if ftype == TType.BOOL:
22524 
          self.success = iprot.readBool();
22525 
        else:
22526 
          iprot.skip(ftype)
22527 
      elif fid == 1:
22528 
        if ftype == TType.STRUCT:
22529 
          self.ex = TransactionServiceException()
22530 
          self.ex.read(iprot)
22531 
        else:
22532 
          iprot.skip(ftype)
22533 
      else:
22534 
        iprot.skip(ftype)
22535 
      iprot.readFieldEnd()
22536 
    iprot.readStructEnd()
22537 
 
22538 
  def write(self, oprot):
22539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22541 
      return
22542 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22543 
    if self.success is not None:
22544 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22545 
      oprot.writeBool(self.success)
22546 
      oprot.writeFieldEnd()
22547 
    if self.ex is not None:
22548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22549 
      self.ex.write(oprot)
22550 
      oprot.writeFieldEnd()
22551 
    oprot.writeFieldStop()
22552 
    oprot.writeStructEnd()
22553 
 
22554 
  def validate(self):
22555 
    return
22556 
 
22557 
 
22558 
  def __repr__(self):
22559 
    L = ['%s=%r' % (key, value)
22560 
      for key, value in self.__dict__.iteritems()]
22561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22562 
 
22563 
  def __eq__(self, other):
22564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22565 
 
22566 
  def __ne__(self, other):
22567 
    return not (self == other)
22568 
 
4386 anupam.sin 22569 
class getOrderForAwb_args:
22570 
  """
22571 
  Attributes:
22572 
   - awb
22573 
  """
22574 
 
22575 
  thrift_spec = (
22576 
    None, # 0
22577 
    (1, TType.STRING, 'awb', None, None, ), # 1
22578 
  )
22579 
 
22580 
  def __init__(self, awb=None,):
22581 
    self.awb = awb
22582 
 
22583 
  def read(self, iprot):
22584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22586 
      return
22587 
    iprot.readStructBegin()
22588 
    while True:
22589 
      (fname, ftype, fid) = iprot.readFieldBegin()
22590 
      if ftype == TType.STOP:
22591 
        break
22592 
      if fid == 1:
22593 
        if ftype == TType.STRING:
22594 
          self.awb = iprot.readString();
22595 
        else:
22596 
          iprot.skip(ftype)
22597 
      else:
22598 
        iprot.skip(ftype)
22599 
      iprot.readFieldEnd()
22600 
    iprot.readStructEnd()
22601 
 
22602 
  def write(self, oprot):
22603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22605 
      return
22606 
    oprot.writeStructBegin('getOrderForAwb_args')
22607 
    if self.awb is not None:
22608 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22609 
      oprot.writeString(self.awb)
22610 
      oprot.writeFieldEnd()
22611 
    oprot.writeFieldStop()
22612 
    oprot.writeStructEnd()
22613 
 
22614 
  def validate(self):
22615 
    return
22616 
 
22617 
 
22618 
  def __repr__(self):
22619 
    L = ['%s=%r' % (key, value)
22620 
      for key, value in self.__dict__.iteritems()]
22621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22622 
 
22623 
  def __eq__(self, other):
22624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22625 
 
22626 
  def __ne__(self, other):
22627 
    return not (self == other)
22628 
 
22629 
class getOrderForAwb_result:
22630 
  """
22631 
  Attributes:
22632 
   - success
22633 
   - ex
22634 
  """
22635 
 
22636 
  thrift_spec = (
22637 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22638 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22639 
  )
22640 
 
22641 
  def __init__(self, success=None, ex=None,):
22642 
    self.success = success
22643 
    self.ex = ex
22644 
 
22645 
  def read(self, iprot):
22646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22648 
      return
22649 
    iprot.readStructBegin()
22650 
    while True:
22651 
      (fname, ftype, fid) = iprot.readFieldBegin()
22652 
      if ftype == TType.STOP:
22653 
        break
22654 
      if fid == 0:
22655 
        if ftype == TType.STRUCT:
22656 
          self.success = Order()
22657 
          self.success.read(iprot)
22658 
        else:
22659 
          iprot.skip(ftype)
22660 
      elif fid == 1:
22661 
        if ftype == TType.STRUCT:
22662 
          self.ex = TransactionServiceException()
22663 
          self.ex.read(iprot)
22664 
        else:
22665 
          iprot.skip(ftype)
22666 
      else:
22667 
        iprot.skip(ftype)
22668 
      iprot.readFieldEnd()
22669 
    iprot.readStructEnd()
22670 
 
22671 
  def write(self, oprot):
22672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22674 
      return
22675 
    oprot.writeStructBegin('getOrderForAwb_result')
22676 
    if self.success is not None:
22677 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22678 
      self.success.write(oprot)
22679 
      oprot.writeFieldEnd()
22680 
    if self.ex is not None:
22681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22682 
      self.ex.write(oprot)
22683 
      oprot.writeFieldEnd()
22684 
    oprot.writeFieldStop()
22685 
    oprot.writeStructEnd()
22686 
 
22687 
  def validate(self):
22688 
    return
22689 
 
22690 
 
22691 
  def __repr__(self):
22692 
    L = ['%s=%r' % (key, value)
22693 
      for key, value in self.__dict__.iteritems()]
22694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22695 
 
22696 
  def __eq__(self, other):
22697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22698 
 
22699 
  def __ne__(self, other):
22700 
    return not (self == other)
4506 phani.kuma 22701 
 
22702 
class getOrdersForProviderForStatus_args:
22703 
  """
22704 
  Attributes:
22705 
   - logistics_provider_id
4910 phani.kuma 22706 
   - order_status_list
4506 phani.kuma 22707 
  """
22708 
 
22709 
  thrift_spec = (
22710 
    None, # 0
22711 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22712 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22713 
  )
22714 
 
4910 phani.kuma 22715 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22716 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22717 
    self.order_status_list = order_status_list
4506 phani.kuma 22718 
 
22719 
  def read(self, iprot):
22720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22722 
      return
22723 
    iprot.readStructBegin()
22724 
    while True:
22725 
      (fname, ftype, fid) = iprot.readFieldBegin()
22726 
      if ftype == TType.STOP:
22727 
        break
22728 
      if fid == 1:
22729 
        if ftype == TType.I64:
22730 
          self.logistics_provider_id = iprot.readI64();
22731 
        else:
22732 
          iprot.skip(ftype)
22733 
      elif fid == 2:
4910 phani.kuma 22734 
        if ftype == TType.LIST:
22735 
          self.order_status_list = []
6188 rajveer 22736 
          (_etype513, _size510) = iprot.readListBegin()
22737 
          for _i514 in xrange(_size510):
22738 
            _elem515 = iprot.readI32();
22739 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22740 
          iprot.readListEnd()
4506 phani.kuma 22741 
        else:
22742 
          iprot.skip(ftype)
22743 
      else:
22744 
        iprot.skip(ftype)
22745 
      iprot.readFieldEnd()
22746 
    iprot.readStructEnd()
22747 
 
22748 
  def write(self, oprot):
22749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22751 
      return
22752 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22753 
    if self.logistics_provider_id is not None:
22754 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22755 
      oprot.writeI64(self.logistics_provider_id)
22756 
      oprot.writeFieldEnd()
4910 phani.kuma 22757 
    if self.order_status_list is not None:
22758 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22759 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22760 
      for iter516 in self.order_status_list:
22761 
        oprot.writeI32(iter516)
4910 phani.kuma 22762 
      oprot.writeListEnd()
4506 phani.kuma 22763 
      oprot.writeFieldEnd()
22764 
    oprot.writeFieldStop()
22765 
    oprot.writeStructEnd()
22766 
 
22767 
  def validate(self):
22768 
    return
22769 
 
22770 
 
22771 
  def __repr__(self):
22772 
    L = ['%s=%r' % (key, value)
22773 
      for key, value in self.__dict__.iteritems()]
22774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22775 
 
22776 
  def __eq__(self, other):
22777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22778 
 
22779 
  def __ne__(self, other):
22780 
    return not (self == other)
22781 
 
22782 
class getOrdersForProviderForStatus_result:
22783 
  """
22784 
  Attributes:
22785 
   - success
22786 
   - ex
22787 
  """
22788 
 
22789 
  thrift_spec = (
22790 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22792 
  )
22793 
 
22794 
  def __init__(self, success=None, ex=None,):
22795 
    self.success = success
22796 
    self.ex = ex
22797 
 
22798 
  def read(self, iprot):
22799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22801 
      return
22802 
    iprot.readStructBegin()
22803 
    while True:
22804 
      (fname, ftype, fid) = iprot.readFieldBegin()
22805 
      if ftype == TType.STOP:
22806 
        break
22807 
      if fid == 0:
22808 
        if ftype == TType.LIST:
22809 
          self.success = []
6188 rajveer 22810 
          (_etype520, _size517) = iprot.readListBegin()
22811 
          for _i521 in xrange(_size517):
22812 
            _elem522 = Order()
22813 
            _elem522.read(iprot)
22814 
            self.success.append(_elem522)
4506 phani.kuma 22815 
          iprot.readListEnd()
22816 
        else:
22817 
          iprot.skip(ftype)
22818 
      elif fid == 1:
22819 
        if ftype == TType.STRUCT:
22820 
          self.ex = TransactionServiceException()
22821 
          self.ex.read(iprot)
22822 
        else:
22823 
          iprot.skip(ftype)
22824 
      else:
22825 
        iprot.skip(ftype)
22826 
      iprot.readFieldEnd()
22827 
    iprot.readStructEnd()
22828 
 
22829 
  def write(self, oprot):
22830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22832 
      return
22833 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22834 
    if self.success is not None:
22835 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22836 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22837 
      for iter523 in self.success:
22838 
        iter523.write(oprot)
4506 phani.kuma 22839 
      oprot.writeListEnd()
22840 
      oprot.writeFieldEnd()
22841 
    if self.ex is not None:
22842 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22843 
      self.ex.write(oprot)
22844 
      oprot.writeFieldEnd()
22845 
    oprot.writeFieldStop()
22846 
    oprot.writeStructEnd()
22847 
 
22848 
  def validate(self):
22849 
    return
22850 
 
22851 
 
22852 
  def __repr__(self):
22853 
    L = ['%s=%r' % (key, value)
22854 
      for key, value in self.__dict__.iteritems()]
22855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22856 
 
22857 
  def __eq__(self, other):
22858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22859 
 
22860 
  def __ne__(self, other):
22861 
    return not (self == other)
4600 varun.gupt 22862 
 
22863 
class getBilledOrdersForVendor_args:
22864 
  """
22865 
  Attributes:
22866 
   - vendorId
22867 
   - billingDateFrom
22868 
   - billingDateTo
22869 
  """
22870 
 
22871 
  thrift_spec = (
22872 
    None, # 0
22873 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22874 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22875 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22876 
  )
22877 
 
22878 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22879 
    self.vendorId = vendorId
22880 
    self.billingDateFrom = billingDateFrom
22881 
    self.billingDateTo = billingDateTo
22882 
 
22883 
  def read(self, iprot):
22884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22886 
      return
22887 
    iprot.readStructBegin()
22888 
    while True:
22889 
      (fname, ftype, fid) = iprot.readFieldBegin()
22890 
      if ftype == TType.STOP:
22891 
        break
22892 
      if fid == 1:
22893 
        if ftype == TType.I64:
22894 
          self.vendorId = iprot.readI64();
22895 
        else:
22896 
          iprot.skip(ftype)
22897 
      elif fid == 2:
22898 
        if ftype == TType.I64:
22899 
          self.billingDateFrom = iprot.readI64();
22900 
        else:
22901 
          iprot.skip(ftype)
22902 
      elif fid == 3:
22903 
        if ftype == TType.I64:
22904 
          self.billingDateTo = iprot.readI64();
22905 
        else:
22906 
          iprot.skip(ftype)
22907 
      else:
22908 
        iprot.skip(ftype)
22909 
      iprot.readFieldEnd()
22910 
    iprot.readStructEnd()
22911 
 
22912 
  def write(self, oprot):
22913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22915 
      return
22916 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22917 
    if self.vendorId is not None:
22918 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22919 
      oprot.writeI64(self.vendorId)
22920 
      oprot.writeFieldEnd()
22921 
    if self.billingDateFrom is not None:
22922 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22923 
      oprot.writeI64(self.billingDateFrom)
22924 
      oprot.writeFieldEnd()
22925 
    if self.billingDateTo is not None:
22926 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22927 
      oprot.writeI64(self.billingDateTo)
22928 
      oprot.writeFieldEnd()
22929 
    oprot.writeFieldStop()
22930 
    oprot.writeStructEnd()
22931 
 
22932 
  def validate(self):
22933 
    return
22934 
 
22935 
 
22936 
  def __repr__(self):
22937 
    L = ['%s=%r' % (key, value)
22938 
      for key, value in self.__dict__.iteritems()]
22939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22940 
 
22941 
  def __eq__(self, other):
22942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22943 
 
22944 
  def __ne__(self, other):
22945 
    return not (self == other)
22946 
 
22947 
class getBilledOrdersForVendor_result:
22948 
  """
22949 
  Attributes:
22950 
   - success
22951 
   - ex
22952 
  """
22953 
 
22954 
  thrift_spec = (
22955 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22957 
  )
22958 
 
22959 
  def __init__(self, success=None, ex=None,):
22960 
    self.success = success
22961 
    self.ex = ex
22962 
 
22963 
  def read(self, iprot):
22964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22966 
      return
22967 
    iprot.readStructBegin()
22968 
    while True:
22969 
      (fname, ftype, fid) = iprot.readFieldBegin()
22970 
      if ftype == TType.STOP:
22971 
        break
22972 
      if fid == 0:
22973 
        if ftype == TType.LIST:
22974 
          self.success = []
6188 rajveer 22975 
          (_etype527, _size524) = iprot.readListBegin()
22976 
          for _i528 in xrange(_size524):
22977 
            _elem529 = Order()
22978 
            _elem529.read(iprot)
22979 
            self.success.append(_elem529)
4600 varun.gupt 22980 
          iprot.readListEnd()
22981 
        else:
22982 
          iprot.skip(ftype)
22983 
      elif fid == 1:
22984 
        if ftype == TType.STRUCT:
22985 
          self.ex = TransactionServiceException()
22986 
          self.ex.read(iprot)
22987 
        else:
22988 
          iprot.skip(ftype)
22989 
      else:
22990 
        iprot.skip(ftype)
22991 
      iprot.readFieldEnd()
22992 
    iprot.readStructEnd()
22993 
 
22994 
  def write(self, oprot):
22995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22997 
      return
22998 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22999 
    if self.success is not None:
23000 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23001 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23002 
      for iter530 in self.success:
23003 
        iter530.write(oprot)
4600 varun.gupt 23004 
      oprot.writeListEnd()
23005 
      oprot.writeFieldEnd()
23006 
    if self.ex is not None:
23007 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23008 
      self.ex.write(oprot)
23009 
      oprot.writeFieldEnd()
23010 
    oprot.writeFieldStop()
23011 
    oprot.writeStructEnd()
23012 
 
23013 
  def validate(self):
23014 
    return
23015 
 
23016 
 
23017 
  def __repr__(self):
23018 
    L = ['%s=%r' % (key, value)
23019 
      for key, value in self.__dict__.iteritems()]
23020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23021 
 
23022 
  def __eq__(self, other):
23023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23024 
 
23025 
  def __ne__(self, other):
23026 
    return not (self == other)
23027 
 
4607 rajveer 23028 
class getSlippedSippingDateOrders_args:
23029 
 
23030 
  thrift_spec = (
23031 
  )
23032 
 
23033 
  def read(self, iprot):
23034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23036 
      return
23037 
    iprot.readStructBegin()
23038 
    while True:
23039 
      (fname, ftype, fid) = iprot.readFieldBegin()
23040 
      if ftype == TType.STOP:
23041 
        break
23042 
      else:
23043 
        iprot.skip(ftype)
23044 
      iprot.readFieldEnd()
23045 
    iprot.readStructEnd()
23046 
 
23047 
  def write(self, oprot):
23048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23050 
      return
23051 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23052 
    oprot.writeFieldStop()
23053 
    oprot.writeStructEnd()
23054 
 
23055 
  def validate(self):
23056 
    return
23057 
 
23058 
 
23059 
  def __repr__(self):
23060 
    L = ['%s=%r' % (key, value)
23061 
      for key, value in self.__dict__.iteritems()]
23062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23063 
 
23064 
  def __eq__(self, other):
23065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23066 
 
23067 
  def __ne__(self, other):
23068 
    return not (self == other)
23069 
 
23070 
class getSlippedSippingDateOrders_result:
23071 
  """
23072 
  Attributes:
23073 
   - success
23074 
   - ex
23075 
  """
23076 
 
23077 
  thrift_spec = (
23078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23080 
  )
23081 
 
23082 
  def __init__(self, success=None, ex=None,):
23083 
    self.success = success
23084 
    self.ex = ex
23085 
 
23086 
  def read(self, iprot):
23087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23089 
      return
23090 
    iprot.readStructBegin()
23091 
    while True:
23092 
      (fname, ftype, fid) = iprot.readFieldBegin()
23093 
      if ftype == TType.STOP:
23094 
        break
23095 
      if fid == 0:
23096 
        if ftype == TType.LIST:
23097 
          self.success = []
6188 rajveer 23098 
          (_etype534, _size531) = iprot.readListBegin()
23099 
          for _i535 in xrange(_size531):
23100 
            _elem536 = Order()
23101 
            _elem536.read(iprot)
23102 
            self.success.append(_elem536)
4607 rajveer 23103 
          iprot.readListEnd()
23104 
        else:
23105 
          iprot.skip(ftype)
23106 
      elif fid == 1:
23107 
        if ftype == TType.STRUCT:
23108 
          self.ex = TransactionServiceException()
23109 
          self.ex.read(iprot)
23110 
        else:
23111 
          iprot.skip(ftype)
23112 
      else:
23113 
        iprot.skip(ftype)
23114 
      iprot.readFieldEnd()
23115 
    iprot.readStructEnd()
23116 
 
23117 
  def write(self, oprot):
23118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23120 
      return
23121 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23122 
    if self.success is not None:
23123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23125 
      for iter537 in self.success:
23126 
        iter537.write(oprot)
4607 rajveer 23127 
      oprot.writeListEnd()
23128 
      oprot.writeFieldEnd()
23129 
    if self.ex is not None:
23130 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23131 
      self.ex.write(oprot)
23132 
      oprot.writeFieldEnd()
23133 
    oprot.writeFieldStop()
23134 
    oprot.writeStructEnd()
23135 
 
23136 
  def validate(self):
23137 
    return
23138 
 
23139 
 
23140 
  def __repr__(self):
23141 
    L = ['%s=%r' % (key, value)
23142 
      for key, value in self.__dict__.iteritems()]
23143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23144 
 
23145 
  def __eq__(self, other):
23146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23147 
 
23148 
  def __ne__(self, other):
23149 
    return not (self == other)
23150 
 
4709 rajveer 23151 
class getCancelledOrders_args:
23152 
  """
23153 
  Attributes:
23154 
   - cancelDateFrom
23155 
   - cancelDateTo
23156 
  """
23157 
 
23158 
  thrift_spec = (
23159 
    None, # 0
23160 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23161 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23162 
  )
23163 
 
23164 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23165 
    self.cancelDateFrom = cancelDateFrom
23166 
    self.cancelDateTo = cancelDateTo
23167 
 
23168 
  def read(self, iprot):
23169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23171 
      return
23172 
    iprot.readStructBegin()
23173 
    while True:
23174 
      (fname, ftype, fid) = iprot.readFieldBegin()
23175 
      if ftype == TType.STOP:
23176 
        break
23177 
      if fid == 1:
23178 
        if ftype == TType.I64:
23179 
          self.cancelDateFrom = iprot.readI64();
23180 
        else:
23181 
          iprot.skip(ftype)
23182 
      elif fid == 2:
23183 
        if ftype == TType.I64:
23184 
          self.cancelDateTo = iprot.readI64();
23185 
        else:
23186 
          iprot.skip(ftype)
23187 
      else:
23188 
        iprot.skip(ftype)
23189 
      iprot.readFieldEnd()
23190 
    iprot.readStructEnd()
23191 
 
23192 
  def write(self, oprot):
23193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23195 
      return
23196 
    oprot.writeStructBegin('getCancelledOrders_args')
23197 
    if self.cancelDateFrom is not None:
23198 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23199 
      oprot.writeI64(self.cancelDateFrom)
23200 
      oprot.writeFieldEnd()
23201 
    if self.cancelDateTo is not None:
23202 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23203 
      oprot.writeI64(self.cancelDateTo)
23204 
      oprot.writeFieldEnd()
23205 
    oprot.writeFieldStop()
23206 
    oprot.writeStructEnd()
23207 
 
23208 
  def validate(self):
23209 
    return
23210 
 
23211 
 
23212 
  def __repr__(self):
23213 
    L = ['%s=%r' % (key, value)
23214 
      for key, value in self.__dict__.iteritems()]
23215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23216 
 
23217 
  def __eq__(self, other):
23218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23219 
 
23220 
  def __ne__(self, other):
23221 
    return not (self == other)
23222 
 
23223 
class getCancelledOrders_result:
23224 
  """
23225 
  Attributes:
23226 
   - success
23227 
   - ex
23228 
  """
23229 
 
23230 
  thrift_spec = (
23231 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23233 
  )
23234 
 
23235 
  def __init__(self, success=None, ex=None,):
23236 
    self.success = success
23237 
    self.ex = ex
23238 
 
23239 
  def read(self, iprot):
23240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23242 
      return
23243 
    iprot.readStructBegin()
23244 
    while True:
23245 
      (fname, ftype, fid) = iprot.readFieldBegin()
23246 
      if ftype == TType.STOP:
23247 
        break
23248 
      if fid == 0:
23249 
        if ftype == TType.LIST:
23250 
          self.success = []
6188 rajveer 23251 
          (_etype541, _size538) = iprot.readListBegin()
23252 
          for _i542 in xrange(_size538):
23253 
            _elem543 = Order()
23254 
            _elem543.read(iprot)
23255 
            self.success.append(_elem543)
4709 rajveer 23256 
          iprot.readListEnd()
23257 
        else:
23258 
          iprot.skip(ftype)
23259 
      elif fid == 1:
23260 
        if ftype == TType.STRUCT:
23261 
          self.ex = TransactionServiceException()
23262 
          self.ex.read(iprot)
23263 
        else:
23264 
          iprot.skip(ftype)
23265 
      else:
23266 
        iprot.skip(ftype)
23267 
      iprot.readFieldEnd()
23268 
    iprot.readStructEnd()
23269 
 
23270 
  def write(self, oprot):
23271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23273 
      return
23274 
    oprot.writeStructBegin('getCancelledOrders_result')
23275 
    if self.success is not None:
23276 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23277 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23278 
      for iter544 in self.success:
23279 
        iter544.write(oprot)
4709 rajveer 23280 
      oprot.writeListEnd()
23281 
      oprot.writeFieldEnd()
23282 
    if self.ex is not None:
23283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23284 
      self.ex.write(oprot)
23285 
      oprot.writeFieldEnd()
23286 
    oprot.writeFieldStop()
23287 
    oprot.writeStructEnd()
23288 
 
23289 
  def validate(self):
23290 
    return
23291 
 
23292 
 
23293 
  def __repr__(self):
23294 
    L = ['%s=%r' % (key, value)
23295 
      for key, value in self.__dict__.iteritems()]
23296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23297 
 
23298 
  def __eq__(self, other):
23299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23300 
 
23301 
  def __ne__(self, other):
23302 
    return not (self == other)
23303 
 
4600 varun.gupt 23304 
class saveBluedartSettlements_args:
23305 
  """
23306 
  Attributes:
23307 
   - mapAWBAndAmount
23308 
  """
23309 
 
23310 
  thrift_spec = (
23311 
    None, # 0
23312 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23313 
  )
23314 
 
23315 
  def __init__(self, mapAWBAndAmount=None,):
23316 
    self.mapAWBAndAmount = mapAWBAndAmount
23317 
 
23318 
  def read(self, iprot):
23319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23321 
      return
23322 
    iprot.readStructBegin()
23323 
    while True:
23324 
      (fname, ftype, fid) = iprot.readFieldBegin()
23325 
      if ftype == TType.STOP:
23326 
        break
23327 
      if fid == 1:
23328 
        if ftype == TType.MAP:
23329 
          self.mapAWBAndAmount = {}
6188 rajveer 23330 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23331 
          for _i549 in xrange(_size545):
23332 
            _key550 = iprot.readI64();
23333 
            _val551 = iprot.readDouble();
23334 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23335 
          iprot.readMapEnd()
23336 
        else:
23337 
          iprot.skip(ftype)
23338 
      else:
23339 
        iprot.skip(ftype)
23340 
      iprot.readFieldEnd()
23341 
    iprot.readStructEnd()
23342 
 
23343 
  def write(self, oprot):
23344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23346 
      return
23347 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23348 
    if self.mapAWBAndAmount is not None:
23349 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23350 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23351 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23352 
        oprot.writeI64(kiter552)
23353 
        oprot.writeDouble(viter553)
4600 varun.gupt 23354 
      oprot.writeMapEnd()
23355 
      oprot.writeFieldEnd()
23356 
    oprot.writeFieldStop()
23357 
    oprot.writeStructEnd()
23358 
 
23359 
  def validate(self):
23360 
    return
23361 
 
23362 
 
23363 
  def __repr__(self):
23364 
    L = ['%s=%r' % (key, value)
23365 
      for key, value in self.__dict__.iteritems()]
23366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23367 
 
23368 
  def __eq__(self, other):
23369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23370 
 
23371 
  def __ne__(self, other):
23372 
    return not (self == other)
23373 
 
23374 
class saveBluedartSettlements_result:
23375 
  """
23376 
  Attributes:
23377 
   - ex
23378 
  """
23379 
 
23380 
  thrift_spec = (
23381 
    None, # 0
23382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23383 
  )
23384 
 
23385 
  def __init__(self, ex=None,):
23386 
    self.ex = ex
23387 
 
23388 
  def read(self, iprot):
23389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23391 
      return
23392 
    iprot.readStructBegin()
23393 
    while True:
23394 
      (fname, ftype, fid) = iprot.readFieldBegin()
23395 
      if ftype == TType.STOP:
23396 
        break
23397 
      if fid == 1:
23398 
        if ftype == TType.STRUCT:
23399 
          self.ex = TransactionServiceException()
23400 
          self.ex.read(iprot)
23401 
        else:
23402 
          iprot.skip(ftype)
23403 
      else:
23404 
        iprot.skip(ftype)
23405 
      iprot.readFieldEnd()
23406 
    iprot.readStructEnd()
23407 
 
23408 
  def write(self, oprot):
23409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23411 
      return
23412 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23413 
    if self.ex is not None:
23414 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23415 
      self.ex.write(oprot)
23416 
      oprot.writeFieldEnd()
23417 
    oprot.writeFieldStop()
23418 
    oprot.writeStructEnd()
23419 
 
23420 
  def validate(self):
23421 
    return
23422 
 
23423 
 
23424 
  def __repr__(self):
23425 
    L = ['%s=%r' % (key, value)
23426 
      for key, value in self.__dict__.iteritems()]
23427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23428 
 
23429 
  def __eq__(self, other):
23430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23431 
 
23432 
  def __ne__(self, other):
23433 
    return not (self == other)
23434 
 
23435 
class savePaymentSettlements_args:
23436 
  """
23437 
  Attributes:
23438 
   - settlementDate
23439 
   - paymentGatewayId
4905 varun.gupt 23440 
   - referenceId
4600 varun.gupt 23441 
   - serviceTax
23442 
   - otherCharges
23443 
   - netCollection
23444 
  """
23445 
 
23446 
  thrift_spec = (
23447 
    None, # 0
23448 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23449 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23450 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23451 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23452 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23453 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23454 
  )
23455 
 
4905 varun.gupt 23456 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23457 
    self.settlementDate = settlementDate
23458 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23459 
    self.referenceId = referenceId
4600 varun.gupt 23460 
    self.serviceTax = serviceTax
23461 
    self.otherCharges = otherCharges
23462 
    self.netCollection = netCollection
23463 
 
23464 
  def read(self, iprot):
23465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23467 
      return
23468 
    iprot.readStructBegin()
23469 
    while True:
23470 
      (fname, ftype, fid) = iprot.readFieldBegin()
23471 
      if ftype == TType.STOP:
23472 
        break
23473 
      if fid == 1:
23474 
        if ftype == TType.I64:
23475 
          self.settlementDate = iprot.readI64();
23476 
        else:
23477 
          iprot.skip(ftype)
23478 
      elif fid == 2:
23479 
        if ftype == TType.I64:
23480 
          self.paymentGatewayId = iprot.readI64();
23481 
        else:
23482 
          iprot.skip(ftype)
23483 
      elif fid == 3:
23484 
        if ftype == TType.I64:
4905 varun.gupt 23485 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23486 
        else:
23487 
          iprot.skip(ftype)
23488 
      elif fid == 4:
23489 
        if ftype == TType.DOUBLE:
23490 
          self.serviceTax = iprot.readDouble();
23491 
        else:
23492 
          iprot.skip(ftype)
23493 
      elif fid == 5:
23494 
        if ftype == TType.DOUBLE:
23495 
          self.otherCharges = iprot.readDouble();
23496 
        else:
23497 
          iprot.skip(ftype)
23498 
      elif fid == 6:
23499 
        if ftype == TType.DOUBLE:
23500 
          self.netCollection = iprot.readDouble();
23501 
        else:
23502 
          iprot.skip(ftype)
23503 
      else:
23504 
        iprot.skip(ftype)
23505 
      iprot.readFieldEnd()
23506 
    iprot.readStructEnd()
23507 
 
23508 
  def write(self, oprot):
23509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23511 
      return
23512 
    oprot.writeStructBegin('savePaymentSettlements_args')
23513 
    if self.settlementDate is not None:
23514 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23515 
      oprot.writeI64(self.settlementDate)
23516 
      oprot.writeFieldEnd()
23517 
    if self.paymentGatewayId is not None:
23518 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23519 
      oprot.writeI64(self.paymentGatewayId)
23520 
      oprot.writeFieldEnd()
4905 varun.gupt 23521 
    if self.referenceId is not None:
23522 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23523 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23524 
      oprot.writeFieldEnd()
23525 
    if self.serviceTax is not None:
23526 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23527 
      oprot.writeDouble(self.serviceTax)
23528 
      oprot.writeFieldEnd()
23529 
    if self.otherCharges is not None:
23530 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23531 
      oprot.writeDouble(self.otherCharges)
23532 
      oprot.writeFieldEnd()
23533 
    if self.netCollection is not None:
23534 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23535 
      oprot.writeDouble(self.netCollection)
23536 
      oprot.writeFieldEnd()
23537 
    oprot.writeFieldStop()
23538 
    oprot.writeStructEnd()
23539 
 
23540 
  def validate(self):
23541 
    return
23542 
 
23543 
 
23544 
  def __repr__(self):
23545 
    L = ['%s=%r' % (key, value)
23546 
      for key, value in self.__dict__.iteritems()]
23547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23548 
 
23549 
  def __eq__(self, other):
23550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23551 
 
23552 
  def __ne__(self, other):
23553 
    return not (self == other)
23554 
 
23555 
class savePaymentSettlements_result:
23556 
  """
23557 
  Attributes:
23558 
   - ex
23559 
  """
23560 
 
23561 
  thrift_spec = (
23562 
    None, # 0
23563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23564 
  )
23565 
 
23566 
  def __init__(self, ex=None,):
23567 
    self.ex = ex
23568 
 
23569 
  def read(self, iprot):
23570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23572 
      return
23573 
    iprot.readStructBegin()
23574 
    while True:
23575 
      (fname, ftype, fid) = iprot.readFieldBegin()
23576 
      if ftype == TType.STOP:
23577 
        break
23578 
      if fid == 1:
23579 
        if ftype == TType.STRUCT:
23580 
          self.ex = TransactionServiceException()
23581 
          self.ex.read(iprot)
23582 
        else:
23583 
          iprot.skip(ftype)
23584 
      else:
23585 
        iprot.skip(ftype)
23586 
      iprot.readFieldEnd()
23587 
    iprot.readStructEnd()
23588 
 
23589 
  def write(self, oprot):
23590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23592 
      return
23593 
    oprot.writeStructBegin('savePaymentSettlements_result')
23594 
    if self.ex is not None:
23595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23596 
      self.ex.write(oprot)
23597 
      oprot.writeFieldEnd()
23598 
    oprot.writeFieldStop()
23599 
    oprot.writeStructEnd()
23600 
 
23601 
  def validate(self):
23602 
    return
23603 
 
23604 
 
23605 
  def __repr__(self):
23606 
    L = ['%s=%r' % (key, value)
23607 
      for key, value in self.__dict__.iteritems()]
23608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23609 
 
23610 
  def __eq__(self, other):
23611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23612 
 
23613 
  def __ne__(self, other):
23614 
    return not (self == other)
23615 
 
23616 
class saveEBSSettlementSummary_args:
23617 
  """
23618 
  Attributes:
23619 
   - settlementId
23620 
   - settlementDate
23621 
   - transactionDateFrom
23622 
   - transactionDateTo
23623 
   - amount
23624 
  """
23625 
 
23626 
  thrift_spec = (
23627 
    None, # 0
23628 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23629 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23630 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23631 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23632 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23633 
  )
23634 
 
23635 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23636 
    self.settlementId = settlementId
23637 
    self.settlementDate = settlementDate
23638 
    self.transactionDateFrom = transactionDateFrom
23639 
    self.transactionDateTo = transactionDateTo
23640 
    self.amount = amount
23641 
 
23642 
  def read(self, iprot):
23643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23645 
      return
23646 
    iprot.readStructBegin()
23647 
    while True:
23648 
      (fname, ftype, fid) = iprot.readFieldBegin()
23649 
      if ftype == TType.STOP:
23650 
        break
23651 
      if fid == 1:
23652 
        if ftype == TType.I64:
23653 
          self.settlementId = iprot.readI64();
23654 
        else:
23655 
          iprot.skip(ftype)
23656 
      elif fid == 2:
23657 
        if ftype == TType.I64:
23658 
          self.settlementDate = iprot.readI64();
23659 
        else:
23660 
          iprot.skip(ftype)
23661 
      elif fid == 3:
23662 
        if ftype == TType.I64:
23663 
          self.transactionDateFrom = iprot.readI64();
23664 
        else:
23665 
          iprot.skip(ftype)
23666 
      elif fid == 4:
23667 
        if ftype == TType.I64:
23668 
          self.transactionDateTo = iprot.readI64();
23669 
        else:
23670 
          iprot.skip(ftype)
23671 
      elif fid == 5:
23672 
        if ftype == TType.DOUBLE:
23673 
          self.amount = iprot.readDouble();
23674 
        else:
23675 
          iprot.skip(ftype)
23676 
      else:
23677 
        iprot.skip(ftype)
23678 
      iprot.readFieldEnd()
23679 
    iprot.readStructEnd()
23680 
 
23681 
  def write(self, oprot):
23682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23684 
      return
23685 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23686 
    if self.settlementId is not None:
23687 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23688 
      oprot.writeI64(self.settlementId)
23689 
      oprot.writeFieldEnd()
23690 
    if self.settlementDate is not None:
23691 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23692 
      oprot.writeI64(self.settlementDate)
23693 
      oprot.writeFieldEnd()
23694 
    if self.transactionDateFrom is not None:
23695 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23696 
      oprot.writeI64(self.transactionDateFrom)
23697 
      oprot.writeFieldEnd()
23698 
    if self.transactionDateTo is not None:
23699 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23700 
      oprot.writeI64(self.transactionDateTo)
23701 
      oprot.writeFieldEnd()
23702 
    if self.amount is not None:
23703 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23704 
      oprot.writeDouble(self.amount)
23705 
      oprot.writeFieldEnd()
23706 
    oprot.writeFieldStop()
23707 
    oprot.writeStructEnd()
23708 
 
23709 
  def validate(self):
23710 
    return
23711 
 
23712 
 
23713 
  def __repr__(self):
23714 
    L = ['%s=%r' % (key, value)
23715 
      for key, value in self.__dict__.iteritems()]
23716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23717 
 
23718 
  def __eq__(self, other):
23719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23720 
 
23721 
  def __ne__(self, other):
23722 
    return not (self == other)
23723 
 
23724 
class saveEBSSettlementSummary_result:
23725 
  """
23726 
  Attributes:
23727 
   - ex
23728 
  """
23729 
 
23730 
  thrift_spec = (
23731 
    None, # 0
23732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23733 
  )
23734 
 
23735 
  def __init__(self, ex=None,):
23736 
    self.ex = ex
23737 
 
23738 
  def read(self, iprot):
23739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23741 
      return
23742 
    iprot.readStructBegin()
23743 
    while True:
23744 
      (fname, ftype, fid) = iprot.readFieldBegin()
23745 
      if ftype == TType.STOP:
23746 
        break
23747 
      if fid == 1:
23748 
        if ftype == TType.STRUCT:
23749 
          self.ex = TransactionServiceException()
23750 
          self.ex.read(iprot)
23751 
        else:
23752 
          iprot.skip(ftype)
23753 
      else:
23754 
        iprot.skip(ftype)
23755 
      iprot.readFieldEnd()
23756 
    iprot.readStructEnd()
23757 
 
23758 
  def write(self, oprot):
23759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23761 
      return
23762 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23763 
    if self.ex is not None:
23764 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23765 
      self.ex.write(oprot)
23766 
      oprot.writeFieldEnd()
23767 
    oprot.writeFieldStop()
23768 
    oprot.writeStructEnd()
23769 
 
23770 
  def validate(self):
23771 
    return
23772 
 
23773 
 
23774 
  def __repr__(self):
23775 
    L = ['%s=%r' % (key, value)
23776 
      for key, value in self.__dict__.iteritems()]
23777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23778 
 
23779 
  def __eq__(self, other):
23780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23781 
 
23782 
  def __ne__(self, other):
23783 
    return not (self == other)
23784 
 
5386 phani.kuma 23785 
class getSettlementForPrepaid_args:
4600 varun.gupt 23786 
  """
23787 
  Attributes:
5189 varun.gupt 23788 
   - referenceId
23789 
   - isRefund
4600 varun.gupt 23790 
  """
23791 
 
23792 
  thrift_spec = (
23793 
    None, # 0
5189 varun.gupt 23794 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23795 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23796 
  )
23797 
 
5386 phani.kuma 23798 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23799 
    self.referenceId = referenceId
23800 
    self.isRefund = isRefund
4600 varun.gupt 23801 
 
23802 
  def read(self, iprot):
23803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23805 
      return
23806 
    iprot.readStructBegin()
23807 
    while True:
23808 
      (fname, ftype, fid) = iprot.readFieldBegin()
23809 
      if ftype == TType.STOP:
23810 
        break
23811 
      if fid == 1:
23812 
        if ftype == TType.I64:
5189 varun.gupt 23813 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23814 
        else:
23815 
          iprot.skip(ftype)
5189 varun.gupt 23816 
      elif fid == 2:
23817 
        if ftype == TType.BOOL:
23818 
          self.isRefund = iprot.readBool();
23819 
        else:
23820 
          iprot.skip(ftype)
4600 varun.gupt 23821 
      else:
23822 
        iprot.skip(ftype)
23823 
      iprot.readFieldEnd()
23824 
    iprot.readStructEnd()
23825 
 
23826 
  def write(self, oprot):
23827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23829 
      return
5386 phani.kuma 23830 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23831 
    if self.referenceId is not None:
23832 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23833 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23834 
      oprot.writeFieldEnd()
5386 phani.kuma 23835 
    if self.isRefund is not None:
23836 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23837 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23838 
      oprot.writeFieldEnd()
5386 phani.kuma 23839 
    oprot.writeFieldStop()
23840 
    oprot.writeStructEnd()
23841 
 
23842 
  def validate(self):
23843 
    return
23844 
 
23845 
 
23846 
  def __repr__(self):
23847 
    L = ['%s=%r' % (key, value)
23848 
      for key, value in self.__dict__.iteritems()]
23849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23850 
 
23851 
  def __eq__(self, other):
23852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23853 
 
23854 
  def __ne__(self, other):
23855 
    return not (self == other)
23856 
 
23857 
class getSettlementForPrepaid_result:
23858 
  """
23859 
  Attributes:
23860 
   - success
23861 
   - ex
23862 
  """
23863 
 
23864 
  thrift_spec = (
23865 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23867 
  )
23868 
 
23869 
  def __init__(self, success=None, ex=None,):
23870 
    self.success = success
23871 
    self.ex = ex
23872 
 
23873 
  def read(self, iprot):
23874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23876 
      return
23877 
    iprot.readStructBegin()
23878 
    while True:
23879 
      (fname, ftype, fid) = iprot.readFieldBegin()
23880 
      if ftype == TType.STOP:
23881 
        break
23882 
      if fid == 0:
23883 
        if ftype == TType.STRUCT:
23884 
          self.success = PaymentSettlement()
23885 
          self.success.read(iprot)
23886 
        else:
23887 
          iprot.skip(ftype)
23888 
      elif fid == 1:
23889 
        if ftype == TType.STRUCT:
23890 
          self.ex = TransactionServiceException()
23891 
          self.ex.read(iprot)
23892 
        else:
23893 
          iprot.skip(ftype)
23894 
      else:
23895 
        iprot.skip(ftype)
23896 
      iprot.readFieldEnd()
23897 
    iprot.readStructEnd()
23898 
 
23899 
  def write(self, oprot):
23900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23902 
      return
23903 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23904 
    if self.success is not None:
23905 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23906 
      self.success.write(oprot)
23907 
      oprot.writeFieldEnd()
23908 
    if self.ex is not None:
23909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23910 
      self.ex.write(oprot)
23911 
      oprot.writeFieldEnd()
23912 
    oprot.writeFieldStop()
23913 
    oprot.writeStructEnd()
23914 
 
23915 
  def validate(self):
23916 
    return
23917 
 
23918 
 
23919 
  def __repr__(self):
23920 
    L = ['%s=%r' % (key, value)
23921 
      for key, value in self.__dict__.iteritems()]
23922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23923 
 
23924 
  def __eq__(self, other):
23925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23926 
 
23927 
  def __ne__(self, other):
23928 
    return not (self == other)
23929 
 
23930 
class getSettlementForCod_args:
23931 
  """
23932 
  Attributes:
23933 
   - orderId
23934 
   - isRefund
23935 
  """
23936 
 
23937 
  thrift_spec = (
23938 
    None, # 0
23939 
    (1, TType.I64, 'orderId', None, None, ), # 1
23940 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23941 
  )
23942 
 
23943 
  def __init__(self, orderId=None, isRefund=None,):
23944 
    self.orderId = orderId
23945 
    self.isRefund = isRefund
23946 
 
23947 
  def read(self, iprot):
23948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23950 
      return
23951 
    iprot.readStructBegin()
23952 
    while True:
23953 
      (fname, ftype, fid) = iprot.readFieldBegin()
23954 
      if ftype == TType.STOP:
23955 
        break
23956 
      if fid == 1:
23957 
        if ftype == TType.I64:
23958 
          self.orderId = iprot.readI64();
23959 
        else:
23960 
          iprot.skip(ftype)
23961 
      elif fid == 2:
23962 
        if ftype == TType.BOOL:
23963 
          self.isRefund = iprot.readBool();
23964 
        else:
23965 
          iprot.skip(ftype)
23966 
      else:
23967 
        iprot.skip(ftype)
23968 
      iprot.readFieldEnd()
23969 
    iprot.readStructEnd()
23970 
 
23971 
  def write(self, oprot):
23972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23974 
      return
23975 
    oprot.writeStructBegin('getSettlementForCod_args')
23976 
    if self.orderId is not None:
23977 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23978 
      oprot.writeI64(self.orderId)
23979 
      oprot.writeFieldEnd()
5189 varun.gupt 23980 
    if self.isRefund is not None:
5386 phani.kuma 23981 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23982 
      oprot.writeBool(self.isRefund)
23983 
      oprot.writeFieldEnd()
4600 varun.gupt 23984 
    oprot.writeFieldStop()
23985 
    oprot.writeStructEnd()
23986 
 
23987 
  def validate(self):
23988 
    return
23989 
 
23990 
 
23991 
  def __repr__(self):
23992 
    L = ['%s=%r' % (key, value)
23993 
      for key, value in self.__dict__.iteritems()]
23994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23995 
 
23996 
  def __eq__(self, other):
23997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23998 
 
23999 
  def __ne__(self, other):
24000 
    return not (self == other)
24001 
 
5386 phani.kuma 24002 
class getSettlementForCod_result:
4600 varun.gupt 24003 
  """
24004 
  Attributes:
24005 
   - success
24006 
   - ex
24007 
  """
24008 
 
24009 
  thrift_spec = (
24010 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24012 
  )
24013 
 
24014 
  def __init__(self, success=None, ex=None,):
24015 
    self.success = success
24016 
    self.ex = ex
24017 
 
24018 
  def read(self, iprot):
24019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24021 
      return
24022 
    iprot.readStructBegin()
24023 
    while True:
24024 
      (fname, ftype, fid) = iprot.readFieldBegin()
24025 
      if ftype == TType.STOP:
24026 
        break
24027 
      if fid == 0:
24028 
        if ftype == TType.STRUCT:
24029 
          self.success = PaymentSettlement()
24030 
          self.success.read(iprot)
24031 
        else:
24032 
          iprot.skip(ftype)
24033 
      elif fid == 1:
24034 
        if ftype == TType.STRUCT:
24035 
          self.ex = TransactionServiceException()
24036 
          self.ex.read(iprot)
24037 
        else:
24038 
          iprot.skip(ftype)
24039 
      else:
24040 
        iprot.skip(ftype)
24041 
      iprot.readFieldEnd()
24042 
    iprot.readStructEnd()
24043 
 
24044 
  def write(self, oprot):
24045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24047 
      return
5386 phani.kuma 24048 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24049 
    if self.success is not None:
24050 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24051 
      self.success.write(oprot)
24052 
      oprot.writeFieldEnd()
24053 
    if self.ex is not None:
24054 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24055 
      self.ex.write(oprot)
24056 
      oprot.writeFieldEnd()
24057 
    oprot.writeFieldStop()
24058 
    oprot.writeStructEnd()
24059 
 
24060 
  def validate(self):
24061 
    return
24062 
 
24063 
 
24064 
  def __repr__(self):
24065 
    L = ['%s=%r' % (key, value)
24066 
      for key, value in self.__dict__.iteritems()]
24067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24068 
 
24069 
  def __eq__(self, other):
24070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24071 
 
24072 
  def __ne__(self, other):
24073 
    return not (self == other)
24074 
 
24075 
class getEBSSettlementSummaries_args:
24076 
 
24077 
  thrift_spec = (
24078 
  )
24079 
 
24080 
  def read(self, iprot):
24081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24083 
      return
24084 
    iprot.readStructBegin()
24085 
    while True:
24086 
      (fname, ftype, fid) = iprot.readFieldBegin()
24087 
      if ftype == TType.STOP:
24088 
        break
24089 
      else:
24090 
        iprot.skip(ftype)
24091 
      iprot.readFieldEnd()
24092 
    iprot.readStructEnd()
24093 
 
24094 
  def write(self, oprot):
24095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24097 
      return
24098 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24099 
    oprot.writeFieldStop()
24100 
    oprot.writeStructEnd()
24101 
 
24102 
  def validate(self):
24103 
    return
24104 
 
24105 
 
24106 
  def __repr__(self):
24107 
    L = ['%s=%r' % (key, value)
24108 
      for key, value in self.__dict__.iteritems()]
24109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24110 
 
24111 
  def __eq__(self, other):
24112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24113 
 
24114 
  def __ne__(self, other):
24115 
    return not (self == other)
24116 
 
24117 
class getEBSSettlementSummaries_result:
24118 
  """
24119 
  Attributes:
24120 
   - success
24121 
   - ex
24122 
  """
24123 
 
24124 
  thrift_spec = (
24125 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24126 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24127 
  )
24128 
 
24129 
  def __init__(self, success=None, ex=None,):
24130 
    self.success = success
24131 
    self.ex = ex
24132 
 
24133 
  def read(self, iprot):
24134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24136 
      return
24137 
    iprot.readStructBegin()
24138 
    while True:
24139 
      (fname, ftype, fid) = iprot.readFieldBegin()
24140 
      if ftype == TType.STOP:
24141 
        break
24142 
      if fid == 0:
24143 
        if ftype == TType.MAP:
24144 
          self.success = {}
6188 rajveer 24145 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24146 
          for _i558 in xrange(_size554):
24147 
            _key559 = iprot.readI64();
24148 
            _val560 = iprot.readString();
24149 
            self.success[_key559] = _val560
4600 varun.gupt 24150 
          iprot.readMapEnd()
24151 
        else:
24152 
          iprot.skip(ftype)
24153 
      elif fid == 1:
24154 
        if ftype == TType.STRUCT:
24155 
          self.ex = TransactionServiceException()
24156 
          self.ex.read(iprot)
24157 
        else:
24158 
          iprot.skip(ftype)
24159 
      else:
24160 
        iprot.skip(ftype)
24161 
      iprot.readFieldEnd()
24162 
    iprot.readStructEnd()
24163 
 
24164 
  def write(self, oprot):
24165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24167 
      return
24168 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24169 
    if self.success is not None:
24170 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24171 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24172 
      for kiter561,viter562 in self.success.items():
24173 
        oprot.writeI64(kiter561)
24174 
        oprot.writeString(viter562)
4600 varun.gupt 24175 
      oprot.writeMapEnd()
24176 
      oprot.writeFieldEnd()
24177 
    if self.ex is not None:
24178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24179 
      self.ex.write(oprot)
24180 
      oprot.writeFieldEnd()
24181 
    oprot.writeFieldStop()
24182 
    oprot.writeStructEnd()
24183 
 
24184 
  def validate(self):
24185 
    return
24186 
 
24187 
 
24188 
  def __repr__(self):
24189 
    L = ['%s=%r' % (key, value)
24190 
      for key, value in self.__dict__.iteritems()]
24191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24192 
 
24193 
  def __eq__(self, other):
24194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24195 
 
24196 
  def __ne__(self, other):
24197 
    return not (self == other)
24198 
 
24199 
class markEBSSettlementUploaded_args:
24200 
  """
24201 
  Attributes:
24202 
   - settlementId
24203 
  """
24204 
 
24205 
  thrift_spec = (
24206 
    None, # 0
24207 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24208 
  )
24209 
 
24210 
  def __init__(self, settlementId=None,):
24211 
    self.settlementId = settlementId
24212 
 
24213 
  def read(self, iprot):
24214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24216 
      return
24217 
    iprot.readStructBegin()
24218 
    while True:
24219 
      (fname, ftype, fid) = iprot.readFieldBegin()
24220 
      if ftype == TType.STOP:
24221 
        break
24222 
      if fid == 1:
24223 
        if ftype == TType.I64:
24224 
          self.settlementId = iprot.readI64();
24225 
        else:
24226 
          iprot.skip(ftype)
24227 
      else:
24228 
        iprot.skip(ftype)
24229 
      iprot.readFieldEnd()
24230 
    iprot.readStructEnd()
24231 
 
24232 
  def write(self, oprot):
24233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24235 
      return
24236 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24237 
    if self.settlementId is not None:
24238 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24239 
      oprot.writeI64(self.settlementId)
24240 
      oprot.writeFieldEnd()
24241 
    oprot.writeFieldStop()
24242 
    oprot.writeStructEnd()
24243 
 
24244 
  def validate(self):
24245 
    return
24246 
 
24247 
 
24248 
  def __repr__(self):
24249 
    L = ['%s=%r' % (key, value)
24250 
      for key, value in self.__dict__.iteritems()]
24251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24252 
 
24253 
  def __eq__(self, other):
24254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24255 
 
24256 
  def __ne__(self, other):
24257 
    return not (self == other)
24258 
 
24259 
class markEBSSettlementUploaded_result:
24260 
  """
24261 
  Attributes:
24262 
   - ex
24263 
  """
24264 
 
24265 
  thrift_spec = (
24266 
    None, # 0
24267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24268 
  )
24269 
 
24270 
  def __init__(self, ex=None,):
24271 
    self.ex = ex
24272 
 
24273 
  def read(self, iprot):
24274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24276 
      return
24277 
    iprot.readStructBegin()
24278 
    while True:
24279 
      (fname, ftype, fid) = iprot.readFieldBegin()
24280 
      if ftype == TType.STOP:
24281 
        break
24282 
      if fid == 1:
24283 
        if ftype == TType.STRUCT:
24284 
          self.ex = TransactionServiceException()
24285 
          self.ex.read(iprot)
24286 
        else:
24287 
          iprot.skip(ftype)
24288 
      else:
24289 
        iprot.skip(ftype)
24290 
      iprot.readFieldEnd()
24291 
    iprot.readStructEnd()
24292 
 
24293 
  def write(self, oprot):
24294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24296 
      return
24297 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24298 
    if self.ex is not None:
24299 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24300 
      self.ex.write(oprot)
24301 
      oprot.writeFieldEnd()
24302 
    oprot.writeFieldStop()
24303 
    oprot.writeStructEnd()
24304 
 
24305 
  def validate(self):
24306 
    return
24307 
 
24308 
 
24309 
  def __repr__(self):
24310 
    L = ['%s=%r' % (key, value)
24311 
      for key, value in self.__dict__.iteritems()]
24312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24313 
 
24314 
  def __eq__(self, other):
24315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24316 
 
24317 
  def __ne__(self, other):
24318 
    return not (self == other)
24319 
 
24320 
class getEBSSettlementDate_args:
24321 
  """
24322 
  Attributes:
24323 
   - settlementId
24324 
  """
24325 
 
24326 
  thrift_spec = (
24327 
    None, # 0
24328 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24329 
  )
24330 
 
24331 
  def __init__(self, settlementId=None,):
24332 
    self.settlementId = settlementId
24333 
 
24334 
  def read(self, iprot):
24335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24337 
      return
24338 
    iprot.readStructBegin()
24339 
    while True:
24340 
      (fname, ftype, fid) = iprot.readFieldBegin()
24341 
      if ftype == TType.STOP:
24342 
        break
24343 
      if fid == 1:
24344 
        if ftype == TType.I64:
24345 
          self.settlementId = iprot.readI64();
24346 
        else:
24347 
          iprot.skip(ftype)
24348 
      else:
24349 
        iprot.skip(ftype)
24350 
      iprot.readFieldEnd()
24351 
    iprot.readStructEnd()
24352 
 
24353 
  def write(self, oprot):
24354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24356 
      return
24357 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24358 
    if self.settlementId is not None:
24359 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24360 
      oprot.writeI64(self.settlementId)
24361 
      oprot.writeFieldEnd()
24362 
    oprot.writeFieldStop()
24363 
    oprot.writeStructEnd()
24364 
 
24365 
  def validate(self):
24366 
    return
24367 
 
24368 
 
24369 
  def __repr__(self):
24370 
    L = ['%s=%r' % (key, value)
24371 
      for key, value in self.__dict__.iteritems()]
24372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24373 
 
24374 
  def __eq__(self, other):
24375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24376 
 
24377 
  def __ne__(self, other):
24378 
    return not (self == other)
24379 
 
24380 
class getEBSSettlementDate_result:
24381 
  """
24382 
  Attributes:
24383 
   - success
24384 
   - ex
24385 
  """
24386 
 
24387 
  thrift_spec = (
24388 
    (0, TType.I64, 'success', None, None, ), # 0
24389 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24390 
  )
24391 
 
24392 
  def __init__(self, success=None, ex=None,):
24393 
    self.success = success
24394 
    self.ex = ex
24395 
 
24396 
  def read(self, iprot):
24397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24399 
      return
24400 
    iprot.readStructBegin()
24401 
    while True:
24402 
      (fname, ftype, fid) = iprot.readFieldBegin()
24403 
      if ftype == TType.STOP:
24404 
        break
24405 
      if fid == 0:
24406 
        if ftype == TType.I64:
24407 
          self.success = iprot.readI64();
24408 
        else:
24409 
          iprot.skip(ftype)
24410 
      elif fid == 1:
24411 
        if ftype == TType.STRUCT:
24412 
          self.ex = TransactionServiceException()
24413 
          self.ex.read(iprot)
24414 
        else:
24415 
          iprot.skip(ftype)
24416 
      else:
24417 
        iprot.skip(ftype)
24418 
      iprot.readFieldEnd()
24419 
    iprot.readStructEnd()
24420 
 
24421 
  def write(self, oprot):
24422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24424 
      return
24425 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24426 
    if self.success is not None:
24427 
      oprot.writeFieldBegin('success', TType.I64, 0)
24428 
      oprot.writeI64(self.success)
24429 
      oprot.writeFieldEnd()
24430 
    if self.ex is not None:
24431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24432 
      self.ex.write(oprot)
24433 
      oprot.writeFieldEnd()
24434 
    oprot.writeFieldStop()
24435 
    oprot.writeStructEnd()
24436 
 
24437 
  def validate(self):
24438 
    return
24439 
 
24440 
 
24441 
  def __repr__(self):
24442 
    L = ['%s=%r' % (key, value)
24443 
      for key, value in self.__dict__.iteritems()]
24444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24445 
 
24446 
  def __eq__(self, other):
24447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24448 
 
24449 
  def __ne__(self, other):
24450 
    return not (self == other)
4715 varun.gupt 24451 
 
24452 
class getSettlementsByDate_args:
24453 
  """
24454 
  Attributes:
24455 
   - settlementDateFrom
24456 
   - settlementDateTo
24457 
   - isRefund
24458 
  """
24459 
 
24460 
  thrift_spec = (
24461 
    None, # 0
24462 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24463 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24464 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24465 
  )
24466 
 
24467 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24468 
    self.settlementDateFrom = settlementDateFrom
24469 
    self.settlementDateTo = settlementDateTo
24470 
    self.isRefund = isRefund
24471 
 
24472 
  def read(self, iprot):
24473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24475 
      return
24476 
    iprot.readStructBegin()
24477 
    while True:
24478 
      (fname, ftype, fid) = iprot.readFieldBegin()
24479 
      if ftype == TType.STOP:
24480 
        break
24481 
      if fid == 1:
24482 
        if ftype == TType.I64:
24483 
          self.settlementDateFrom = iprot.readI64();
24484 
        else:
24485 
          iprot.skip(ftype)
24486 
      elif fid == 2:
24487 
        if ftype == TType.I64:
24488 
          self.settlementDateTo = iprot.readI64();
24489 
        else:
24490 
          iprot.skip(ftype)
24491 
      elif fid == 3:
24492 
        if ftype == TType.BOOL:
24493 
          self.isRefund = iprot.readBool();
24494 
        else:
24495 
          iprot.skip(ftype)
24496 
      else:
24497 
        iprot.skip(ftype)
24498 
      iprot.readFieldEnd()
24499 
    iprot.readStructEnd()
24500 
 
24501 
  def write(self, oprot):
24502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24504 
      return
24505 
    oprot.writeStructBegin('getSettlementsByDate_args')
24506 
    if self.settlementDateFrom is not None:
24507 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24508 
      oprot.writeI64(self.settlementDateFrom)
24509 
      oprot.writeFieldEnd()
24510 
    if self.settlementDateTo is not None:
24511 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24512 
      oprot.writeI64(self.settlementDateTo)
24513 
      oprot.writeFieldEnd()
24514 
    if self.isRefund is not None:
24515 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24516 
      oprot.writeBool(self.isRefund)
24517 
      oprot.writeFieldEnd()
24518 
    oprot.writeFieldStop()
24519 
    oprot.writeStructEnd()
24520 
 
24521 
  def validate(self):
24522 
    return
24523 
 
24524 
 
24525 
  def __repr__(self):
24526 
    L = ['%s=%r' % (key, value)
24527 
      for key, value in self.__dict__.iteritems()]
24528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24529 
 
24530 
  def __eq__(self, other):
24531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24532 
 
24533 
  def __ne__(self, other):
24534 
    return not (self == other)
24535 
 
24536 
class getSettlementsByDate_result:
24537 
  """
24538 
  Attributes:
24539 
   - success
24540 
   - ex
24541 
  """
24542 
 
24543 
  thrift_spec = (
24544 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24546 
  )
24547 
 
24548 
  def __init__(self, success=None, ex=None,):
24549 
    self.success = success
24550 
    self.ex = ex
24551 
 
24552 
  def read(self, iprot):
24553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24555 
      return
24556 
    iprot.readStructBegin()
24557 
    while True:
24558 
      (fname, ftype, fid) = iprot.readFieldBegin()
24559 
      if ftype == TType.STOP:
24560 
        break
24561 
      if fid == 0:
24562 
        if ftype == TType.LIST:
24563 
          self.success = []
6188 rajveer 24564 
          (_etype566, _size563) = iprot.readListBegin()
24565 
          for _i567 in xrange(_size563):
24566 
            _elem568 = PaymentSettlement()
24567 
            _elem568.read(iprot)
24568 
            self.success.append(_elem568)
4715 varun.gupt 24569 
          iprot.readListEnd()
24570 
        else:
24571 
          iprot.skip(ftype)
24572 
      elif fid == 1:
24573 
        if ftype == TType.STRUCT:
24574 
          self.ex = TransactionServiceException()
24575 
          self.ex.read(iprot)
24576 
        else:
24577 
          iprot.skip(ftype)
24578 
      else:
24579 
        iprot.skip(ftype)
24580 
      iprot.readFieldEnd()
24581 
    iprot.readStructEnd()
24582 
 
24583 
  def write(self, oprot):
24584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24586 
      return
24587 
    oprot.writeStructBegin('getSettlementsByDate_result')
24588 
    if self.success is not None:
24589 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24590 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24591 
      for iter569 in self.success:
24592 
        iter569.write(oprot)
4715 varun.gupt 24593 
      oprot.writeListEnd()
24594 
      oprot.writeFieldEnd()
24595 
    if self.ex is not None:
24596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24597 
      self.ex.write(oprot)
24598 
      oprot.writeFieldEnd()
24599 
    oprot.writeFieldStop()
24600 
    oprot.writeStructEnd()
24601 
 
24602 
  def validate(self):
24603 
    return
24604 
 
24605 
 
24606 
  def __repr__(self):
24607 
    L = ['%s=%r' % (key, value)
24608 
      for key, value in self.__dict__.iteritems()]
24609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24610 
 
24611 
  def __eq__(self, other):
24612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24613 
 
24614 
  def __ne__(self, other):
24615 
    return not (self == other)
24616 
 
24617 
class getReshippedOrderIds_args:
24618 
  """
24619 
  Attributes:
24620 
   - orderIds
24621 
  """
24622 
 
24623 
  thrift_spec = (
24624 
    None, # 0
24625 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24626 
  )
24627 
 
24628 
  def __init__(self, orderIds=None,):
24629 
    self.orderIds = orderIds
24630 
 
24631 
  def read(self, iprot):
24632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24634 
      return
24635 
    iprot.readStructBegin()
24636 
    while True:
24637 
      (fname, ftype, fid) = iprot.readFieldBegin()
24638 
      if ftype == TType.STOP:
24639 
        break
24640 
      if fid == 1:
24641 
        if ftype == TType.LIST:
24642 
          self.orderIds = []
6188 rajveer 24643 
          (_etype573, _size570) = iprot.readListBegin()
24644 
          for _i574 in xrange(_size570):
24645 
            _elem575 = iprot.readI64();
24646 
            self.orderIds.append(_elem575)
4715 varun.gupt 24647 
          iprot.readListEnd()
24648 
        else:
24649 
          iprot.skip(ftype)
24650 
      else:
24651 
        iprot.skip(ftype)
24652 
      iprot.readFieldEnd()
24653 
    iprot.readStructEnd()
24654 
 
24655 
  def write(self, oprot):
24656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24658 
      return
24659 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24660 
    if self.orderIds is not None:
24661 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24662 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24663 
      for iter576 in self.orderIds:
24664 
        oprot.writeI64(iter576)
4715 varun.gupt 24665 
      oprot.writeListEnd()
24666 
      oprot.writeFieldEnd()
24667 
    oprot.writeFieldStop()
24668 
    oprot.writeStructEnd()
24669 
 
24670 
  def validate(self):
24671 
    return
24672 
 
24673 
 
24674 
  def __repr__(self):
24675 
    L = ['%s=%r' % (key, value)
24676 
      for key, value in self.__dict__.iteritems()]
24677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24678 
 
24679 
  def __eq__(self, other):
24680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24681 
 
24682 
  def __ne__(self, other):
24683 
    return not (self == other)
24684 
 
24685 
class getReshippedOrderIds_result:
24686 
  """
24687 
  Attributes:
24688 
   - success
24689 
   - ex
24690 
  """
24691 
 
24692 
  thrift_spec = (
24693 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24695 
  )
24696 
 
24697 
  def __init__(self, success=None, ex=None,):
24698 
    self.success = success
24699 
    self.ex = ex
24700 
 
24701 
  def read(self, iprot):
24702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24704 
      return
24705 
    iprot.readStructBegin()
24706 
    while True:
24707 
      (fname, ftype, fid) = iprot.readFieldBegin()
24708 
      if ftype == TType.STOP:
24709 
        break
24710 
      if fid == 0:
24711 
        if ftype == TType.LIST:
24712 
          self.success = []
6188 rajveer 24713 
          (_etype580, _size577) = iprot.readListBegin()
24714 
          for _i581 in xrange(_size577):
24715 
            _elem582 = iprot.readI64();
24716 
            self.success.append(_elem582)
4715 varun.gupt 24717 
          iprot.readListEnd()
24718 
        else:
24719 
          iprot.skip(ftype)
24720 
      elif fid == 1:
24721 
        if ftype == TType.STRUCT:
24722 
          self.ex = TransactionServiceException()
24723 
          self.ex.read(iprot)
24724 
        else:
24725 
          iprot.skip(ftype)
24726 
      else:
24727 
        iprot.skip(ftype)
24728 
      iprot.readFieldEnd()
24729 
    iprot.readStructEnd()
24730 
 
24731 
  def write(self, oprot):
24732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24734 
      return
24735 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24736 
    if self.success is not None:
24737 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24738 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24739 
      for iter583 in self.success:
24740 
        oprot.writeI64(iter583)
4715 varun.gupt 24741 
      oprot.writeListEnd()
24742 
      oprot.writeFieldEnd()
24743 
    if self.ex is not None:
24744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24745 
      self.ex.write(oprot)
24746 
      oprot.writeFieldEnd()
24747 
    oprot.writeFieldStop()
24748 
    oprot.writeStructEnd()
24749 
 
24750 
  def validate(self):
24751 
    return
24752 
 
24753 
 
24754 
  def __repr__(self):
24755 
    L = ['%s=%r' % (key, value)
24756 
      for key, value in self.__dict__.iteritems()]
24757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24758 
 
24759 
  def __eq__(self, other):
24760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24761 
 
24762 
  def __ne__(self, other):
24763 
    return not (self == other)
4757 mandeep.dh 24764 
 
5481 phani.kuma 24765 
class getBilledOrders_args:
4875 varun.gupt 24766 
  """
24767 
  Attributes:
24768 
   - vendorId
5481 phani.kuma 24769 
   - onlyVendorNotPaid
24770 
   - billingDateFrom
24771 
   - billingDateTo
4875 varun.gupt 24772 
  """
24773 
 
24774 
  thrift_spec = (
24775 
    None, # 0
24776 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24777 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24778 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24779 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24780 
  )
24781 
 
5481 phani.kuma 24782 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24783 
    self.vendorId = vendorId
5481 phani.kuma 24784 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24785 
    self.billingDateFrom = billingDateFrom
24786 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24787 
 
24788 
  def read(self, iprot):
24789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24791 
      return
24792 
    iprot.readStructBegin()
24793 
    while True:
24794 
      (fname, ftype, fid) = iprot.readFieldBegin()
24795 
      if ftype == TType.STOP:
24796 
        break
24797 
      if fid == 1:
24798 
        if ftype == TType.I64:
24799 
          self.vendorId = iprot.readI64();
24800 
        else:
24801 
          iprot.skip(ftype)
5481 phani.kuma 24802 
      elif fid == 2:
24803 
        if ftype == TType.BOOL:
24804 
          self.onlyVendorNotPaid = iprot.readBool();
24805 
        else:
24806 
          iprot.skip(ftype)
24807 
      elif fid == 3:
24808 
        if ftype == TType.I64:
24809 
          self.billingDateFrom = iprot.readI64();
24810 
        else:
24811 
          iprot.skip(ftype)
24812 
      elif fid == 4:
24813 
        if ftype == TType.I64:
24814 
          self.billingDateTo = iprot.readI64();
24815 
        else:
24816 
          iprot.skip(ftype)
4875 varun.gupt 24817 
      else:
24818 
        iprot.skip(ftype)
24819 
      iprot.readFieldEnd()
24820 
    iprot.readStructEnd()
24821 
 
24822 
  def write(self, oprot):
24823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24825 
      return
5481 phani.kuma 24826 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24827 
    if self.vendorId is not None:
24828 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24829 
      oprot.writeI64(self.vendorId)
24830 
      oprot.writeFieldEnd()
5481 phani.kuma 24831 
    if self.onlyVendorNotPaid is not None:
24832 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24833 
      oprot.writeBool(self.onlyVendorNotPaid)
24834 
      oprot.writeFieldEnd()
24835 
    if self.billingDateFrom is not None:
24836 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24837 
      oprot.writeI64(self.billingDateFrom)
24838 
      oprot.writeFieldEnd()
24839 
    if self.billingDateTo is not None:
24840 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24841 
      oprot.writeI64(self.billingDateTo)
24842 
      oprot.writeFieldEnd()
4875 varun.gupt 24843 
    oprot.writeFieldStop()
24844 
    oprot.writeStructEnd()
24845 
 
24846 
  def validate(self):
24847 
    return
24848 
 
24849 
 
24850 
  def __repr__(self):
24851 
    L = ['%s=%r' % (key, value)
24852 
      for key, value in self.__dict__.iteritems()]
24853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24854 
 
24855 
  def __eq__(self, other):
24856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24857 
 
24858 
  def __ne__(self, other):
24859 
    return not (self == other)
24860 
 
5481 phani.kuma 24861 
class getBilledOrders_result:
4875 varun.gupt 24862 
  """
24863 
  Attributes:
24864 
   - success
24865 
   - ex
24866 
  """
24867 
 
24868 
  thrift_spec = (
24869 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24871 
  )
24872 
 
24873 
  def __init__(self, success=None, ex=None,):
24874 
    self.success = success
24875 
    self.ex = ex
24876 
 
24877 
  def read(self, iprot):
24878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24880 
      return
24881 
    iprot.readStructBegin()
24882 
    while True:
24883 
      (fname, ftype, fid) = iprot.readFieldBegin()
24884 
      if ftype == TType.STOP:
24885 
        break
24886 
      if fid == 0:
24887 
        if ftype == TType.LIST:
24888 
          self.success = []
6188 rajveer 24889 
          (_etype587, _size584) = iprot.readListBegin()
24890 
          for _i588 in xrange(_size584):
24891 
            _elem589 = Order()
24892 
            _elem589.read(iprot)
24893 
            self.success.append(_elem589)
4875 varun.gupt 24894 
          iprot.readListEnd()
24895 
        else:
24896 
          iprot.skip(ftype)
24897 
      elif fid == 1:
24898 
        if ftype == TType.STRUCT:
24899 
          self.ex = TransactionServiceException()
24900 
          self.ex.read(iprot)
24901 
        else:
24902 
          iprot.skip(ftype)
24903 
      else:
24904 
        iprot.skip(ftype)
24905 
      iprot.readFieldEnd()
24906 
    iprot.readStructEnd()
24907 
 
24908 
  def write(self, oprot):
24909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24911 
      return
5481 phani.kuma 24912 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24913 
    if self.success is not None:
24914 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24915 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24916 
      for iter590 in self.success:
24917 
        iter590.write(oprot)
4875 varun.gupt 24918 
      oprot.writeListEnd()
24919 
      oprot.writeFieldEnd()
24920 
    if self.ex is not None:
24921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24922 
      self.ex.write(oprot)
24923 
      oprot.writeFieldEnd()
24924 
    oprot.writeFieldStop()
24925 
    oprot.writeStructEnd()
24926 
 
24927 
  def validate(self):
24928 
    return
24929 
 
24930 
 
24931 
  def __repr__(self):
24932 
    L = ['%s=%r' % (key, value)
24933 
      for key, value in self.__dict__.iteritems()]
24934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24935 
 
24936 
  def __eq__(self, other):
24937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24938 
 
24939 
  def __ne__(self, other):
24940 
    return not (self == other)
5031 varun.gupt 24941 
 
24942 
class getStatusDistributionOfOrders_args:
24943 
  """
24944 
  Attributes:
24945 
   - startDate
24946 
   - endDate
24947 
  """
24948 
 
24949 
  thrift_spec = (
24950 
    None, # 0
24951 
    (1, TType.I64, 'startDate', None, None, ), # 1
24952 
    (2, TType.I64, 'endDate', None, None, ), # 2
24953 
  )
24954 
 
24955 
  def __init__(self, startDate=None, endDate=None,):
24956 
    self.startDate = startDate
24957 
    self.endDate = endDate
24958 
 
24959 
  def read(self, iprot):
24960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24962 
      return
24963 
    iprot.readStructBegin()
24964 
    while True:
24965 
      (fname, ftype, fid) = iprot.readFieldBegin()
24966 
      if ftype == TType.STOP:
24967 
        break
24968 
      if fid == 1:
24969 
        if ftype == TType.I64:
24970 
          self.startDate = iprot.readI64();
24971 
        else:
24972 
          iprot.skip(ftype)
24973 
      elif fid == 2:
24974 
        if ftype == TType.I64:
24975 
          self.endDate = iprot.readI64();
24976 
        else:
24977 
          iprot.skip(ftype)
24978 
      else:
24979 
        iprot.skip(ftype)
24980 
      iprot.readFieldEnd()
24981 
    iprot.readStructEnd()
24982 
 
24983 
  def write(self, oprot):
24984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24986 
      return
24987 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24988 
    if self.startDate is not None:
24989 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24990 
      oprot.writeI64(self.startDate)
24991 
      oprot.writeFieldEnd()
24992 
    if self.endDate is not None:
24993 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24994 
      oprot.writeI64(self.endDate)
24995 
      oprot.writeFieldEnd()
24996 
    oprot.writeFieldStop()
24997 
    oprot.writeStructEnd()
24998 
 
24999 
  def validate(self):
25000 
    return
25001 
 
25002 
 
25003 
  def __repr__(self):
25004 
    L = ['%s=%r' % (key, value)
25005 
      for key, value in self.__dict__.iteritems()]
25006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25007 
 
25008 
  def __eq__(self, other):
25009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25010 
 
25011 
  def __ne__(self, other):
25012 
    return not (self == other)
25013 
 
25014 
class getStatusDistributionOfOrders_result:
25015 
  """
25016 
  Attributes:
25017 
   - success
25018 
   - ex
25019 
  """
25020 
 
25021 
  thrift_spec = (
25022 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25024 
  )
25025 
 
25026 
  def __init__(self, success=None, ex=None,):
25027 
    self.success = success
25028 
    self.ex = ex
25029 
 
25030 
  def read(self, iprot):
25031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25033 
      return
25034 
    iprot.readStructBegin()
25035 
    while True:
25036 
      (fname, ftype, fid) = iprot.readFieldBegin()
25037 
      if ftype == TType.STOP:
25038 
        break
25039 
      if fid == 0:
25040 
        if ftype == TType.MAP:
25041 
          self.success = {}
6188 rajveer 25042 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25043 
          for _i595 in xrange(_size591):
25044 
            _key596 = iprot.readI64();
25045 
            _val597 = iprot.readI64();
25046 
            self.success[_key596] = _val597
5031 varun.gupt 25047 
          iprot.readMapEnd()
25048 
        else:
25049 
          iprot.skip(ftype)
25050 
      elif fid == 1:
25051 
        if ftype == TType.STRUCT:
25052 
          self.ex = TransactionServiceException()
25053 
          self.ex.read(iprot)
25054 
        else:
25055 
          iprot.skip(ftype)
25056 
      else:
25057 
        iprot.skip(ftype)
25058 
      iprot.readFieldEnd()
25059 
    iprot.readStructEnd()
25060 
 
25061 
  def write(self, oprot):
25062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25064 
      return
25065 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25066 
    if self.success is not None:
25067 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25068 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25069 
      for kiter598,viter599 in self.success.items():
25070 
        oprot.writeI64(kiter598)
25071 
        oprot.writeI64(viter599)
5031 varun.gupt 25072 
      oprot.writeMapEnd()
25073 
      oprot.writeFieldEnd()
25074 
    if self.ex is not None:
25075 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25076 
      self.ex.write(oprot)
25077 
      oprot.writeFieldEnd()
25078 
    oprot.writeFieldStop()
25079 
    oprot.writeStructEnd()
25080 
 
25081 
  def validate(self):
25082 
    return
25083 
 
25084 
 
25085 
  def __repr__(self):
25086 
    L = ['%s=%r' % (key, value)
25087 
      for key, value in self.__dict__.iteritems()]
25088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25089 
 
25090 
  def __eq__(self, other):
25091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25092 
 
25093 
  def __ne__(self, other):
25094 
    return not (self == other)
5067 varun.gupt 25095 
 
25096 
class getOrderIdsForStatus_args:
25097 
  """
25098 
  Attributes:
25099 
   - status
25100 
   - startDatetime
25101 
   - endDatetime
25102 
  """
25103 
 
25104 
  thrift_spec = (
25105 
    None, # 0
25106 
    (1, TType.I64, 'status', None, None, ), # 1
25107 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25108 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25109 
  )
25110 
 
25111 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25112 
    self.status = status
25113 
    self.startDatetime = startDatetime
25114 
    self.endDatetime = endDatetime
25115 
 
25116 
  def read(self, iprot):
25117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25119 
      return
25120 
    iprot.readStructBegin()
25121 
    while True:
25122 
      (fname, ftype, fid) = iprot.readFieldBegin()
25123 
      if ftype == TType.STOP:
25124 
        break
25125 
      if fid == 1:
25126 
        if ftype == TType.I64:
25127 
          self.status = iprot.readI64();
25128 
        else:
25129 
          iprot.skip(ftype)
25130 
      elif fid == 2:
25131 
        if ftype == TType.I64:
25132 
          self.startDatetime = iprot.readI64();
25133 
        else:
25134 
          iprot.skip(ftype)
25135 
      elif fid == 3:
25136 
        if ftype == TType.I64:
25137 
          self.endDatetime = iprot.readI64();
25138 
        else:
25139 
          iprot.skip(ftype)
25140 
      else:
25141 
        iprot.skip(ftype)
25142 
      iprot.readFieldEnd()
25143 
    iprot.readStructEnd()
25144 
 
25145 
  def write(self, oprot):
25146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25148 
      return
25149 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25150 
    if self.status is not None:
25151 
      oprot.writeFieldBegin('status', TType.I64, 1)
25152 
      oprot.writeI64(self.status)
25153 
      oprot.writeFieldEnd()
25154 
    if self.startDatetime is not None:
25155 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25156 
      oprot.writeI64(self.startDatetime)
25157 
      oprot.writeFieldEnd()
25158 
    if self.endDatetime is not None:
25159 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25160 
      oprot.writeI64(self.endDatetime)
25161 
      oprot.writeFieldEnd()
25162 
    oprot.writeFieldStop()
25163 
    oprot.writeStructEnd()
25164 
 
25165 
  def validate(self):
25166 
    return
25167 
 
25168 
 
25169 
  def __repr__(self):
25170 
    L = ['%s=%r' % (key, value)
25171 
      for key, value in self.__dict__.iteritems()]
25172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25173 
 
25174 
  def __eq__(self, other):
25175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25176 
 
25177 
  def __ne__(self, other):
25178 
    return not (self == other)
25179 
 
25180 
class getOrderIdsForStatus_result:
25181 
  """
25182 
  Attributes:
25183 
   - success
25184 
   - ex
25185 
  """
25186 
 
25187 
  thrift_spec = (
25188 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25189 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25190 
  )
25191 
 
25192 
  def __init__(self, success=None, ex=None,):
25193 
    self.success = success
25194 
    self.ex = ex
25195 
 
25196 
  def read(self, iprot):
25197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25199 
      return
25200 
    iprot.readStructBegin()
25201 
    while True:
25202 
      (fname, ftype, fid) = iprot.readFieldBegin()
25203 
      if ftype == TType.STOP:
25204 
        break
25205 
      if fid == 0:
25206 
        if ftype == TType.LIST:
25207 
          self.success = []
6188 rajveer 25208 
          (_etype603, _size600) = iprot.readListBegin()
25209 
          for _i604 in xrange(_size600):
25210 
            _elem605 = iprot.readI64();
25211 
            self.success.append(_elem605)
5067 varun.gupt 25212 
          iprot.readListEnd()
25213 
        else:
25214 
          iprot.skip(ftype)
25215 
      elif fid == 1:
25216 
        if ftype == TType.STRUCT:
25217 
          self.ex = TransactionServiceException()
25218 
          self.ex.read(iprot)
25219 
        else:
25220 
          iprot.skip(ftype)
25221 
      else:
25222 
        iprot.skip(ftype)
25223 
      iprot.readFieldEnd()
25224 
    iprot.readStructEnd()
25225 
 
25226 
  def write(self, oprot):
25227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25229 
      return
25230 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25231 
    if self.success is not None:
25232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25233 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25234 
      for iter606 in self.success:
25235 
        oprot.writeI64(iter606)
5067 varun.gupt 25236 
      oprot.writeListEnd()
25237 
      oprot.writeFieldEnd()
25238 
    if self.ex is not None:
25239 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25240 
      self.ex.write(oprot)
25241 
      oprot.writeFieldEnd()
25242 
    oprot.writeFieldStop()
25243 
    oprot.writeStructEnd()
25244 
 
25245 
  def validate(self):
25246 
    return
25247 
 
25248 
 
25249 
  def __repr__(self):
25250 
    L = ['%s=%r' % (key, value)
25251 
      for key, value in self.__dict__.iteritems()]
25252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25253 
 
25254 
  def __eq__(self, other):
25255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25256 
 
25257 
  def __ne__(self, other):
25258 
    return not (self == other)
5099 varun.gupt 25259 
 
5348 anupam.sin 25260 
class updateCODAgent_args:
25261 
  """
25262 
  Attributes:
25263 
   - agent
25264 
   - orderId
25265 
  """
25266 
 
25267 
  thrift_spec = (
25268 
    None, # 0
25269 
    (1, TType.STRING, 'agent', None, None, ), # 1
25270 
    (2, TType.I64, 'orderId', None, None, ), # 2
25271 
  )
25272 
 
25273 
  def __init__(self, agent=None, orderId=None,):
25274 
    self.agent = agent
25275 
    self.orderId = orderId
25276 
 
25277 
  def read(self, iprot):
25278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25280 
      return
25281 
    iprot.readStructBegin()
25282 
    while True:
25283 
      (fname, ftype, fid) = iprot.readFieldBegin()
25284 
      if ftype == TType.STOP:
25285 
        break
25286 
      if fid == 1:
25287 
        if ftype == TType.STRING:
25288 
          self.agent = iprot.readString();
25289 
        else:
25290 
          iprot.skip(ftype)
25291 
      elif fid == 2:
25292 
        if ftype == TType.I64:
25293 
          self.orderId = iprot.readI64();
25294 
        else:
25295 
          iprot.skip(ftype)
25296 
      else:
25297 
        iprot.skip(ftype)
25298 
      iprot.readFieldEnd()
25299 
    iprot.readStructEnd()
25300 
 
25301 
  def write(self, oprot):
25302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25304 
      return
25305 
    oprot.writeStructBegin('updateCODAgent_args')
25306 
    if self.agent is not None:
25307 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25308 
      oprot.writeString(self.agent)
25309 
      oprot.writeFieldEnd()
25310 
    if self.orderId is not None:
25311 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25312 
      oprot.writeI64(self.orderId)
25313 
      oprot.writeFieldEnd()
25314 
    oprot.writeFieldStop()
25315 
    oprot.writeStructEnd()
25316 
 
25317 
  def validate(self):
25318 
    return
25319 
 
25320 
 
25321 
  def __repr__(self):
25322 
    L = ['%s=%r' % (key, value)
25323 
      for key, value in self.__dict__.iteritems()]
25324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25325 
 
25326 
  def __eq__(self, other):
25327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25328 
 
25329 
  def __ne__(self, other):
25330 
    return not (self == other)
25331 
 
25332 
class updateCODAgent_result:
25333 
  """
25334 
  Attributes:
25335 
   - ex
25336 
  """
25337 
 
25338 
  thrift_spec = (
25339 
    None, # 0
25340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25341 
  )
25342 
 
25343 
  def __init__(self, ex=None,):
25344 
    self.ex = ex
25345 
 
25346 
  def read(self, iprot):
25347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25349 
      return
25350 
    iprot.readStructBegin()
25351 
    while True:
25352 
      (fname, ftype, fid) = iprot.readFieldBegin()
25353 
      if ftype == TType.STOP:
25354 
        break
25355 
      if fid == 1:
25356 
        if ftype == TType.STRUCT:
25357 
          self.ex = TransactionServiceException()
25358 
          self.ex.read(iprot)
25359 
        else:
25360 
          iprot.skip(ftype)
25361 
      else:
25362 
        iprot.skip(ftype)
25363 
      iprot.readFieldEnd()
25364 
    iprot.readStructEnd()
25365 
 
25366 
  def write(self, oprot):
25367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25369 
      return
25370 
    oprot.writeStructBegin('updateCODAgent_result')
25371 
    if self.ex is not None:
25372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25373 
      self.ex.write(oprot)
25374 
      oprot.writeFieldEnd()
25375 
    oprot.writeFieldStop()
25376 
    oprot.writeStructEnd()
25377 
 
25378 
  def validate(self):
25379 
    return
25380 
 
25381 
 
25382 
  def __repr__(self):
25383 
    L = ['%s=%r' % (key, value)
25384 
      for key, value in self.__dict__.iteritems()]
25385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25386 
 
25387 
  def __eq__(self, other):
25388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25389 
 
25390 
  def __ne__(self, other):
25391 
    return not (self == other)
25392 
 
5099 varun.gupt 25393 
class updateOrderAsPaidToVendor_args:
25394 
  """
25395 
  Attributes:
25396 
   - orderId
25397 
  """
25398 
 
25399 
  thrift_spec = (
25400 
    None, # 0
25401 
    (1, TType.I64, 'orderId', None, None, ), # 1
25402 
  )
25403 
 
25404 
  def __init__(self, orderId=None,):
25405 
    self.orderId = orderId
25406 
 
25407 
  def read(self, iprot):
25408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25410 
      return
25411 
    iprot.readStructBegin()
25412 
    while True:
25413 
      (fname, ftype, fid) = iprot.readFieldBegin()
25414 
      if ftype == TType.STOP:
25415 
        break
25416 
      if fid == 1:
25417 
        if ftype == TType.I64:
25418 
          self.orderId = iprot.readI64();
25419 
        else:
25420 
          iprot.skip(ftype)
25421 
      else:
25422 
        iprot.skip(ftype)
25423 
      iprot.readFieldEnd()
25424 
    iprot.readStructEnd()
25425 
 
25426 
  def write(self, oprot):
25427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25429 
      return
25430 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25431 
    if self.orderId is not None:
25432 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25433 
      oprot.writeI64(self.orderId)
25434 
      oprot.writeFieldEnd()
25435 
    oprot.writeFieldStop()
25436 
    oprot.writeStructEnd()
25437 
 
25438 
  def validate(self):
25439 
    return
25440 
 
25441 
 
25442 
  def __repr__(self):
25443 
    L = ['%s=%r' % (key, value)
25444 
      for key, value in self.__dict__.iteritems()]
25445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25446 
 
25447 
  def __eq__(self, other):
25448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25449 
 
25450 
  def __ne__(self, other):
25451 
    return not (self == other)
25452 
 
25453 
class updateOrderAsPaidToVendor_result:
25454 
  """
25455 
  Attributes:
25456 
   - ex
25457 
  """
25458 
 
25459 
  thrift_spec = (
25460 
    None, # 0
25461 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25462 
  )
25463 
 
25464 
  def __init__(self, ex=None,):
25465 
    self.ex = ex
25466 
 
25467 
  def read(self, iprot):
25468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25470 
      return
25471 
    iprot.readStructBegin()
25472 
    while True:
25473 
      (fname, ftype, fid) = iprot.readFieldBegin()
25474 
      if ftype == TType.STOP:
25475 
        break
25476 
      if fid == 1:
25477 
        if ftype == TType.STRUCT:
25478 
          self.ex = TransactionServiceException()
25479 
          self.ex.read(iprot)
25480 
        else:
25481 
          iprot.skip(ftype)
25482 
      else:
25483 
        iprot.skip(ftype)
25484 
      iprot.readFieldEnd()
25485 
    iprot.readStructEnd()
25486 
 
25487 
  def write(self, oprot):
25488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25490 
      return
25491 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25492 
    if self.ex is not None:
25493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25494 
      self.ex.write(oprot)
25495 
      oprot.writeFieldEnd()
25496 
    oprot.writeFieldStop()
25497 
    oprot.writeStructEnd()
25498 
 
25499 
  def validate(self):
25500 
    return
25501 
 
25502 
 
25503 
  def __repr__(self):
25504 
    L = ['%s=%r' % (key, value)
25505 
      for key, value in self.__dict__.iteritems()]
25506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25507 
 
25508 
  def __eq__(self, other):
25509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25510 
 
25511 
  def __ne__(self, other):
25512 
    return not (self == other)
5208 varun.gupt 25513 
 
5386 phani.kuma 25514 
class updateOrderOnlyAsPaidToVendor_args:
25515 
  """
25516 
  Attributes:
25517 
   - orderId
25518 
  """
25519 
 
25520 
  thrift_spec = (
25521 
    None, # 0
25522 
    (1, TType.I64, 'orderId', None, None, ), # 1
25523 
  )
25524 
 
25525 
  def __init__(self, orderId=None,):
25526 
    self.orderId = orderId
25527 
 
25528 
  def read(self, iprot):
25529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25531 
      return
25532 
    iprot.readStructBegin()
25533 
    while True:
25534 
      (fname, ftype, fid) = iprot.readFieldBegin()
25535 
      if ftype == TType.STOP:
25536 
        break
25537 
      if fid == 1:
25538 
        if ftype == TType.I64:
25539 
          self.orderId = iprot.readI64();
25540 
        else:
25541 
          iprot.skip(ftype)
25542 
      else:
25543 
        iprot.skip(ftype)
25544 
      iprot.readFieldEnd()
25545 
    iprot.readStructEnd()
25546 
 
25547 
  def write(self, oprot):
25548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25550 
      return
25551 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25552 
    if self.orderId is not None:
25553 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25554 
      oprot.writeI64(self.orderId)
25555 
      oprot.writeFieldEnd()
25556 
    oprot.writeFieldStop()
25557 
    oprot.writeStructEnd()
25558 
 
25559 
  def validate(self):
25560 
    return
25561 
 
25562 
 
25563 
  def __repr__(self):
25564 
    L = ['%s=%r' % (key, value)
25565 
      for key, value in self.__dict__.iteritems()]
25566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25567 
 
25568 
  def __eq__(self, other):
25569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25570 
 
25571 
  def __ne__(self, other):
25572 
    return not (self == other)
25573 
 
25574 
class updateOrderOnlyAsPaidToVendor_result:
25575 
  """
25576 
  Attributes:
25577 
   - ex
25578 
  """
25579 
 
25580 
  thrift_spec = (
25581 
    None, # 0
25582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25583 
  )
25584 
 
25585 
  def __init__(self, ex=None,):
25586 
    self.ex = ex
25587 
 
25588 
  def read(self, iprot):
25589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25591 
      return
25592 
    iprot.readStructBegin()
25593 
    while True:
25594 
      (fname, ftype, fid) = iprot.readFieldBegin()
25595 
      if ftype == TType.STOP:
25596 
        break
25597 
      if fid == 1:
25598 
        if ftype == TType.STRUCT:
25599 
          self.ex = TransactionServiceException()
25600 
          self.ex.read(iprot)
25601 
        else:
25602 
          iprot.skip(ftype)
25603 
      else:
25604 
        iprot.skip(ftype)
25605 
      iprot.readFieldEnd()
25606 
    iprot.readStructEnd()
25607 
 
25608 
  def write(self, oprot):
25609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25611 
      return
25612 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25613 
    if self.ex is not None:
25614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25615 
      self.ex.write(oprot)
25616 
      oprot.writeFieldEnd()
25617 
    oprot.writeFieldStop()
25618 
    oprot.writeStructEnd()
25619 
 
25620 
  def validate(self):
25621 
    return
25622 
 
25623 
 
25624 
  def __repr__(self):
25625 
    L = ['%s=%r' % (key, value)
25626 
      for key, value in self.__dict__.iteritems()]
25627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25628 
 
25629 
  def __eq__(self, other):
25630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25631 
 
25632 
  def __ne__(self, other):
25633 
    return not (self == other)
25634 
 
5208 varun.gupt 25635 
class getRefundedOrdersMarkedPaid_args:
25636 
 
25637 
  thrift_spec = (
25638 
  )
25639 
 
25640 
  def read(self, iprot):
25641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25643 
      return
25644 
    iprot.readStructBegin()
25645 
    while True:
25646 
      (fname, ftype, fid) = iprot.readFieldBegin()
25647 
      if ftype == TType.STOP:
25648 
        break
25649 
      else:
25650 
        iprot.skip(ftype)
25651 
      iprot.readFieldEnd()
25652 
    iprot.readStructEnd()
25653 
 
25654 
  def write(self, oprot):
25655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25657 
      return
25658 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25659 
    oprot.writeFieldStop()
25660 
    oprot.writeStructEnd()
25661 
 
25662 
  def validate(self):
25663 
    return
25664 
 
25665 
 
25666 
  def __repr__(self):
25667 
    L = ['%s=%r' % (key, value)
25668 
      for key, value in self.__dict__.iteritems()]
25669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25670 
 
25671 
  def __eq__(self, other):
25672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25673 
 
25674 
  def __ne__(self, other):
25675 
    return not (self == other)
25676 
 
25677 
class getRefundedOrdersMarkedPaid_result:
25678 
  """
25679 
  Attributes:
25680 
   - success
25681 
   - ex
25682 
  """
25683 
 
25684 
  thrift_spec = (
25685 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25687 
  )
25688 
 
25689 
  def __init__(self, success=None, ex=None,):
25690 
    self.success = success
25691 
    self.ex = ex
25692 
 
25693 
  def read(self, iprot):
25694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25696 
      return
25697 
    iprot.readStructBegin()
25698 
    while True:
25699 
      (fname, ftype, fid) = iprot.readFieldBegin()
25700 
      if ftype == TType.STOP:
25701 
        break
25702 
      if fid == 0:
25703 
        if ftype == TType.LIST:
25704 
          self.success = []
6188 rajveer 25705 
          (_etype610, _size607) = iprot.readListBegin()
25706 
          for _i611 in xrange(_size607):
25707 
            _elem612 = Order()
25708 
            _elem612.read(iprot)
25709 
            self.success.append(_elem612)
5208 varun.gupt 25710 
          iprot.readListEnd()
25711 
        else:
25712 
          iprot.skip(ftype)
25713 
      elif fid == 1:
25714 
        if ftype == TType.STRUCT:
25715 
          self.ex = TransactionServiceException()
25716 
          self.ex.read(iprot)
25717 
        else:
25718 
          iprot.skip(ftype)
25719 
      else:
25720 
        iprot.skip(ftype)
25721 
      iprot.readFieldEnd()
25722 
    iprot.readStructEnd()
25723 
 
25724 
  def write(self, oprot):
25725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25727 
      return
25728 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25729 
    if self.success is not None:
25730 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25731 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25732 
      for iter613 in self.success:
25733 
        iter613.write(oprot)
5208 varun.gupt 25734 
      oprot.writeListEnd()
25735 
      oprot.writeFieldEnd()
25736 
    if self.ex is not None:
25737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25738 
      self.ex.write(oprot)
25739 
      oprot.writeFieldEnd()
25740 
    oprot.writeFieldStop()
25741 
    oprot.writeStructEnd()
25742 
 
25743 
  def validate(self):
25744 
    return
25745 
 
25746 
 
25747 
  def __repr__(self):
25748 
    L = ['%s=%r' % (key, value)
25749 
      for key, value in self.__dict__.iteritems()]
25750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25751 
 
25752 
  def __eq__(self, other):
25753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25754 
 
25755 
  def __ne__(self, other):
25756 
    return not (self == other)
5447 anupam.sin 25757 
 
25758 
class getAllVerificationAgents_args:
25759 
  """
25760 
  Attributes:
25761 
   - minOrderId
25762 
   - maxOrderId
25763 
  """
25764 
 
25765 
  thrift_spec = (
25766 
    None, # 0
25767 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25768 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25769 
  )
25770 
 
25771 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25772 
    self.minOrderId = minOrderId
25773 
    self.maxOrderId = maxOrderId
25774 
 
25775 
  def read(self, iprot):
25776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25778 
      return
25779 
    iprot.readStructBegin()
25780 
    while True:
25781 
      (fname, ftype, fid) = iprot.readFieldBegin()
25782 
      if ftype == TType.STOP:
25783 
        break
25784 
      if fid == 1:
25785 
        if ftype == TType.I64:
25786 
          self.minOrderId = iprot.readI64();
25787 
        else:
25788 
          iprot.skip(ftype)
25789 
      elif fid == 2:
25790 
        if ftype == TType.I64:
25791 
          self.maxOrderId = iprot.readI64();
25792 
        else:
25793 
          iprot.skip(ftype)
25794 
      else:
25795 
        iprot.skip(ftype)
25796 
      iprot.readFieldEnd()
25797 
    iprot.readStructEnd()
25798 
 
25799 
  def write(self, oprot):
25800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25802 
      return
25803 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25804 
    if self.minOrderId is not None:
25805 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25806 
      oprot.writeI64(self.minOrderId)
25807 
      oprot.writeFieldEnd()
25808 
    if self.maxOrderId is not None:
25809 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25810 
      oprot.writeI64(self.maxOrderId)
25811 
      oprot.writeFieldEnd()
25812 
    oprot.writeFieldStop()
25813 
    oprot.writeStructEnd()
25814 
 
25815 
  def validate(self):
25816 
    return
25817 
 
25818 
 
25819 
  def __repr__(self):
25820 
    L = ['%s=%r' % (key, value)
25821 
      for key, value in self.__dict__.iteritems()]
25822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25823 
 
25824 
  def __eq__(self, other):
25825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25826 
 
25827 
  def __ne__(self, other):
25828 
    return not (self == other)
25829 
 
25830 
class getAllVerificationAgents_result:
25831 
  """
25832 
  Attributes:
25833 
   - success
25834 
  """
25835 
 
25836 
  thrift_spec = (
25837 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25838 
  )
25839 
 
25840 
  def __init__(self, success=None,):
25841 
    self.success = success
25842 
 
25843 
  def read(self, iprot):
25844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25846 
      return
25847 
    iprot.readStructBegin()
25848 
    while True:
25849 
      (fname, ftype, fid) = iprot.readFieldBegin()
25850 
      if ftype == TType.STOP:
25851 
        break
25852 
      if fid == 0:
25853 
        if ftype == TType.LIST:
25854 
          self.success = []
6188 rajveer 25855 
          (_etype617, _size614) = iprot.readListBegin()
25856 
          for _i618 in xrange(_size614):
25857 
            _elem619 = CODVerificationAgent()
25858 
            _elem619.read(iprot)
25859 
            self.success.append(_elem619)
5447 anupam.sin 25860 
          iprot.readListEnd()
25861 
        else:
25862 
          iprot.skip(ftype)
25863 
      else:
25864 
        iprot.skip(ftype)
25865 
      iprot.readFieldEnd()
25866 
    iprot.readStructEnd()
25867 
 
25868 
  def write(self, oprot):
25869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25871 
      return
25872 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25873 
    if self.success is not None:
25874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25876 
      for iter620 in self.success:
25877 
        iter620.write(oprot)
5447 anupam.sin 25878 
      oprot.writeListEnd()
25879 
      oprot.writeFieldEnd()
25880 
    oprot.writeFieldStop()
25881 
    oprot.writeStructEnd()
25882 
 
25883 
  def validate(self):
25884 
    return
25885 
 
25886 
 
25887 
  def __repr__(self):
25888 
    L = ['%s=%r' % (key, value)
25889 
      for key, value in self.__dict__.iteritems()]
25890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25891 
 
25892 
  def __eq__(self, other):
25893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25894 
 
25895 
  def __ne__(self, other):
25896 
    return not (self == other)
5527 anupam.sin 25897 
 
25898 
class getAllAttributesForOrderId_args:
25899 
  """
25900 
  Attributes:
25901 
   - orderId
25902 
  """
25903 
 
25904 
  thrift_spec = (
25905 
    None, # 0
25906 
    (1, TType.I64, 'orderId', None, None, ), # 1
25907 
  )
25908 
 
25909 
  def __init__(self, orderId=None,):
25910 
    self.orderId = orderId
25911 
 
25912 
  def read(self, iprot):
25913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25915 
      return
25916 
    iprot.readStructBegin()
25917 
    while True:
25918 
      (fname, ftype, fid) = iprot.readFieldBegin()
25919 
      if ftype == TType.STOP:
25920 
        break
25921 
      if fid == 1:
25922 
        if ftype == TType.I64:
25923 
          self.orderId = iprot.readI64();
25924 
        else:
25925 
          iprot.skip(ftype)
25926 
      else:
25927 
        iprot.skip(ftype)
25928 
      iprot.readFieldEnd()
25929 
    iprot.readStructEnd()
25930 
 
25931 
  def write(self, oprot):
25932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25934 
      return
25935 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25936 
    if self.orderId is not None:
25937 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25938 
      oprot.writeI64(self.orderId)
25939 
      oprot.writeFieldEnd()
25940 
    oprot.writeFieldStop()
25941 
    oprot.writeStructEnd()
25942 
 
25943 
  def validate(self):
25944 
    return
25945 
 
25946 
 
25947 
  def __repr__(self):
25948 
    L = ['%s=%r' % (key, value)
25949 
      for key, value in self.__dict__.iteritems()]
25950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25951 
 
25952 
  def __eq__(self, other):
25953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25954 
 
25955 
  def __ne__(self, other):
25956 
    return not (self == other)
25957 
 
25958 
class getAllAttributesForOrderId_result:
25959 
  """
25960 
  Attributes:
25961 
   - success
25962 
  """
25963 
 
25964 
  thrift_spec = (
25965 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25966 
  )
25967 
 
25968 
  def __init__(self, success=None,):
25969 
    self.success = success
25970 
 
25971 
  def read(self, iprot):
25972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25974 
      return
25975 
    iprot.readStructBegin()
25976 
    while True:
25977 
      (fname, ftype, fid) = iprot.readFieldBegin()
25978 
      if ftype == TType.STOP:
25979 
        break
25980 
      if fid == 0:
25981 
        if ftype == TType.LIST:
25982 
          self.success = []
6188 rajveer 25983 
          (_etype624, _size621) = iprot.readListBegin()
25984 
          for _i625 in xrange(_size621):
25985 
            _elem626 = Attribute()
25986 
            _elem626.read(iprot)
25987 
            self.success.append(_elem626)
5527 anupam.sin 25988 
          iprot.readListEnd()
25989 
        else:
25990 
          iprot.skip(ftype)
25991 
      else:
25992 
        iprot.skip(ftype)
25993 
      iprot.readFieldEnd()
25994 
    iprot.readStructEnd()
25995 
 
25996 
  def write(self, oprot):
25997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25999 
      return
26000 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26001 
    if self.success is not None:
26002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26004 
      for iter627 in self.success:
26005 
        iter627.write(oprot)
5527 anupam.sin 26006 
      oprot.writeListEnd()
26007 
      oprot.writeFieldEnd()
26008 
    oprot.writeFieldStop()
26009 
    oprot.writeStructEnd()
26010 
 
26011 
  def validate(self):
26012 
    return
26013 
 
26014 
 
26015 
  def __repr__(self):
26016 
    L = ['%s=%r' % (key, value)
26017 
      for key, value in self.__dict__.iteritems()]
26018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26019 
 
26020 
  def __eq__(self, other):
26021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26022 
 
26023 
  def __ne__(self, other):
26024 
    return not (self == other)
26025 
 
5676 rajveer 26026 
class setOrderAttributes_args:
26027 
  """
26028 
  Attributes:
26029 
   - orderId
26030 
   - attributes
26031 
  """
26032 
 
26033 
  thrift_spec = None
26034 
  def __init__(self, orderId=None, attributes=None,):
26035 
    self.orderId = orderId
26036 
    self.attributes = attributes
26037 
 
26038 
  def read(self, iprot):
26039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26041 
      return
26042 
    iprot.readStructBegin()
26043 
    while True:
26044 
      (fname, ftype, fid) = iprot.readFieldBegin()
26045 
      if ftype == TType.STOP:
26046 
        break
26047 
      if fid == 1:
26048 
        if ftype == TType.I64:
26049 
          self.orderId = iprot.readI64();
26050 
        else:
26051 
          iprot.skip(ftype)
26052 
      elif fid == -1:
26053 
        if ftype == TType.LIST:
26054 
          self.attributes = []
6188 rajveer 26055 
          (_etype631, _size628) = iprot.readListBegin()
26056 
          for _i632 in xrange(_size628):
26057 
            _elem633 = Attribute()
26058 
            _elem633.read(iprot)
26059 
            self.attributes.append(_elem633)
5676 rajveer 26060 
          iprot.readListEnd()
26061 
        else:
26062 
          iprot.skip(ftype)
26063 
      else:
26064 
        iprot.skip(ftype)
26065 
      iprot.readFieldEnd()
26066 
    iprot.readStructEnd()
26067 
 
26068 
  def write(self, oprot):
26069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26071 
      return
26072 
    oprot.writeStructBegin('setOrderAttributes_args')
26073 
    if self.attributes is not None:
26074 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26075 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26076 
      for iter634 in self.attributes:
26077 
        iter634.write(oprot)
5676 rajveer 26078 
      oprot.writeListEnd()
26079 
      oprot.writeFieldEnd()
26080 
    if self.orderId is not None:
26081 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26082 
      oprot.writeI64(self.orderId)
26083 
      oprot.writeFieldEnd()
26084 
    oprot.writeFieldStop()
26085 
    oprot.writeStructEnd()
26086 
 
26087 
  def validate(self):
26088 
    return
26089 
 
26090 
 
26091 
  def __repr__(self):
26092 
    L = ['%s=%r' % (key, value)
26093 
      for key, value in self.__dict__.iteritems()]
26094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26095 
 
26096 
  def __eq__(self, other):
26097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26098 
 
26099 
  def __ne__(self, other):
26100 
    return not (self == other)
26101 
 
26102 
class setOrderAttributes_result:
26103 
 
26104 
  thrift_spec = (
26105 
  )
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 
      else:
26117 
        iprot.skip(ftype)
26118 
      iprot.readFieldEnd()
26119 
    iprot.readStructEnd()
26120 
 
26121 
  def write(self, oprot):
26122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26124 
      return
26125 
    oprot.writeStructBegin('setOrderAttributes_result')
26126 
    oprot.writeFieldStop()
26127 
    oprot.writeStructEnd()
26128 
 
26129 
  def validate(self):
26130 
    return
26131 
 
26132 
 
26133 
  def __repr__(self):
26134 
    L = ['%s=%r' % (key, value)
26135 
      for key, value in self.__dict__.iteritems()]
26136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26137 
 
26138 
  def __eq__(self, other):
26139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26140 
 
26141 
  def __ne__(self, other):
26142 
    return not (self == other)
26143 
 
5527 anupam.sin 26144 
class setOrderAttributeForTransaction_args:
26145 
  """
26146 
  Attributes:
26147 
   - transactionId
26148 
   - attribute
26149 
  """
26150 
 
26151 
  thrift_spec = None
26152 
  def __init__(self, transactionId=None, attribute=None,):
26153 
    self.transactionId = transactionId
26154 
    self.attribute = attribute
26155 
 
26156 
  def read(self, iprot):
26157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26159 
      return
26160 
    iprot.readStructBegin()
26161 
    while True:
26162 
      (fname, ftype, fid) = iprot.readFieldBegin()
26163 
      if ftype == TType.STOP:
26164 
        break
26165 
      if fid == 1:
26166 
        if ftype == TType.I64:
26167 
          self.transactionId = iprot.readI64();
26168 
        else:
26169 
          iprot.skip(ftype)
26170 
      elif fid == -1:
26171 
        if ftype == TType.STRUCT:
26172 
          self.attribute = Attribute()
26173 
          self.attribute.read(iprot)
26174 
        else:
26175 
          iprot.skip(ftype)
26176 
      else:
26177 
        iprot.skip(ftype)
26178 
      iprot.readFieldEnd()
26179 
    iprot.readStructEnd()
26180 
 
26181 
  def write(self, oprot):
26182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26184 
      return
26185 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26186 
    if self.attribute is not None:
26187 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26188 
      self.attribute.write(oprot)
26189 
      oprot.writeFieldEnd()
26190 
    if self.transactionId is not None:
26191 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26192 
      oprot.writeI64(self.transactionId)
26193 
      oprot.writeFieldEnd()
26194 
    oprot.writeFieldStop()
26195 
    oprot.writeStructEnd()
26196 
 
26197 
  def validate(self):
26198 
    return
26199 
 
26200 
 
26201 
  def __repr__(self):
26202 
    L = ['%s=%r' % (key, value)
26203 
      for key, value in self.__dict__.iteritems()]
26204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26205 
 
26206 
  def __eq__(self, other):
26207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26208 
 
26209 
  def __ne__(self, other):
26210 
    return not (self == other)
26211 
 
26212 
class setOrderAttributeForTransaction_result:
26213 
 
26214 
  thrift_spec = (
26215 
  )
26216 
 
26217 
  def read(self, iprot):
26218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26220 
      return
26221 
    iprot.readStructBegin()
26222 
    while True:
26223 
      (fname, ftype, fid) = iprot.readFieldBegin()
26224 
      if ftype == TType.STOP:
26225 
        break
26226 
      else:
26227 
        iprot.skip(ftype)
26228 
      iprot.readFieldEnd()
26229 
    iprot.readStructEnd()
26230 
 
26231 
  def write(self, oprot):
26232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26234 
      return
26235 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26236 
    oprot.writeFieldStop()
26237 
    oprot.writeStructEnd()
26238 
 
26239 
  def validate(self):
26240 
    return
26241 
 
26242 
 
26243 
  def __repr__(self):
26244 
    L = ['%s=%r' % (key, value)
26245 
      for key, value in self.__dict__.iteritems()]
26246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26247 
 
26248 
  def __eq__(self, other):
26249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26250 
 
26251 
  def __ne__(self, other):
26252 
    return not (self == other)
5553 rajveer 26253 
 
26254 
class getReceivePendingOrders_args:
26255 
  """
26256 
  Attributes:
26257 
   - storeId
26258 
  """
26259 
 
26260 
  thrift_spec = (
26261 
    None, # 0
26262 
    (1, TType.I64, 'storeId', None, None, ), # 1
26263 
  )
26264 
 
26265 
  def __init__(self, storeId=None,):
26266 
    self.storeId = storeId
26267 
 
26268 
  def read(self, iprot):
26269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26271 
      return
26272 
    iprot.readStructBegin()
26273 
    while True:
26274 
      (fname, ftype, fid) = iprot.readFieldBegin()
26275 
      if ftype == TType.STOP:
26276 
        break
26277 
      if fid == 1:
26278 
        if ftype == TType.I64:
26279 
          self.storeId = iprot.readI64();
26280 
        else:
26281 
          iprot.skip(ftype)
26282 
      else:
26283 
        iprot.skip(ftype)
26284 
      iprot.readFieldEnd()
26285 
    iprot.readStructEnd()
26286 
 
26287 
  def write(self, oprot):
26288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26290 
      return
26291 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26292 
    if self.storeId is not None:
26293 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26294 
      oprot.writeI64(self.storeId)
26295 
      oprot.writeFieldEnd()
26296 
    oprot.writeFieldStop()
26297 
    oprot.writeStructEnd()
26298 
 
26299 
  def validate(self):
26300 
    return
26301 
 
26302 
 
26303 
  def __repr__(self):
26304 
    L = ['%s=%r' % (key, value)
26305 
      for key, value in self.__dict__.iteritems()]
26306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26307 
 
26308 
  def __eq__(self, other):
26309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26310 
 
26311 
  def __ne__(self, other):
26312 
    return not (self == other)
26313 
 
26314 
class getReceivePendingOrders_result:
26315 
  """
26316 
  Attributes:
26317 
   - success
26318 
  """
26319 
 
26320 
  thrift_spec = (
26321 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26322 
  )
26323 
 
26324 
  def __init__(self, success=None,):
26325 
    self.success = success
26326 
 
26327 
  def read(self, iprot):
26328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26330 
      return
26331 
    iprot.readStructBegin()
26332 
    while True:
26333 
      (fname, ftype, fid) = iprot.readFieldBegin()
26334 
      if ftype == TType.STOP:
26335 
        break
26336 
      if fid == 0:
26337 
        if ftype == TType.LIST:
26338 
          self.success = []
6188 rajveer 26339 
          (_etype638, _size635) = iprot.readListBegin()
26340 
          for _i639 in xrange(_size635):
26341 
            _elem640 = Order()
26342 
            _elem640.read(iprot)
26343 
            self.success.append(_elem640)
5553 rajveer 26344 
          iprot.readListEnd()
26345 
        else:
26346 
          iprot.skip(ftype)
26347 
      else:
26348 
        iprot.skip(ftype)
26349 
      iprot.readFieldEnd()
26350 
    iprot.readStructEnd()
26351 
 
26352 
  def write(self, oprot):
26353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26355 
      return
26356 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26357 
    if self.success is not None:
26358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26360 
      for iter641 in self.success:
26361 
        iter641.write(oprot)
5553 rajveer 26362 
      oprot.writeListEnd()
26363 
      oprot.writeFieldEnd()
26364 
    oprot.writeFieldStop()
26365 
    oprot.writeStructEnd()
26366 
 
26367 
  def validate(self):
26368 
    return
26369 
 
26370 
 
26371 
  def __repr__(self):
26372 
    L = ['%s=%r' % (key, value)
26373 
      for key, value in self.__dict__.iteritems()]
26374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26375 
 
26376 
  def __eq__(self, other):
26377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26378 
 
26379 
  def __ne__(self, other):
26380 
    return not (self == other)
26381 
 
26382 
class getReceivedAtStoreOrders_args:
26383 
  """
26384 
  Attributes:
26385 
   - storeId
26386 
  """
26387 
 
26388 
  thrift_spec = (
26389 
    None, # 0
26390 
    (1, TType.I64, 'storeId', None, None, ), # 1
26391 
  )
26392 
 
26393 
  def __init__(self, storeId=None,):
26394 
    self.storeId = storeId
26395 
 
26396 
  def read(self, iprot):
26397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26399 
      return
26400 
    iprot.readStructBegin()
26401 
    while True:
26402 
      (fname, ftype, fid) = iprot.readFieldBegin()
26403 
      if ftype == TType.STOP:
26404 
        break
26405 
      if fid == 1:
26406 
        if ftype == TType.I64:
26407 
          self.storeId = iprot.readI64();
26408 
        else:
26409 
          iprot.skip(ftype)
26410 
      else:
26411 
        iprot.skip(ftype)
26412 
      iprot.readFieldEnd()
26413 
    iprot.readStructEnd()
26414 
 
26415 
  def write(self, oprot):
26416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26418 
      return
26419 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26420 
    if self.storeId is not None:
26421 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26422 
      oprot.writeI64(self.storeId)
26423 
      oprot.writeFieldEnd()
26424 
    oprot.writeFieldStop()
26425 
    oprot.writeStructEnd()
26426 
 
26427 
  def validate(self):
26428 
    return
26429 
 
26430 
 
26431 
  def __repr__(self):
26432 
    L = ['%s=%r' % (key, value)
26433 
      for key, value in self.__dict__.iteritems()]
26434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26435 
 
26436 
  def __eq__(self, other):
26437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26438 
 
26439 
  def __ne__(self, other):
26440 
    return not (self == other)
26441 
 
26442 
class getReceivedAtStoreOrders_result:
26443 
  """
26444 
  Attributes:
26445 
   - success
26446 
  """
26447 
 
26448 
  thrift_spec = (
26449 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26450 
  )
26451 
 
26452 
  def __init__(self, success=None,):
26453 
    self.success = success
26454 
 
26455 
  def read(self, iprot):
26456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26458 
      return
26459 
    iprot.readStructBegin()
26460 
    while True:
26461 
      (fname, ftype, fid) = iprot.readFieldBegin()
26462 
      if ftype == TType.STOP:
26463 
        break
26464 
      if fid == 0:
26465 
        if ftype == TType.LIST:
26466 
          self.success = []
6188 rajveer 26467 
          (_etype645, _size642) = iprot.readListBegin()
26468 
          for _i646 in xrange(_size642):
26469 
            _elem647 = Order()
26470 
            _elem647.read(iprot)
26471 
            self.success.append(_elem647)
5553 rajveer 26472 
          iprot.readListEnd()
26473 
        else:
26474 
          iprot.skip(ftype)
26475 
      else:
26476 
        iprot.skip(ftype)
26477 
      iprot.readFieldEnd()
26478 
    iprot.readStructEnd()
26479 
 
26480 
  def write(self, oprot):
26481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26483 
      return
26484 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26485 
    if self.success is not None:
26486 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26487 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26488 
      for iter648 in self.success:
26489 
        iter648.write(oprot)
5553 rajveer 26490 
      oprot.writeListEnd()
26491 
      oprot.writeFieldEnd()
26492 
    oprot.writeFieldStop()
26493 
    oprot.writeStructEnd()
26494 
 
26495 
  def validate(self):
26496 
    return
26497 
 
26498 
 
26499 
  def __repr__(self):
26500 
    L = ['%s=%r' % (key, value)
26501 
      for key, value in self.__dict__.iteritems()]
26502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26503 
 
26504 
  def __eq__(self, other):
26505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26506 
 
26507 
  def __ne__(self, other):
26508 
    return not (self == other)
5593 mandeep.dh 26509 
 
5713 rajveer 26510 
class getOrdersCollectionAtStore_args:
26511 
  """
26512 
  Attributes:
26513 
   - storeId
26514 
   - fromDate
26515 
   - toDate
26516 
   - onlyCod
26517 
  """
26518 
 
26519 
  thrift_spec = (
26520 
    None, # 0
26521 
    (1, TType.I64, 'storeId', None, None, ), # 1
26522 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26523 
    (3, TType.I64, 'toDate', None, None, ), # 3
26524 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26525 
  )
26526 
 
26527 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26528 
    self.storeId = storeId
26529 
    self.fromDate = fromDate
26530 
    self.toDate = toDate
26531 
    self.onlyCod = onlyCod
26532 
 
26533 
  def read(self, iprot):
26534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26536 
      return
26537 
    iprot.readStructBegin()
26538 
    while True:
26539 
      (fname, ftype, fid) = iprot.readFieldBegin()
26540 
      if ftype == TType.STOP:
26541 
        break
26542 
      if fid == 1:
26543 
        if ftype == TType.I64:
26544 
          self.storeId = iprot.readI64();
26545 
        else:
26546 
          iprot.skip(ftype)
26547 
      elif fid == 2:
26548 
        if ftype == TType.I64:
26549 
          self.fromDate = iprot.readI64();
26550 
        else:
26551 
          iprot.skip(ftype)
26552 
      elif fid == 3:
26553 
        if ftype == TType.I64:
26554 
          self.toDate = iprot.readI64();
26555 
        else:
26556 
          iprot.skip(ftype)
26557 
      elif fid == 4:
26558 
        if ftype == TType.BOOL:
26559 
          self.onlyCod = iprot.readBool();
26560 
        else:
26561 
          iprot.skip(ftype)
26562 
      else:
26563 
        iprot.skip(ftype)
26564 
      iprot.readFieldEnd()
26565 
    iprot.readStructEnd()
26566 
 
26567 
  def write(self, oprot):
26568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26570 
      return
26571 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26572 
    if self.storeId is not None:
26573 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26574 
      oprot.writeI64(self.storeId)
26575 
      oprot.writeFieldEnd()
26576 
    if self.fromDate is not None:
26577 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26578 
      oprot.writeI64(self.fromDate)
26579 
      oprot.writeFieldEnd()
26580 
    if self.toDate is not None:
26581 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26582 
      oprot.writeI64(self.toDate)
26583 
      oprot.writeFieldEnd()
26584 
    if self.onlyCod is not None:
26585 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26586 
      oprot.writeBool(self.onlyCod)
26587 
      oprot.writeFieldEnd()
26588 
    oprot.writeFieldStop()
26589 
    oprot.writeStructEnd()
26590 
 
26591 
  def validate(self):
26592 
    return
26593 
 
26594 
 
26595 
  def __repr__(self):
26596 
    L = ['%s=%r' % (key, value)
26597 
      for key, value in self.__dict__.iteritems()]
26598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26599 
 
26600 
  def __eq__(self, other):
26601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26602 
 
26603 
  def __ne__(self, other):
26604 
    return not (self == other)
26605 
 
26606 
class getOrdersCollectionAtStore_result:
26607 
  """
26608 
  Attributes:
26609 
   - success
26610 
  """
26611 
 
26612 
  thrift_spec = (
26613 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26614 
  )
26615 
 
26616 
  def __init__(self, success=None,):
26617 
    self.success = success
26618 
 
26619 
  def read(self, iprot):
26620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26622 
      return
26623 
    iprot.readStructBegin()
26624 
    while True:
26625 
      (fname, ftype, fid) = iprot.readFieldBegin()
26626 
      if ftype == TType.STOP:
26627 
        break
26628 
      if fid == 0:
26629 
        if ftype == TType.LIST:
26630 
          self.success = []
6188 rajveer 26631 
          (_etype652, _size649) = iprot.readListBegin()
26632 
          for _i653 in xrange(_size649):
26633 
            _elem654 = Order()
26634 
            _elem654.read(iprot)
26635 
            self.success.append(_elem654)
5713 rajveer 26636 
          iprot.readListEnd()
26637 
        else:
26638 
          iprot.skip(ftype)
26639 
      else:
26640 
        iprot.skip(ftype)
26641 
      iprot.readFieldEnd()
26642 
    iprot.readStructEnd()
26643 
 
26644 
  def write(self, oprot):
26645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26647 
      return
26648 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26649 
    if self.success is not None:
26650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26651 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26652 
      for iter655 in self.success:
26653 
        iter655.write(oprot)
5713 rajveer 26654 
      oprot.writeListEnd()
26655 
      oprot.writeFieldEnd()
26656 
    oprot.writeFieldStop()
26657 
    oprot.writeStructEnd()
26658 
 
26659 
  def validate(self):
26660 
    return
26661 
 
26662 
 
26663 
  def __repr__(self):
26664 
    L = ['%s=%r' % (key, value)
26665 
      for key, value in self.__dict__.iteritems()]
26666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26667 
 
26668 
  def __eq__(self, other):
26669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26670 
 
26671 
  def __ne__(self, other):
26672 
    return not (self == other)
26673 
 
5833 rajveer 26674 
class getOrderAttributeValue_args:
26675 
  """
26676 
  Attributes:
26677 
   - orderId
26678 
   - attributeName
26679 
  """
26680 
 
26681 
  thrift_spec = None
26682 
  def __init__(self, orderId=None, attributeName=None,):
26683 
    self.orderId = orderId
26684 
    self.attributeName = attributeName
26685 
 
26686 
  def read(self, iprot):
26687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26689 
      return
26690 
    iprot.readStructBegin()
26691 
    while True:
26692 
      (fname, ftype, fid) = iprot.readFieldBegin()
26693 
      if ftype == TType.STOP:
26694 
        break
26695 
      if fid == 1:
26696 
        if ftype == TType.I64:
26697 
          self.orderId = iprot.readI64();
26698 
        else:
26699 
          iprot.skip(ftype)
26700 
      elif fid == -1:
26701 
        if ftype == TType.STRING:
26702 
          self.attributeName = iprot.readString();
26703 
        else:
26704 
          iprot.skip(ftype)
26705 
      else:
26706 
        iprot.skip(ftype)
26707 
      iprot.readFieldEnd()
26708 
    iprot.readStructEnd()
26709 
 
26710 
  def write(self, oprot):
26711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26713 
      return
26714 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26715 
    if self.attributeName is not None:
26716 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26717 
      oprot.writeString(self.attributeName)
26718 
      oprot.writeFieldEnd()
26719 
    if self.orderId is not None:
26720 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26721 
      oprot.writeI64(self.orderId)
26722 
      oprot.writeFieldEnd()
26723 
    oprot.writeFieldStop()
26724 
    oprot.writeStructEnd()
26725 
 
26726 
  def validate(self):
26727 
    return
26728 
 
26729 
 
26730 
  def __repr__(self):
26731 
    L = ['%s=%r' % (key, value)
26732 
      for key, value in self.__dict__.iteritems()]
26733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26734 
 
26735 
  def __eq__(self, other):
26736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26737 
 
26738 
  def __ne__(self, other):
26739 
    return not (self == other)
26740 
 
26741 
class getOrderAttributeValue_result:
26742 
  """
26743 
  Attributes:
26744 
   - success
26745 
  """
26746 
 
26747 
  thrift_spec = (
26748 
    (0, TType.STRING, 'success', None, None, ), # 0
26749 
  )
26750 
 
26751 
  def __init__(self, success=None,):
26752 
    self.success = success
26753 
 
26754 
  def read(self, iprot):
26755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26757 
      return
26758 
    iprot.readStructBegin()
26759 
    while True:
26760 
      (fname, ftype, fid) = iprot.readFieldBegin()
26761 
      if ftype == TType.STOP:
26762 
        break
26763 
      if fid == 0:
26764 
        if ftype == TType.STRING:
26765 
          self.success = iprot.readString();
26766 
        else:
26767 
          iprot.skip(ftype)
26768 
      else:
26769 
        iprot.skip(ftype)
26770 
      iprot.readFieldEnd()
26771 
    iprot.readStructEnd()
26772 
 
26773 
  def write(self, oprot):
26774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26776 
      return
26777 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26778 
    if self.success is not None:
26779 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26780 
      oprot.writeString(self.success)
26781 
      oprot.writeFieldEnd()
26782 
    oprot.writeFieldStop()
26783 
    oprot.writeStructEnd()
26784 
 
26785 
  def validate(self):
26786 
    return
26787 
 
26788 
 
26789 
  def __repr__(self):
26790 
    L = ['%s=%r' % (key, value)
26791 
      for key, value in self.__dict__.iteritems()]
26792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26793 
 
26794 
  def __eq__(self, other):
26795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26796 
 
26797 
  def __ne__(self, other):
26798 
    return not (self == other)
26799 
 
6019 rajveer 26800 
class changeJacketNumber_args:
26801 
  """
26802 
  Attributes:
26803 
   - orderId
26804 
   - jacketNumber
26805 
  """
26806 
 
26807 
  thrift_spec = (
26808 
    None, # 0
26809 
    (1, TType.I64, 'orderId', None, None, ), # 1
26810 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26811 
  )
26812 
 
26813 
  def __init__(self, orderId=None, jacketNumber=None,):
26814 
    self.orderId = orderId
26815 
    self.jacketNumber = jacketNumber
26816 
 
26817 
  def read(self, iprot):
26818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26820 
      return
26821 
    iprot.readStructBegin()
26822 
    while True:
26823 
      (fname, ftype, fid) = iprot.readFieldBegin()
26824 
      if ftype == TType.STOP:
26825 
        break
26826 
      if fid == 1:
26827 
        if ftype == TType.I64:
26828 
          self.orderId = iprot.readI64();
26829 
        else:
26830 
          iprot.skip(ftype)
26831 
      elif fid == 2:
26832 
        if ftype == TType.I64:
26833 
          self.jacketNumber = iprot.readI64();
26834 
        else:
26835 
          iprot.skip(ftype)
26836 
      else:
26837 
        iprot.skip(ftype)
26838 
      iprot.readFieldEnd()
26839 
    iprot.readStructEnd()
26840 
 
26841 
  def write(self, oprot):
26842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26844 
      return
26845 
    oprot.writeStructBegin('changeJacketNumber_args')
26846 
    if self.orderId is not None:
26847 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26848 
      oprot.writeI64(self.orderId)
26849 
      oprot.writeFieldEnd()
26850 
    if self.jacketNumber is not None:
26851 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26852 
      oprot.writeI64(self.jacketNumber)
26853 
      oprot.writeFieldEnd()
26854 
    oprot.writeFieldStop()
26855 
    oprot.writeStructEnd()
26856 
 
26857 
  def validate(self):
26858 
    return
26859 
 
26860 
 
26861 
  def __repr__(self):
26862 
    L = ['%s=%r' % (key, value)
26863 
      for key, value in self.__dict__.iteritems()]
26864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26865 
 
26866 
  def __eq__(self, other):
26867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26868 
 
26869 
  def __ne__(self, other):
26870 
    return not (self == other)
26871 
 
26872 
class changeJacketNumber_result:
26873 
  """
26874 
  Attributes:
26875 
   - success
26876 
  """
26877 
 
26878 
  thrift_spec = (
26879 
    (0, TType.BOOL, 'success', None, None, ), # 0
26880 
  )
26881 
 
26882 
  def __init__(self, success=None,):
26883 
    self.success = success
26884 
 
26885 
  def read(self, iprot):
26886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26888 
      return
26889 
    iprot.readStructBegin()
26890 
    while True:
26891 
      (fname, ftype, fid) = iprot.readFieldBegin()
26892 
      if ftype == TType.STOP:
26893 
        break
26894 
      if fid == 0:
26895 
        if ftype == TType.BOOL:
26896 
          self.success = iprot.readBool();
26897 
        else:
26898 
          iprot.skip(ftype)
26899 
      else:
26900 
        iprot.skip(ftype)
26901 
      iprot.readFieldEnd()
26902 
    iprot.readStructEnd()
26903 
 
26904 
  def write(self, oprot):
26905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26907 
      return
26908 
    oprot.writeStructBegin('changeJacketNumber_result')
26909 
    if self.success is not None:
26910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26911 
      oprot.writeBool(self.success)
26912 
      oprot.writeFieldEnd()
26913 
    oprot.writeFieldStop()
26914 
    oprot.writeStructEnd()
26915 
 
26916 
  def validate(self):
26917 
    return
26918 
 
26919 
 
26920 
  def __repr__(self):
26921 
    L = ['%s=%r' % (key, value)
26922 
      for key, value in self.__dict__.iteritems()]
26923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26924 
 
26925 
  def __eq__(self, other):
26926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26927 
 
26928 
  def __ne__(self, other):
26929 
    return not (self == other)
26930 
 
26931 
class markOrderAsRtoInTransit_args:
26932 
  """
26933 
  Attributes:
26934 
   - orderId
26935 
  """
26936 
 
26937 
  thrift_spec = (
26938 
    None, # 0
26939 
    (1, TType.I64, 'orderId', None, None, ), # 1
26940 
  )
26941 
 
26942 
  def __init__(self, orderId=None,):
26943 
    self.orderId = orderId
26944 
 
26945 
  def read(self, iprot):
26946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26948 
      return
26949 
    iprot.readStructBegin()
26950 
    while True:
26951 
      (fname, ftype, fid) = iprot.readFieldBegin()
26952 
      if ftype == TType.STOP:
26953 
        break
26954 
      if fid == 1:
26955 
        if ftype == TType.I64:
26956 
          self.orderId = iprot.readI64();
26957 
        else:
26958 
          iprot.skip(ftype)
26959 
      else:
26960 
        iprot.skip(ftype)
26961 
      iprot.readFieldEnd()
26962 
    iprot.readStructEnd()
26963 
 
26964 
  def write(self, oprot):
26965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26967 
      return
26968 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26969 
    if self.orderId is not None:
26970 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26971 
      oprot.writeI64(self.orderId)
26972 
      oprot.writeFieldEnd()
26973 
    oprot.writeFieldStop()
26974 
    oprot.writeStructEnd()
26975 
 
26976 
  def validate(self):
26977 
    return
26978 
 
26979 
 
26980 
  def __repr__(self):
26981 
    L = ['%s=%r' % (key, value)
26982 
      for key, value in self.__dict__.iteritems()]
26983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26984 
 
26985 
  def __eq__(self, other):
26986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26987 
 
26988 
  def __ne__(self, other):
26989 
    return not (self == other)
26990 
 
26991 
class markOrderAsRtoInTransit_result:
26992 
  """
26993 
  Attributes:
26994 
   - success
26995 
  """
26996 
 
26997 
  thrift_spec = (
26998 
    (0, TType.BOOL, 'success', None, None, ), # 0
26999 
  )
27000 
 
27001 
  def __init__(self, success=None,):
27002 
    self.success = success
27003 
 
27004 
  def read(self, iprot):
27005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27007 
      return
27008 
    iprot.readStructBegin()
27009 
    while True:
27010 
      (fname, ftype, fid) = iprot.readFieldBegin()
27011 
      if ftype == TType.STOP:
27012 
        break
27013 
      if fid == 0:
27014 
        if ftype == TType.BOOL:
27015 
          self.success = iprot.readBool();
27016 
        else:
27017 
          iprot.skip(ftype)
27018 
      else:
27019 
        iprot.skip(ftype)
27020 
      iprot.readFieldEnd()
27021 
    iprot.readStructEnd()
27022 
 
27023 
  def write(self, oprot):
27024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27026 
      return
27027 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27028 
    if self.success is not None:
27029 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27030 
      oprot.writeBool(self.success)
27031 
      oprot.writeFieldEnd()
27032 
    oprot.writeFieldStop()
27033 
    oprot.writeStructEnd()
27034 
 
27035 
  def validate(self):
27036 
    return
27037 
 
27038 
 
27039 
  def __repr__(self):
27040 
    L = ['%s=%r' % (key, value)
27041 
      for key, value in self.__dict__.iteritems()]
27042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27043 
 
27044 
  def __eq__(self, other):
27045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27046 
 
27047 
  def __ne__(self, other):
27048 
    return not (self == other)
27049 
 
5593 mandeep.dh 27050 
class acceptOrderForItem_args:
27051 
  """
27052 
  Attributes:
27053 
   - itemId
27054 
   - quantity
27055 
   - fulfilmentWarehouseId
27056 
   - billingWarehouseId
27057 
  """
27058 
 
27059 
  thrift_spec = (
27060 
    None, # 0
27061 
    (1, TType.I64, 'itemId', None, None, ), # 1
27062 
    (2, TType.I64, 'quantity', None, None, ), # 2
27063 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27064 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27065 
  )
27066 
 
27067 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27068 
    self.itemId = itemId
27069 
    self.quantity = quantity
27070 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27071 
    self.billingWarehouseId = billingWarehouseId
27072 
 
27073 
  def read(self, iprot):
27074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27076 
      return
27077 
    iprot.readStructBegin()
27078 
    while True:
27079 
      (fname, ftype, fid) = iprot.readFieldBegin()
27080 
      if ftype == TType.STOP:
27081 
        break
27082 
      if fid == 1:
27083 
        if ftype == TType.I64:
27084 
          self.itemId = iprot.readI64();
27085 
        else:
27086 
          iprot.skip(ftype)
27087 
      elif fid == 2:
27088 
        if ftype == TType.I64:
27089 
          self.quantity = iprot.readI64();
27090 
        else:
27091 
          iprot.skip(ftype)
27092 
      elif fid == 3:
27093 
        if ftype == TType.I64:
27094 
          self.fulfilmentWarehouseId = iprot.readI64();
27095 
        else:
27096 
          iprot.skip(ftype)
27097 
      elif fid == 4:
27098 
        if ftype == TType.I64:
27099 
          self.billingWarehouseId = iprot.readI64();
27100 
        else:
27101 
          iprot.skip(ftype)
27102 
      else:
27103 
        iprot.skip(ftype)
27104 
      iprot.readFieldEnd()
27105 
    iprot.readStructEnd()
27106 
 
27107 
  def write(self, oprot):
27108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27110 
      return
27111 
    oprot.writeStructBegin('acceptOrderForItem_args')
27112 
    if self.itemId is not None:
27113 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27114 
      oprot.writeI64(self.itemId)
27115 
      oprot.writeFieldEnd()
27116 
    if self.quantity is not None:
27117 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27118 
      oprot.writeI64(self.quantity)
27119 
      oprot.writeFieldEnd()
27120 
    if self.fulfilmentWarehouseId is not None:
27121 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27122 
      oprot.writeI64(self.fulfilmentWarehouseId)
27123 
      oprot.writeFieldEnd()
27124 
    if self.billingWarehouseId is not None:
27125 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27126 
      oprot.writeI64(self.billingWarehouseId)
27127 
      oprot.writeFieldEnd()
27128 
    oprot.writeFieldStop()
27129 
    oprot.writeStructEnd()
27130 
 
27131 
  def validate(self):
27132 
    return
27133 
 
27134 
 
27135 
  def __repr__(self):
27136 
    L = ['%s=%r' % (key, value)
27137 
      for key, value in self.__dict__.iteritems()]
27138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27139 
 
27140 
  def __eq__(self, other):
27141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27142 
 
27143 
  def __ne__(self, other):
27144 
    return not (self == other)
27145 
 
27146 
class acceptOrderForItem_result:
27147 
 
27148 
  thrift_spec = (
27149 
  )
27150 
 
27151 
  def read(self, iprot):
27152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27154 
      return
27155 
    iprot.readStructBegin()
27156 
    while True:
27157 
      (fname, ftype, fid) = iprot.readFieldBegin()
27158 
      if ftype == TType.STOP:
27159 
        break
27160 
      else:
27161 
        iprot.skip(ftype)
27162 
      iprot.readFieldEnd()
27163 
    iprot.readStructEnd()
27164 
 
27165 
  def write(self, oprot):
27166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27168 
      return
27169 
    oprot.writeStructBegin('acceptOrderForItem_result')
27170 
    oprot.writeFieldStop()
27171 
    oprot.writeStructEnd()
27172 
 
27173 
  def validate(self):
27174 
    return
27175 
 
27176 
 
27177 
  def __repr__(self):
27178 
    L = ['%s=%r' % (key, value)
27179 
      for key, value in self.__dict__.iteritems()]
27180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27181 
 
27182 
  def __eq__(self, other):
27183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27184 
 
27185 
  def __ne__(self, other):
27186 
    return not (self == other)
6000 mandeep.dh 27187 
 
27188 
class createRechargeOrder_args:
27189 
  """
27190 
  Attributes:
27191 
   - rechargeOrder
27192 
  """
27193 
 
27194 
  thrift_spec = (
27195 
    None, # 0
27196 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27197 
  )
27198 
 
27199 
  def __init__(self, rechargeOrder=None,):
27200 
    self.rechargeOrder = rechargeOrder
27201 
 
27202 
  def read(self, iprot):
27203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27205 
      return
27206 
    iprot.readStructBegin()
27207 
    while True:
27208 
      (fname, ftype, fid) = iprot.readFieldBegin()
27209 
      if ftype == TType.STOP:
27210 
        break
27211 
      if fid == 1:
27212 
        if ftype == TType.STRUCT:
27213 
          self.rechargeOrder = RechargeOrder()
27214 
          self.rechargeOrder.read(iprot)
27215 
        else:
27216 
          iprot.skip(ftype)
27217 
      else:
27218 
        iprot.skip(ftype)
27219 
      iprot.readFieldEnd()
27220 
    iprot.readStructEnd()
27221 
 
27222 
  def write(self, oprot):
27223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27225 
      return
27226 
    oprot.writeStructBegin('createRechargeOrder_args')
27227 
    if self.rechargeOrder is not None:
27228 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27229 
      self.rechargeOrder.write(oprot)
27230 
      oprot.writeFieldEnd()
27231 
    oprot.writeFieldStop()
27232 
    oprot.writeStructEnd()
27233 
 
27234 
  def validate(self):
27235 
    return
27236 
 
27237 
 
27238 
  def __repr__(self):
27239 
    L = ['%s=%r' % (key, value)
27240 
      for key, value in self.__dict__.iteritems()]
27241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27242 
 
27243 
  def __eq__(self, other):
27244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27245 
 
27246 
  def __ne__(self, other):
27247 
    return not (self == other)
27248 
 
27249 
class createRechargeOrder_result:
27250 
  """
27251 
  Attributes:
27252 
   - success
27253 
   - ex
27254 
  """
27255 
 
27256 
  thrift_spec = (
27257 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27259 
  )
27260 
 
27261 
  def __init__(self, success=None, ex=None,):
27262 
    self.success = success
27263 
    self.ex = ex
27264 
 
27265 
  def read(self, iprot):
27266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27268 
      return
27269 
    iprot.readStructBegin()
27270 
    while True:
27271 
      (fname, ftype, fid) = iprot.readFieldBegin()
27272 
      if ftype == TType.STOP:
27273 
        break
27274 
      if fid == 0:
27275 
        if ftype == TType.STRUCT:
27276 
          self.success = RechargeOrder()
27277 
          self.success.read(iprot)
27278 
        else:
27279 
          iprot.skip(ftype)
27280 
      elif fid == 1:
27281 
        if ftype == TType.STRUCT:
27282 
          self.ex = TransactionServiceException()
27283 
          self.ex.read(iprot)
27284 
        else:
27285 
          iprot.skip(ftype)
27286 
      else:
27287 
        iprot.skip(ftype)
27288 
      iprot.readFieldEnd()
27289 
    iprot.readStructEnd()
27290 
 
27291 
  def write(self, oprot):
27292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27294 
      return
27295 
    oprot.writeStructBegin('createRechargeOrder_result')
27296 
    if self.success is not None:
27297 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27298 
      self.success.write(oprot)
27299 
      oprot.writeFieldEnd()
27300 
    if self.ex is not None:
27301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27302 
      self.ex.write(oprot)
27303 
      oprot.writeFieldEnd()
27304 
    oprot.writeFieldStop()
27305 
    oprot.writeStructEnd()
27306 
 
27307 
  def validate(self):
27308 
    return
27309 
 
27310 
 
27311 
  def __repr__(self):
27312 
    L = ['%s=%r' % (key, value)
27313 
      for key, value in self.__dict__.iteritems()]
27314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27315 
 
27316 
  def __eq__(self, other):
27317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27318 
 
27319 
  def __ne__(self, other):
27320 
    return not (self == other)
27321 
 
6031 rajveer 27322 
class getRechargeOrder_args:
27323 
  """
27324 
  Attributes:
27325 
   - rechargeRrderId
27326 
  """
27327 
 
27328 
  thrift_spec = (
27329 
    None, # 0
27330 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27331 
  )
27332 
 
27333 
  def __init__(self, rechargeRrderId=None,):
27334 
    self.rechargeRrderId = rechargeRrderId
27335 
 
27336 
  def read(self, iprot):
27337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27339 
      return
27340 
    iprot.readStructBegin()
27341 
    while True:
27342 
      (fname, ftype, fid) = iprot.readFieldBegin()
27343 
      if ftype == TType.STOP:
27344 
        break
27345 
      if fid == 1:
27346 
        if ftype == TType.I64:
27347 
          self.rechargeRrderId = iprot.readI64();
27348 
        else:
27349 
          iprot.skip(ftype)
27350 
      else:
27351 
        iprot.skip(ftype)
27352 
      iprot.readFieldEnd()
27353 
    iprot.readStructEnd()
27354 
 
27355 
  def write(self, oprot):
27356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27358 
      return
27359 
    oprot.writeStructBegin('getRechargeOrder_args')
27360 
    if self.rechargeRrderId is not None:
27361 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27362 
      oprot.writeI64(self.rechargeRrderId)
27363 
      oprot.writeFieldEnd()
27364 
    oprot.writeFieldStop()
27365 
    oprot.writeStructEnd()
27366 
 
27367 
  def validate(self):
27368 
    return
27369 
 
27370 
 
27371 
  def __repr__(self):
27372 
    L = ['%s=%r' % (key, value)
27373 
      for key, value in self.__dict__.iteritems()]
27374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27375 
 
27376 
  def __eq__(self, other):
27377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27378 
 
27379 
  def __ne__(self, other):
27380 
    return not (self == other)
27381 
 
27382 
class getRechargeOrder_result:
27383 
  """
27384 
  Attributes:
27385 
   - success
27386 
   - ex
27387 
  """
27388 
 
27389 
  thrift_spec = (
27390 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27391 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27392 
  )
27393 
 
27394 
  def __init__(self, success=None, ex=None,):
27395 
    self.success = success
27396 
    self.ex = ex
27397 
 
27398 
  def read(self, iprot):
27399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27401 
      return
27402 
    iprot.readStructBegin()
27403 
    while True:
27404 
      (fname, ftype, fid) = iprot.readFieldBegin()
27405 
      if ftype == TType.STOP:
27406 
        break
27407 
      if fid == 0:
27408 
        if ftype == TType.STRUCT:
27409 
          self.success = RechargeOrder()
27410 
          self.success.read(iprot)
27411 
        else:
27412 
          iprot.skip(ftype)
27413 
      elif fid == 1:
27414 
        if ftype == TType.STRUCT:
27415 
          self.ex = TransactionServiceException()
27416 
          self.ex.read(iprot)
27417 
        else:
27418 
          iprot.skip(ftype)
27419 
      else:
27420 
        iprot.skip(ftype)
27421 
      iprot.readFieldEnd()
27422 
    iprot.readStructEnd()
27423 
 
27424 
  def write(self, oprot):
27425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27427 
      return
27428 
    oprot.writeStructBegin('getRechargeOrder_result')
27429 
    if self.success is not None:
27430 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27431 
      self.success.write(oprot)
27432 
      oprot.writeFieldEnd()
27433 
    if self.ex is not None:
27434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27435 
      self.ex.write(oprot)
27436 
      oprot.writeFieldEnd()
27437 
    oprot.writeFieldStop()
27438 
    oprot.writeStructEnd()
27439 
 
27440 
  def validate(self):
27441 
    return
27442 
 
27443 
 
27444 
  def __repr__(self):
27445 
    L = ['%s=%r' % (key, value)
27446 
      for key, value in self.__dict__.iteritems()]
27447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27448 
 
27449 
  def __eq__(self, other):
27450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27451 
 
27452 
  def __ne__(self, other):
27453 
    return not (self == other)
27454 
 
27455 
class getRechargeOrders_args:
27456 
  """
27457 
  Attributes:
27458 
   - userId
27459 
  """
27460 
 
27461 
  thrift_spec = (
27462 
    None, # 0
27463 
    (1, TType.I64, 'userId', None, None, ), # 1
27464 
  )
27465 
 
27466 
  def __init__(self, userId=None,):
27467 
    self.userId = userId
27468 
 
27469 
  def read(self, iprot):
27470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27472 
      return
27473 
    iprot.readStructBegin()
27474 
    while True:
27475 
      (fname, ftype, fid) = iprot.readFieldBegin()
27476 
      if ftype == TType.STOP:
27477 
        break
27478 
      if fid == 1:
27479 
        if ftype == TType.I64:
27480 
          self.userId = iprot.readI64();
27481 
        else:
27482 
          iprot.skip(ftype)
27483 
      else:
27484 
        iprot.skip(ftype)
27485 
      iprot.readFieldEnd()
27486 
    iprot.readStructEnd()
27487 
 
27488 
  def write(self, oprot):
27489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27491 
      return
27492 
    oprot.writeStructBegin('getRechargeOrders_args')
27493 
    if self.userId is not None:
27494 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27495 
      oprot.writeI64(self.userId)
27496 
      oprot.writeFieldEnd()
27497 
    oprot.writeFieldStop()
27498 
    oprot.writeStructEnd()
27499 
 
27500 
  def validate(self):
27501 
    return
27502 
 
27503 
 
27504 
  def __repr__(self):
27505 
    L = ['%s=%r' % (key, value)
27506 
      for key, value in self.__dict__.iteritems()]
27507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27508 
 
27509 
  def __eq__(self, other):
27510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27511 
 
27512 
  def __ne__(self, other):
27513 
    return not (self == other)
27514 
 
27515 
class getRechargeOrders_result:
27516 
  """
27517 
  Attributes:
27518 
   - success
27519 
  """
27520 
 
27521 
  thrift_spec = (
27522 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27523 
  )
27524 
 
27525 
  def __init__(self, success=None,):
27526 
    self.success = success
27527 
 
27528 
  def read(self, iprot):
27529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27531 
      return
27532 
    iprot.readStructBegin()
27533 
    while True:
27534 
      (fname, ftype, fid) = iprot.readFieldBegin()
27535 
      if ftype == TType.STOP:
27536 
        break
27537 
      if fid == 0:
27538 
        if ftype == TType.LIST:
27539 
          self.success = []
6188 rajveer 27540 
          (_etype659, _size656) = iprot.readListBegin()
27541 
          for _i660 in xrange(_size656):
27542 
            _elem661 = RechargeOrder()
27543 
            _elem661.read(iprot)
27544 
            self.success.append(_elem661)
6031 rajveer 27545 
          iprot.readListEnd()
27546 
        else:
27547 
          iprot.skip(ftype)
27548 
      else:
27549 
        iprot.skip(ftype)
27550 
      iprot.readFieldEnd()
27551 
    iprot.readStructEnd()
27552 
 
27553 
  def write(self, oprot):
27554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27556 
      return
27557 
    oprot.writeStructBegin('getRechargeOrders_result')
27558 
    if self.success is not None:
27559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27561 
      for iter662 in self.success:
27562 
        iter662.write(oprot)
6031 rajveer 27563 
      oprot.writeListEnd()
27564 
      oprot.writeFieldEnd()
27565 
    oprot.writeFieldStop()
27566 
    oprot.writeStructEnd()
27567 
 
27568 
  def validate(self):
27569 
    return
27570 
 
27571 
 
27572 
  def __repr__(self):
27573 
    L = ['%s=%r' % (key, value)
27574 
      for key, value in self.__dict__.iteritems()]
27575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27576 
 
27577 
  def __eq__(self, other):
27578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27579 
 
27580 
  def __ne__(self, other):
27581 
    return not (self == other)
27582 
 
6000 mandeep.dh 27583 
class updateRechargeOrderStatus_args:
27584 
  """
27585 
  Attributes:
27586 
   - rechargeOrderId
27587 
   - rechargeOrderStatus
27588 
  """
27589 
 
27590 
  thrift_spec = (
27591 
    None, # 0
27592 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27593 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27594 
  )
27595 
 
27596 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27597 
    self.rechargeOrderId = rechargeOrderId
27598 
    self.rechargeOrderStatus = rechargeOrderStatus
27599 
 
27600 
  def read(self, iprot):
27601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27603 
      return
27604 
    iprot.readStructBegin()
27605 
    while True:
27606 
      (fname, ftype, fid) = iprot.readFieldBegin()
27607 
      if ftype == TType.STOP:
27608 
        break
27609 
      if fid == 1:
27610 
        if ftype == TType.I64:
27611 
          self.rechargeOrderId = iprot.readI64();
27612 
        else:
27613 
          iprot.skip(ftype)
27614 
      elif fid == 2:
27615 
        if ftype == TType.I32:
27616 
          self.rechargeOrderStatus = iprot.readI32();
27617 
        else:
27618 
          iprot.skip(ftype)
27619 
      else:
27620 
        iprot.skip(ftype)
27621 
      iprot.readFieldEnd()
27622 
    iprot.readStructEnd()
27623 
 
27624 
  def write(self, oprot):
27625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27627 
      return
27628 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27629 
    if self.rechargeOrderId is not None:
27630 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27631 
      oprot.writeI64(self.rechargeOrderId)
27632 
      oprot.writeFieldEnd()
27633 
    if self.rechargeOrderStatus is not None:
27634 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27635 
      oprot.writeI32(self.rechargeOrderStatus)
27636 
      oprot.writeFieldEnd()
27637 
    oprot.writeFieldStop()
27638 
    oprot.writeStructEnd()
27639 
 
27640 
  def validate(self):
27641 
    return
27642 
 
27643 
 
27644 
  def __repr__(self):
27645 
    L = ['%s=%r' % (key, value)
27646 
      for key, value in self.__dict__.iteritems()]
27647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27648 
 
27649 
  def __eq__(self, other):
27650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27651 
 
27652 
  def __ne__(self, other):
27653 
    return not (self == other)
27654 
 
27655 
class updateRechargeOrderStatus_result:
27656 
  """
27657 
  Attributes:
6031 rajveer 27658 
   - success
6000 mandeep.dh 27659 
   - ex
27660 
  """
27661 
 
27662 
  thrift_spec = (
6031 rajveer 27663 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27665 
  )
27666 
 
6031 rajveer 27667 
  def __init__(self, success=None, ex=None,):
27668 
    self.success = success
6000 mandeep.dh 27669 
    self.ex = ex
27670 
 
27671 
  def read(self, iprot):
27672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27674 
      return
27675 
    iprot.readStructBegin()
27676 
    while True:
27677 
      (fname, ftype, fid) = iprot.readFieldBegin()
27678 
      if ftype == TType.STOP:
27679 
        break
6031 rajveer 27680 
      if fid == 0:
27681 
        if ftype == TType.BOOL:
27682 
          self.success = iprot.readBool();
27683 
        else:
27684 
          iprot.skip(ftype)
27685 
      elif fid == 1:
6000 mandeep.dh 27686 
        if ftype == TType.STRUCT:
27687 
          self.ex = TransactionServiceException()
27688 
          self.ex.read(iprot)
27689 
        else:
27690 
          iprot.skip(ftype)
27691 
      else:
27692 
        iprot.skip(ftype)
27693 
      iprot.readFieldEnd()
27694 
    iprot.readStructEnd()
27695 
 
27696 
  def write(self, oprot):
27697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27699 
      return
27700 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27701 
    if self.success is not None:
27702 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27703 
      oprot.writeBool(self.success)
27704 
      oprot.writeFieldEnd()
6000 mandeep.dh 27705 
    if self.ex is not None:
27706 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27707 
      self.ex.write(oprot)
27708 
      oprot.writeFieldEnd()
27709 
    oprot.writeFieldStop()
27710 
    oprot.writeStructEnd()
27711 
 
27712 
  def validate(self):
27713 
    return
27714 
 
27715 
 
27716 
  def __repr__(self):
27717 
    L = ['%s=%r' % (key, value)
27718 
      for key, value in self.__dict__.iteritems()]
27719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27720 
 
27721 
  def __eq__(self, other):
27722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27723 
 
27724 
  def __ne__(self, other):
27725 
    return not (self == other)
27726 
 
27727 
class activateRechargeTxn_args:
27728 
  """
27729 
  Attributes:
6031 rajveer 27730 
   - rechargeOrderId
6000 mandeep.dh 27731 
  """
27732 
 
27733 
  thrift_spec = (
27734 
    None, # 0
6031 rajveer 27735 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27736 
  )
27737 
 
6031 rajveer 27738 
  def __init__(self, rechargeOrderId=None,):
27739 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27740 
 
27741 
  def read(self, iprot):
27742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27744 
      return
27745 
    iprot.readStructBegin()
27746 
    while True:
27747 
      (fname, ftype, fid) = iprot.readFieldBegin()
27748 
      if ftype == TType.STOP:
27749 
        break
27750 
      if fid == 1:
6031 rajveer 27751 
        if ftype == TType.I64:
27752 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27753 
        else:
27754 
          iprot.skip(ftype)
27755 
      else:
27756 
        iprot.skip(ftype)
27757 
      iprot.readFieldEnd()
27758 
    iprot.readStructEnd()
27759 
 
27760 
  def write(self, oprot):
27761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27763 
      return
27764 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27765 
    if self.rechargeOrderId is not None:
27766 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27767 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27768 
      oprot.writeFieldEnd()
27769 
    oprot.writeFieldStop()
27770 
    oprot.writeStructEnd()
27771 
 
27772 
  def validate(self):
27773 
    return
27774 
 
27775 
 
27776 
  def __repr__(self):
27777 
    L = ['%s=%r' % (key, value)
27778 
      for key, value in self.__dict__.iteritems()]
27779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27780 
 
27781 
  def __eq__(self, other):
27782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27783 
 
27784 
  def __ne__(self, other):
27785 
    return not (self == other)
27786 
 
27787 
class activateRechargeTxn_result:
27788 
  """
27789 
  Attributes:
27790 
   - success
27791 
   - ex
27792 
  """
27793 
 
27794 
  thrift_spec = (
6031 rajveer 27795 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27797 
  )
27798 
 
27799 
  def __init__(self, success=None, ex=None,):
27800 
    self.success = success
27801 
    self.ex = ex
27802 
 
27803 
  def read(self, iprot):
27804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27806 
      return
27807 
    iprot.readStructBegin()
27808 
    while True:
27809 
      (fname, ftype, fid) = iprot.readFieldBegin()
27810 
      if ftype == TType.STOP:
27811 
        break
27812 
      if fid == 0:
6031 rajveer 27813 
        if ftype == TType.BOOL:
27814 
          self.success = iprot.readBool();
6000 mandeep.dh 27815 
        else:
27816 
          iprot.skip(ftype)
27817 
      elif fid == 1:
27818 
        if ftype == TType.STRUCT:
27819 
          self.ex = TransactionServiceException()
27820 
          self.ex.read(iprot)
27821 
        else:
27822 
          iprot.skip(ftype)
27823 
      else:
27824 
        iprot.skip(ftype)
27825 
      iprot.readFieldEnd()
27826 
    iprot.readStructEnd()
27827 
 
27828 
  def write(self, oprot):
27829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27831 
      return
27832 
    oprot.writeStructBegin('activateRechargeTxn_result')
27833 
    if self.success is not None:
6031 rajveer 27834 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27835 
      oprot.writeBool(self.success)
6000 mandeep.dh 27836 
      oprot.writeFieldEnd()
27837 
    if self.ex is not None:
27838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27839 
      self.ex.write(oprot)
27840 
      oprot.writeFieldEnd()
27841 
    oprot.writeFieldStop()
27842 
    oprot.writeStructEnd()
27843 
 
27844 
  def validate(self):
27845 
    return
27846 
 
27847 
 
27848 
  def __repr__(self):
27849 
    L = ['%s=%r' % (key, value)
27850 
      for key, value in self.__dict__.iteritems()]
27851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27852 
 
27853 
  def __eq__(self, other):
27854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27855 
 
27856 
  def __ne__(self, other):
27857 
    return not (self == other)
27858 
 
6031 rajveer 27859 
class getUserWallet_args:
6000 mandeep.dh 27860 
  """
27861 
  Attributes:
6031 rajveer 27862 
   - userId
6000 mandeep.dh 27863 
  """
27864 
 
27865 
  thrift_spec = (
27866 
    None, # 0
6031 rajveer 27867 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27868 
  )
27869 
 
6031 rajveer 27870 
  def __init__(self, userId=None,):
27871 
    self.userId = userId
6000 mandeep.dh 27872 
 
27873 
  def read(self, iprot):
27874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27876 
      return
27877 
    iprot.readStructBegin()
27878 
    while True:
27879 
      (fname, ftype, fid) = iprot.readFieldBegin()
27880 
      if ftype == TType.STOP:
27881 
        break
27882 
      if fid == 1:
27883 
        if ftype == TType.I64:
6031 rajveer 27884 
          self.userId = iprot.readI64();
6000 mandeep.dh 27885 
        else:
27886 
          iprot.skip(ftype)
27887 
      else:
27888 
        iprot.skip(ftype)
27889 
      iprot.readFieldEnd()
27890 
    iprot.readStructEnd()
27891 
 
27892 
  def write(self, oprot):
27893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27895 
      return
6031 rajveer 27896 
    oprot.writeStructBegin('getUserWallet_args')
27897 
    if self.userId is not None:
27898 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27899 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27900 
      oprot.writeFieldEnd()
27901 
    oprot.writeFieldStop()
27902 
    oprot.writeStructEnd()
27903 
 
27904 
  def validate(self):
27905 
    return
27906 
 
27907 
 
27908 
  def __repr__(self):
27909 
    L = ['%s=%r' % (key, value)
27910 
      for key, value in self.__dict__.iteritems()]
27911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27912 
 
27913 
  def __eq__(self, other):
27914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27915 
 
27916 
  def __ne__(self, other):
27917 
    return not (self == other)
27918 
 
6031 rajveer 27919 
class getUserWallet_result:
6000 mandeep.dh 27920 
  """
27921 
  Attributes:
27922 
   - success
27923 
  """
27924 
 
27925 
  thrift_spec = (
6031 rajveer 27926 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27927 
  )
27928 
 
27929 
  def __init__(self, success=None,):
27930 
    self.success = success
27931 
 
27932 
  def read(self, iprot):
27933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27935 
      return
27936 
    iprot.readStructBegin()
27937 
    while True:
27938 
      (fname, ftype, fid) = iprot.readFieldBegin()
27939 
      if ftype == TType.STOP:
27940 
        break
27941 
      if fid == 0:
6031 rajveer 27942 
        if ftype == TType.STRUCT:
27943 
          self.success = UserWallet()
27944 
          self.success.read(iprot)
6000 mandeep.dh 27945 
        else:
27946 
          iprot.skip(ftype)
27947 
      else:
27948 
        iprot.skip(ftype)
27949 
      iprot.readFieldEnd()
27950 
    iprot.readStructEnd()
27951 
 
27952 
  def write(self, oprot):
27953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27955 
      return
6031 rajveer 27956 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27957 
    if self.success is not None:
6031 rajveer 27958 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27959 
      self.success.write(oprot)
6000 mandeep.dh 27960 
      oprot.writeFieldEnd()
27961 
    oprot.writeFieldStop()
27962 
    oprot.writeStructEnd()
27963 
 
27964 
  def validate(self):
27965 
    return
27966 
 
27967 
 
27968 
  def __repr__(self):
27969 
    L = ['%s=%r' % (key, value)
27970 
      for key, value in self.__dict__.iteritems()]
27971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27972 
 
27973 
  def __eq__(self, other):
27974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27975 
 
27976 
  def __ne__(self, other):
27977 
    return not (self == other)
27978 
 
6031 rajveer 27979 
class getUserWalletHistory_args:
6000 mandeep.dh 27980 
  """
27981 
  Attributes:
6031 rajveer 27982 
   - userId
6000 mandeep.dh 27983 
  """
27984 
 
27985 
  thrift_spec = (
27986 
    None, # 0
6031 rajveer 27987 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27988 
  )
27989 
 
6031 rajveer 27990 
  def __init__(self, userId=None,):
27991 
    self.userId = userId
6000 mandeep.dh 27992 
 
27993 
  def read(self, iprot):
27994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27996 
      return
27997 
    iprot.readStructBegin()
27998 
    while True:
27999 
      (fname, ftype, fid) = iprot.readFieldBegin()
28000 
      if ftype == TType.STOP:
28001 
        break
28002 
      if fid == 1:
28003 
        if ftype == TType.I64:
6031 rajveer 28004 
          self.userId = iprot.readI64();
6000 mandeep.dh 28005 
        else:
28006 
          iprot.skip(ftype)
28007 
      else:
28008 
        iprot.skip(ftype)
28009 
      iprot.readFieldEnd()
28010 
    iprot.readStructEnd()
28011 
 
28012 
  def write(self, oprot):
28013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28015 
      return
6031 rajveer 28016 
    oprot.writeStructBegin('getUserWalletHistory_args')
28017 
    if self.userId is not None:
28018 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28019 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28020 
      oprot.writeFieldEnd()
28021 
    oprot.writeFieldStop()
28022 
    oprot.writeStructEnd()
28023 
 
28024 
  def validate(self):
28025 
    return
28026 
 
28027 
 
28028 
  def __repr__(self):
28029 
    L = ['%s=%r' % (key, value)
28030 
      for key, value in self.__dict__.iteritems()]
28031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28032 
 
28033 
  def __eq__(self, other):
28034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28035 
 
28036 
  def __ne__(self, other):
28037 
    return not (self == other)
28038 
 
6031 rajveer 28039 
class getUserWalletHistory_result:
6000 mandeep.dh 28040 
  """
28041 
  Attributes:
28042 
   - success
28043 
  """
28044 
 
28045 
  thrift_spec = (
6031 rajveer 28046 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28047 
  )
28048 
 
28049 
  def __init__(self, success=None,):
28050 
    self.success = success
28051 
 
28052 
  def read(self, iprot):
28053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28055 
      return
28056 
    iprot.readStructBegin()
28057 
    while True:
28058 
      (fname, ftype, fid) = iprot.readFieldBegin()
28059 
      if ftype == TType.STOP:
28060 
        break
28061 
      if fid == 0:
28062 
        if ftype == TType.LIST:
28063 
          self.success = []
6188 rajveer 28064 
          (_etype666, _size663) = iprot.readListBegin()
28065 
          for _i667 in xrange(_size663):
28066 
            _elem668 = UserWalletHistory()
28067 
            _elem668.read(iprot)
28068 
            self.success.append(_elem668)
6000 mandeep.dh 28069 
          iprot.readListEnd()
28070 
        else:
28071 
          iprot.skip(ftype)
28072 
      else:
28073 
        iprot.skip(ftype)
28074 
      iprot.readFieldEnd()
28075 
    iprot.readStructEnd()
28076 
 
28077 
  def write(self, oprot):
28078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28080 
      return
6031 rajveer 28081 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28082 
    if self.success is not None:
28083 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28084 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28085 
      for iter669 in self.success:
28086 
        iter669.write(oprot)
6000 mandeep.dh 28087 
      oprot.writeListEnd()
28088 
      oprot.writeFieldEnd()
28089 
    oprot.writeFieldStop()
28090 
    oprot.writeStructEnd()
28091 
 
28092 
  def validate(self):
28093 
    return
28094 
 
28095 
 
28096 
  def __repr__(self):
28097 
    L = ['%s=%r' % (key, value)
28098 
      for key, value in self.__dict__.iteritems()]
28099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28100 
 
28101 
  def __eq__(self, other):
28102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28103 
 
28104 
  def __ne__(self, other):
28105 
    return not (self == other)
6048 rajveer 28106 
 
6050 anupam.sin 28107 
class getRechargeOrdersForTransaction_args:
28108 
  """
28109 
  Attributes:
28110 
   - txnId
28111 
  """
28112 
 
28113 
  thrift_spec = (
28114 
    None, # 0
28115 
    (1, TType.I64, 'txnId', None, None, ), # 1
28116 
  )
28117 
 
28118 
  def __init__(self, txnId=None,):
28119 
    self.txnId = txnId
28120 
 
28121 
  def read(self, iprot):
28122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28124 
      return
28125 
    iprot.readStructBegin()
28126 
    while True:
28127 
      (fname, ftype, fid) = iprot.readFieldBegin()
28128 
      if ftype == TType.STOP:
28129 
        break
28130 
      if fid == 1:
28131 
        if ftype == TType.I64:
28132 
          self.txnId = iprot.readI64();
28133 
        else:
28134 
          iprot.skip(ftype)
28135 
      else:
28136 
        iprot.skip(ftype)
28137 
      iprot.readFieldEnd()
28138 
    iprot.readStructEnd()
28139 
 
28140 
  def write(self, oprot):
28141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28143 
      return
28144 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28145 
    if self.txnId is not None:
28146 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28147 
      oprot.writeI64(self.txnId)
28148 
      oprot.writeFieldEnd()
28149 
    oprot.writeFieldStop()
28150 
    oprot.writeStructEnd()
28151 
 
28152 
  def validate(self):
28153 
    return
28154 
 
28155 
 
28156 
  def __repr__(self):
28157 
    L = ['%s=%r' % (key, value)
28158 
      for key, value in self.__dict__.iteritems()]
28159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28160 
 
28161 
  def __eq__(self, other):
28162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28163 
 
28164 
  def __ne__(self, other):
28165 
    return not (self == other)
28166 
 
28167 
class getRechargeOrdersForTransaction_result:
28168 
  """
28169 
  Attributes:
28170 
   - success
28171 
   - ex
28172 
  """
28173 
 
28174 
  thrift_spec = (
28175 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28177 
  )
28178 
 
28179 
  def __init__(self, success=None, ex=None,):
28180 
    self.success = success
28181 
    self.ex = ex
28182 
 
28183 
  def read(self, iprot):
28184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28186 
      return
28187 
    iprot.readStructBegin()
28188 
    while True:
28189 
      (fname, ftype, fid) = iprot.readFieldBegin()
28190 
      if ftype == TType.STOP:
28191 
        break
28192 
      if fid == 0:
28193 
        if ftype == TType.STRUCT:
28194 
          self.success = RechargeOrder()
28195 
          self.success.read(iprot)
28196 
        else:
28197 
          iprot.skip(ftype)
28198 
      elif fid == 1:
28199 
        if ftype == TType.STRUCT:
28200 
          self.ex = TransactionServiceException()
28201 
          self.ex.read(iprot)
28202 
        else:
28203 
          iprot.skip(ftype)
28204 
      else:
28205 
        iprot.skip(ftype)
28206 
      iprot.readFieldEnd()
28207 
    iprot.readStructEnd()
28208 
 
28209 
  def write(self, oprot):
28210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28212 
      return
28213 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28214 
    if self.success is not None:
28215 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28216 
      self.success.write(oprot)
28217 
      oprot.writeFieldEnd()
28218 
    if self.ex is not None:
28219 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28220 
      self.ex.write(oprot)
28221 
      oprot.writeFieldEnd()
28222 
    oprot.writeFieldStop()
28223 
    oprot.writeStructEnd()
28224 
 
28225 
  def validate(self):
28226 
    return
28227 
 
28228 
 
28229 
  def __repr__(self):
28230 
    L = ['%s=%r' % (key, value)
28231 
      for key, value in self.__dict__.iteritems()]
28232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28233 
 
28234 
  def __eq__(self, other):
28235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28236 
 
28237 
  def __ne__(self, other):
28238 
    return not (self == other)
28239 
 
6048 rajveer 28240 
class getServiceProviders_args:
28241 
  """
28242 
  Attributes:
28243 
   - rechargeType
6206 rajveer 28244 
   - onlyActive
6048 rajveer 28245 
  """
28246 
 
28247 
  thrift_spec = (
28248 
    None, # 0
28249 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28250 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28251 
  )
28252 
 
6206 rajveer 28253 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28254 
    self.rechargeType = rechargeType
6206 rajveer 28255 
    self.onlyActive = onlyActive
6048 rajveer 28256 
 
28257 
  def read(self, iprot):
28258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28260 
      return
28261 
    iprot.readStructBegin()
28262 
    while True:
28263 
      (fname, ftype, fid) = iprot.readFieldBegin()
28264 
      if ftype == TType.STOP:
28265 
        break
28266 
      if fid == 1:
28267 
        if ftype == TType.I32:
28268 
          self.rechargeType = iprot.readI32();
28269 
        else:
28270 
          iprot.skip(ftype)
6206 rajveer 28271 
      elif fid == 2:
28272 
        if ftype == TType.BOOL:
28273 
          self.onlyActive = iprot.readBool();
28274 
        else:
28275 
          iprot.skip(ftype)
6048 rajveer 28276 
      else:
28277 
        iprot.skip(ftype)
28278 
      iprot.readFieldEnd()
28279 
    iprot.readStructEnd()
28280 
 
28281 
  def write(self, oprot):
28282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28284 
      return
28285 
    oprot.writeStructBegin('getServiceProviders_args')
28286 
    if self.rechargeType is not None:
28287 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28288 
      oprot.writeI32(self.rechargeType)
28289 
      oprot.writeFieldEnd()
6206 rajveer 28290 
    if self.onlyActive is not None:
28291 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28292 
      oprot.writeBool(self.onlyActive)
28293 
      oprot.writeFieldEnd()
6048 rajveer 28294 
    oprot.writeFieldStop()
28295 
    oprot.writeStructEnd()
28296 
 
28297 
  def validate(self):
28298 
    return
28299 
 
28300 
 
28301 
  def __repr__(self):
28302 
    L = ['%s=%r' % (key, value)
28303 
      for key, value in self.__dict__.iteritems()]
28304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28305 
 
28306 
  def __eq__(self, other):
28307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28308 
 
28309 
  def __ne__(self, other):
28310 
    return not (self == other)
28311 
 
28312 
class getServiceProviders_result:
28313 
  """
28314 
  Attributes:
28315 
   - success
28316 
  """
28317 
 
28318 
  thrift_spec = (
28319 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28320 
  )
28321 
 
28322 
  def __init__(self, success=None,):
28323 
    self.success = success
28324 
 
28325 
  def read(self, iprot):
28326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28328 
      return
28329 
    iprot.readStructBegin()
28330 
    while True:
28331 
      (fname, ftype, fid) = iprot.readFieldBegin()
28332 
      if ftype == TType.STOP:
28333 
        break
28334 
      if fid == 0:
28335 
        if ftype == TType.MAP:
28336 
          self.success = {}
6188 rajveer 28337 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28338 
          for _i674 in xrange(_size670):
28339 
            _key675 = iprot.readI64();
28340 
            _val676 = iprot.readString();
28341 
            self.success[_key675] = _val676
6048 rajveer 28342 
          iprot.readMapEnd()
28343 
        else:
28344 
          iprot.skip(ftype)
28345 
      else:
28346 
        iprot.skip(ftype)
28347 
      iprot.readFieldEnd()
28348 
    iprot.readStructEnd()
28349 
 
28350 
  def write(self, oprot):
28351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28353 
      return
28354 
    oprot.writeStructBegin('getServiceProviders_result')
28355 
    if self.success is not None:
28356 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28357 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28358 
      for kiter677,viter678 in self.success.items():
28359 
        oprot.writeI64(kiter677)
28360 
        oprot.writeString(viter678)
6048 rajveer 28361 
      oprot.writeMapEnd()
28362 
      oprot.writeFieldEnd()
28363 
    oprot.writeFieldStop()
28364 
    oprot.writeStructEnd()
28365 
 
28366 
  def validate(self):
28367 
    return
28368 
 
28369 
 
28370 
  def __repr__(self):
28371 
    L = ['%s=%r' % (key, value)
28372 
      for key, value in self.__dict__.iteritems()]
28373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28374 
 
28375 
  def __eq__(self, other):
28376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28377 
 
28378 
  def __ne__(self, other):
28379 
    return not (self == other)
28380 
 
28381 
class getServiceProviderForDevice_args:
28382 
  """
28383 
  Attributes:
6049 rajveer 28384 
   - rechargeType
6048 rajveer 28385 
   - deviceNumber
28386 
  """
28387 
 
28388 
  thrift_spec = (
28389 
    None, # 0
6049 rajveer 28390 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28391 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28392 
  )
28393 
 
6049 rajveer 28394 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28395 
    self.rechargeType = rechargeType
6048 rajveer 28396 
    self.deviceNumber = deviceNumber
28397 
 
28398 
  def read(self, iprot):
28399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28401 
      return
28402 
    iprot.readStructBegin()
28403 
    while True:
28404 
      (fname, ftype, fid) = iprot.readFieldBegin()
28405 
      if ftype == TType.STOP:
28406 
        break
28407 
      if fid == 1:
6049 rajveer 28408 
        if ftype == TType.I32:
28409 
          self.rechargeType = iprot.readI32();
28410 
        else:
28411 
          iprot.skip(ftype)
28412 
      elif fid == 2:
6048 rajveer 28413 
        if ftype == TType.STRING:
28414 
          self.deviceNumber = iprot.readString();
28415 
        else:
28416 
          iprot.skip(ftype)
28417 
      else:
28418 
        iprot.skip(ftype)
28419 
      iprot.readFieldEnd()
28420 
    iprot.readStructEnd()
28421 
 
28422 
  def write(self, oprot):
28423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28425 
      return
28426 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28427 
    if self.rechargeType is not None:
28428 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28429 
      oprot.writeI32(self.rechargeType)
28430 
      oprot.writeFieldEnd()
6048 rajveer 28431 
    if self.deviceNumber is not None:
6049 rajveer 28432 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28433 
      oprot.writeString(self.deviceNumber)
28434 
      oprot.writeFieldEnd()
28435 
    oprot.writeFieldStop()
28436 
    oprot.writeStructEnd()
28437 
 
28438 
  def validate(self):
28439 
    return
28440 
 
28441 
 
28442 
  def __repr__(self):
28443 
    L = ['%s=%r' % (key, value)
28444 
      for key, value in self.__dict__.iteritems()]
28445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28446 
 
28447 
  def __eq__(self, other):
28448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28449 
 
28450 
  def __ne__(self, other):
28451 
    return not (self == other)
28452 
 
28453 
class getServiceProviderForDevice_result:
28454 
  """
28455 
  Attributes:
28456 
   - success
28457 
  """
28458 
 
28459 
  thrift_spec = (
6289 anupam.sin 28460 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28461 
  )
28462 
 
28463 
  def __init__(self, success=None,):
28464 
    self.success = success
28465 
 
28466 
  def read(self, iprot):
28467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28469 
      return
28470 
    iprot.readStructBegin()
28471 
    while True:
28472 
      (fname, ftype, fid) = iprot.readFieldBegin()
28473 
      if ftype == TType.STOP:
28474 
        break
28475 
      if fid == 0:
6289 anupam.sin 28476 
        if ftype == TType.STRUCT:
28477 
          self.success = DeviceNumberInfo()
28478 
          self.success.read(iprot)
6048 rajveer 28479 
        else:
28480 
          iprot.skip(ftype)
28481 
      else:
28482 
        iprot.skip(ftype)
28483 
      iprot.readFieldEnd()
28484 
    iprot.readStructEnd()
28485 
 
28486 
  def write(self, oprot):
28487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28489 
      return
28490 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28491 
    if self.success is not None:
6289 anupam.sin 28492 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28493 
      self.success.write(oprot)
6048 rajveer 28494 
      oprot.writeFieldEnd()
28495 
    oprot.writeFieldStop()
28496 
    oprot.writeStructEnd()
28497 
 
28498 
  def validate(self):
28499 
    return
28500 
 
28501 
 
28502 
  def __repr__(self):
28503 
    L = ['%s=%r' % (key, value)
28504 
      for key, value in self.__dict__.iteritems()]
28505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28506 
 
28507 
  def __eq__(self, other):
28508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28509 
 
28510 
  def __ne__(self, other):
28511 
    return not (self == other)
6094 rajveer 28512 
 
6269 rajveer 28513 
class validateRecharge_args:
28514 
  """
28515 
  Attributes:
28516 
   - rechargeType
28517 
   - deviceNumber
6307 anupam.sin 28518 
   - userSelectedProviderId
6591 anupam.sin 28519 
   - clientAddress
6269 rajveer 28520 
  """
28521 
 
28522 
  thrift_spec = (
28523 
    None, # 0
28524 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28525 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28526 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28527 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28528 
  )
28529 
 
6591 anupam.sin 28530 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28531 
    self.rechargeType = rechargeType
28532 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28533 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28534 
    self.clientAddress = clientAddress
6269 rajveer 28535 
 
28536 
  def read(self, iprot):
28537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28539 
      return
28540 
    iprot.readStructBegin()
28541 
    while True:
28542 
      (fname, ftype, fid) = iprot.readFieldBegin()
28543 
      if ftype == TType.STOP:
28544 
        break
28545 
      if fid == 1:
28546 
        if ftype == TType.I32:
28547 
          self.rechargeType = iprot.readI32();
28548 
        else:
28549 
          iprot.skip(ftype)
28550 
      elif fid == 2:
28551 
        if ftype == TType.STRING:
28552 
          self.deviceNumber = iprot.readString();
28553 
        else:
28554 
          iprot.skip(ftype)
6307 anupam.sin 28555 
      elif fid == 3:
28556 
        if ftype == TType.I64:
28557 
          self.userSelectedProviderId = iprot.readI64();
28558 
        else:
28559 
          iprot.skip(ftype)
6591 anupam.sin 28560 
      elif fid == 4:
28561 
        if ftype == TType.STRING:
28562 
          self.clientAddress = iprot.readString();
28563 
        else:
28564 
          iprot.skip(ftype)
6269 rajveer 28565 
      else:
28566 
        iprot.skip(ftype)
28567 
      iprot.readFieldEnd()
28568 
    iprot.readStructEnd()
28569 
 
28570 
  def write(self, oprot):
28571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28573 
      return
28574 
    oprot.writeStructBegin('validateRecharge_args')
28575 
    if self.rechargeType is not None:
28576 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28577 
      oprot.writeI32(self.rechargeType)
28578 
      oprot.writeFieldEnd()
28579 
    if self.deviceNumber is not None:
28580 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28581 
      oprot.writeString(self.deviceNumber)
28582 
      oprot.writeFieldEnd()
6307 anupam.sin 28583 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28584 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28585 
      oprot.writeI64(self.userSelectedProviderId)
28586 
      oprot.writeFieldEnd()
6591 anupam.sin 28587 
    if self.clientAddress is not None:
28588 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28589 
      oprot.writeString(self.clientAddress)
28590 
      oprot.writeFieldEnd()
6269 rajveer 28591 
    oprot.writeFieldStop()
28592 
    oprot.writeStructEnd()
28593 
 
28594 
  def validate(self):
28595 
    return
28596 
 
28597 
 
28598 
  def __repr__(self):
28599 
    L = ['%s=%r' % (key, value)
28600 
      for key, value in self.__dict__.iteritems()]
28601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28602 
 
28603 
  def __eq__(self, other):
28604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28605 
 
28606 
  def __ne__(self, other):
28607 
    return not (self == other)
28608 
 
28609 
class validateRecharge_result:
28610 
  """
28611 
  Attributes:
28612 
   - success
28613 
  """
28614 
 
28615 
  thrift_spec = (
28616 
    (0, TType.STRING, 'success', None, None, ), # 0
28617 
  )
28618 
 
28619 
  def __init__(self, success=None,):
28620 
    self.success = success
28621 
 
28622 
  def read(self, iprot):
28623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28625 
      return
28626 
    iprot.readStructBegin()
28627 
    while True:
28628 
      (fname, ftype, fid) = iprot.readFieldBegin()
28629 
      if ftype == TType.STOP:
28630 
        break
28631 
      if fid == 0:
28632 
        if ftype == TType.STRING:
28633 
          self.success = iprot.readString();
28634 
        else:
28635 
          iprot.skip(ftype)
28636 
      else:
28637 
        iprot.skip(ftype)
28638 
      iprot.readFieldEnd()
28639 
    iprot.readStructEnd()
28640 
 
28641 
  def write(self, oprot):
28642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28644 
      return
28645 
    oprot.writeStructBegin('validateRecharge_result')
28646 
    if self.success is not None:
28647 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28648 
      oprot.writeString(self.success)
28649 
      oprot.writeFieldEnd()
28650 
    oprot.writeFieldStop()
28651 
    oprot.writeStructEnd()
28652 
 
28653 
  def validate(self):
28654 
    return
28655 
 
28656 
 
28657 
  def __repr__(self):
28658 
    L = ['%s=%r' % (key, value)
28659 
      for key, value in self.__dict__.iteritems()]
28660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28661 
 
28662 
  def __eq__(self, other):
28663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28664 
 
28665 
  def __ne__(self, other):
28666 
    return not (self == other)
28667 
 
6094 rajveer 28668 
class getRechargeOrdersForDevice_args:
28669 
  """
28670 
  Attributes:
28671 
   - deviceNumber
28672 
  """
28673 
 
28674 
  thrift_spec = (
28675 
    None, # 0
28676 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28677 
  )
28678 
 
28679 
  def __init__(self, deviceNumber=None,):
28680 
    self.deviceNumber = deviceNumber
28681 
 
28682 
  def read(self, iprot):
28683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28685 
      return
28686 
    iprot.readStructBegin()
28687 
    while True:
28688 
      (fname, ftype, fid) = iprot.readFieldBegin()
28689 
      if ftype == TType.STOP:
28690 
        break
28691 
      if fid == 1:
28692 
        if ftype == TType.STRING:
28693 
          self.deviceNumber = iprot.readString();
28694 
        else:
28695 
          iprot.skip(ftype)
28696 
      else:
28697 
        iprot.skip(ftype)
28698 
      iprot.readFieldEnd()
28699 
    iprot.readStructEnd()
28700 
 
28701 
  def write(self, oprot):
28702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28704 
      return
28705 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28706 
    if self.deviceNumber is not None:
28707 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28708 
      oprot.writeString(self.deviceNumber)
28709 
      oprot.writeFieldEnd()
28710 
    oprot.writeFieldStop()
28711 
    oprot.writeStructEnd()
28712 
 
28713 
  def validate(self):
28714 
    return
28715 
 
28716 
 
28717 
  def __repr__(self):
28718 
    L = ['%s=%r' % (key, value)
28719 
      for key, value in self.__dict__.iteritems()]
28720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28721 
 
28722 
  def __eq__(self, other):
28723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28724 
 
28725 
  def __ne__(self, other):
28726 
    return not (self == other)
28727 
 
28728 
class getRechargeOrdersForDevice_result:
28729 
  """
28730 
  Attributes:
28731 
   - success
28732 
  """
28733 
 
28734 
  thrift_spec = (
28735 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28736 
  )
28737 
 
28738 
  def __init__(self, success=None,):
28739 
    self.success = success
28740 
 
28741 
  def read(self, iprot):
28742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28744 
      return
28745 
    iprot.readStructBegin()
28746 
    while True:
28747 
      (fname, ftype, fid) = iprot.readFieldBegin()
28748 
      if ftype == TType.STOP:
28749 
        break
28750 
      if fid == 0:
28751 
        if ftype == TType.LIST:
28752 
          self.success = []
6188 rajveer 28753 
          (_etype682, _size679) = iprot.readListBegin()
28754 
          for _i683 in xrange(_size679):
28755 
            _elem684 = RechargeOrder()
28756 
            _elem684.read(iprot)
28757 
            self.success.append(_elem684)
6094 rajveer 28758 
          iprot.readListEnd()
28759 
        else:
28760 
          iprot.skip(ftype)
28761 
      else:
28762 
        iprot.skip(ftype)
28763 
      iprot.readFieldEnd()
28764 
    iprot.readStructEnd()
28765 
 
28766 
  def write(self, oprot):
28767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28769 
      return
28770 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28771 
    if self.success is not None:
28772 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28773 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28774 
      for iter685 in self.success:
28775 
        iter685.write(oprot)
6094 rajveer 28776 
      oprot.writeListEnd()
28777 
      oprot.writeFieldEnd()
28778 
    oprot.writeFieldStop()
28779 
    oprot.writeStructEnd()
28780 
 
28781 
  def validate(self):
28782 
    return
28783 
 
28784 
 
28785 
  def __repr__(self):
28786 
    L = ['%s=%r' % (key, value)
28787 
      for key, value in self.__dict__.iteritems()]
28788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28789 
 
28790 
  def __eq__(self, other):
28791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28792 
 
28793 
  def __ne__(self, other):
28794 
    return not (self == other)
28795 
 
28796 
class addAmountToWallet_args:
28797 
  """
28798 
  Attributes:
28799 
   - userId
28800 
   - orderId
28801 
   - amount
28802 
  """
28803 
 
28804 
  thrift_spec = (
28805 
    None, # 0
28806 
    (1, TType.I64, 'userId', None, None, ), # 1
28807 
    (2, TType.I64, 'orderId', None, None, ), # 2
28808 
    (3, TType.I64, 'amount', None, None, ), # 3
28809 
  )
28810 
 
28811 
  def __init__(self, userId=None, orderId=None, amount=None,):
28812 
    self.userId = userId
28813 
    self.orderId = orderId
28814 
    self.amount = amount
28815 
 
28816 
  def read(self, iprot):
28817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28819 
      return
28820 
    iprot.readStructBegin()
28821 
    while True:
28822 
      (fname, ftype, fid) = iprot.readFieldBegin()
28823 
      if ftype == TType.STOP:
28824 
        break
28825 
      if fid == 1:
28826 
        if ftype == TType.I64:
28827 
          self.userId = iprot.readI64();
28828 
        else:
28829 
          iprot.skip(ftype)
28830 
      elif fid == 2:
28831 
        if ftype == TType.I64:
28832 
          self.orderId = iprot.readI64();
28833 
        else:
28834 
          iprot.skip(ftype)
28835 
      elif fid == 3:
28836 
        if ftype == TType.I64:
28837 
          self.amount = iprot.readI64();
28838 
        else:
28839 
          iprot.skip(ftype)
28840 
      else:
28841 
        iprot.skip(ftype)
28842 
      iprot.readFieldEnd()
28843 
    iprot.readStructEnd()
28844 
 
28845 
  def write(self, oprot):
28846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28848 
      return
28849 
    oprot.writeStructBegin('addAmountToWallet_args')
28850 
    if self.userId is not None:
28851 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28852 
      oprot.writeI64(self.userId)
28853 
      oprot.writeFieldEnd()
28854 
    if self.orderId is not None:
28855 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28856 
      oprot.writeI64(self.orderId)
28857 
      oprot.writeFieldEnd()
28858 
    if self.amount is not None:
28859 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28860 
      oprot.writeI64(self.amount)
28861 
      oprot.writeFieldEnd()
28862 
    oprot.writeFieldStop()
28863 
    oprot.writeStructEnd()
28864 
 
28865 
  def validate(self):
28866 
    return
28867 
 
28868 
 
28869 
  def __repr__(self):
28870 
    L = ['%s=%r' % (key, value)
28871 
      for key, value in self.__dict__.iteritems()]
28872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28873 
 
28874 
  def __eq__(self, other):
28875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28876 
 
28877 
  def __ne__(self, other):
28878 
    return not (self == other)
28879 
 
28880 
class addAmountToWallet_result:
28881 
 
28882 
  thrift_spec = (
28883 
  )
28884 
 
28885 
  def read(self, iprot):
28886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28888 
      return
28889 
    iprot.readStructBegin()
28890 
    while True:
28891 
      (fname, ftype, fid) = iprot.readFieldBegin()
28892 
      if ftype == TType.STOP:
28893 
        break
28894 
      else:
28895 
        iprot.skip(ftype)
28896 
      iprot.readFieldEnd()
28897 
    iprot.readStructEnd()
28898 
 
28899 
  def write(self, oprot):
28900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28902 
      return
28903 
    oprot.writeStructBegin('addAmountToWallet_result')
28904 
    oprot.writeFieldStop()
28905 
    oprot.writeStructEnd()
28906 
 
28907 
  def validate(self):
28908 
    return
28909 
 
28910 
 
28911 
  def __repr__(self):
28912 
    L = ['%s=%r' % (key, value)
28913 
      for key, value in self.__dict__.iteritems()]
28914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28915 
 
28916 
  def __eq__(self, other):
28917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28918 
 
28919 
  def __ne__(self, other):
28920 
    return not (self == other)
6154 rajveer 28921 
 
6188 rajveer 28922 
class getRechargeStatistics_args:
28923 
 
28924 
  thrift_spec = (
28925 
  )
28926 
 
28927 
  def read(self, iprot):
28928 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28929 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28930 
      return
28931 
    iprot.readStructBegin()
28932 
    while True:
28933 
      (fname, ftype, fid) = iprot.readFieldBegin()
28934 
      if ftype == TType.STOP:
28935 
        break
28936 
      else:
28937 
        iprot.skip(ftype)
28938 
      iprot.readFieldEnd()
28939 
    iprot.readStructEnd()
28940 
 
28941 
  def write(self, oprot):
28942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28944 
      return
28945 
    oprot.writeStructBegin('getRechargeStatistics_args')
28946 
    oprot.writeFieldStop()
28947 
    oprot.writeStructEnd()
28948 
 
28949 
  def validate(self):
28950 
    return
28951 
 
28952 
 
28953 
  def __repr__(self):
28954 
    L = ['%s=%r' % (key, value)
28955 
      for key, value in self.__dict__.iteritems()]
28956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28957 
 
28958 
  def __eq__(self, other):
28959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28960 
 
28961 
  def __ne__(self, other):
28962 
    return not (self == other)
28963 
 
28964 
class getRechargeStatistics_result:
28965 
  """
28966 
  Attributes:
28967 
   - success
28968 
  """
28969 
 
28970 
  thrift_spec = (
28971 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28972 
  )
28973 
 
28974 
  def __init__(self, success=None,):
28975 
    self.success = success
28976 
 
28977 
  def read(self, iprot):
28978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28980 
      return
28981 
    iprot.readStructBegin()
28982 
    while True:
28983 
      (fname, ftype, fid) = iprot.readFieldBegin()
28984 
      if ftype == TType.STOP:
28985 
        break
28986 
      if fid == 0:
28987 
        if ftype == TType.STRUCT:
28988 
          self.success = RechargeStatistics()
28989 
          self.success.read(iprot)
28990 
        else:
28991 
          iprot.skip(ftype)
28992 
      else:
28993 
        iprot.skip(ftype)
28994 
      iprot.readFieldEnd()
28995 
    iprot.readStructEnd()
28996 
 
28997 
  def write(self, oprot):
28998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29000 
      return
29001 
    oprot.writeStructBegin('getRechargeStatistics_result')
29002 
    if self.success is not None:
29003 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29004 
      self.success.write(oprot)
29005 
      oprot.writeFieldEnd()
29006 
    oprot.writeFieldStop()
29007 
    oprot.writeStructEnd()
29008 
 
29009 
  def validate(self):
29010 
    return
29011 
 
29012 
 
29013 
  def __repr__(self):
29014 
    L = ['%s=%r' % (key, value)
29015 
      for key, value in self.__dict__.iteritems()]
29016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29017 
 
29018 
  def __eq__(self, other):
29019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29020 
 
29021 
  def __ne__(self, other):
29022 
    return not (self == other)
29023 
 
6154 rajveer 29024 
class getRechargeOrdersForStatus_args:
29025 
  """
29026 
  Attributes:
29027 
   - status
29028 
  """
29029 
 
29030 
  thrift_spec = (
29031 
    None, # 0
29032 
    (1, TType.I64, 'status', None, None, ), # 1
29033 
  )
29034 
 
29035 
  def __init__(self, status=None,):
29036 
    self.status = status
29037 
 
29038 
  def read(self, iprot):
29039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29041 
      return
29042 
    iprot.readStructBegin()
29043 
    while True:
29044 
      (fname, ftype, fid) = iprot.readFieldBegin()
29045 
      if ftype == TType.STOP:
29046 
        break
29047 
      if fid == 1:
29048 
        if ftype == TType.I64:
29049 
          self.status = iprot.readI64();
29050 
        else:
29051 
          iprot.skip(ftype)
29052 
      else:
29053 
        iprot.skip(ftype)
29054 
      iprot.readFieldEnd()
29055 
    iprot.readStructEnd()
29056 
 
29057 
  def write(self, oprot):
29058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29060 
      return
29061 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29062 
    if self.status is not None:
29063 
      oprot.writeFieldBegin('status', TType.I64, 1)
29064 
      oprot.writeI64(self.status)
29065 
      oprot.writeFieldEnd()
29066 
    oprot.writeFieldStop()
29067 
    oprot.writeStructEnd()
29068 
 
29069 
  def validate(self):
29070 
    return
29071 
 
29072 
 
29073 
  def __repr__(self):
29074 
    L = ['%s=%r' % (key, value)
29075 
      for key, value in self.__dict__.iteritems()]
29076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29077 
 
29078 
  def __eq__(self, other):
29079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29080 
 
29081 
  def __ne__(self, other):
29082 
    return not (self == other)
29083 
 
29084 
class getRechargeOrdersForStatus_result:
29085 
  """
29086 
  Attributes:
29087 
   - success
29088 
  """
29089 
 
29090 
  thrift_spec = (
29091 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29092 
  )
29093 
 
29094 
  def __init__(self, success=None,):
29095 
    self.success = success
29096 
 
29097 
  def read(self, iprot):
29098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29100 
      return
29101 
    iprot.readStructBegin()
29102 
    while True:
29103 
      (fname, ftype, fid) = iprot.readFieldBegin()
29104 
      if ftype == TType.STOP:
29105 
        break
29106 
      if fid == 0:
29107 
        if ftype == TType.LIST:
29108 
          self.success = []
6188 rajveer 29109 
          (_etype689, _size686) = iprot.readListBegin()
29110 
          for _i690 in xrange(_size686):
29111 
            _elem691 = RechargeOrder()
29112 
            _elem691.read(iprot)
29113 
            self.success.append(_elem691)
6154 rajveer 29114 
          iprot.readListEnd()
29115 
        else:
29116 
          iprot.skip(ftype)
29117 
      else:
29118 
        iprot.skip(ftype)
29119 
      iprot.readFieldEnd()
29120 
    iprot.readStructEnd()
29121 
 
29122 
  def write(self, oprot):
29123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29125 
      return
29126 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29127 
    if self.success is not None:
29128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29130 
      for iter692 in self.success:
29131 
        iter692.write(oprot)
6154 rajveer 29132 
      oprot.writeListEnd()
29133 
      oprot.writeFieldEnd()
29134 
    oprot.writeFieldStop()
29135 
    oprot.writeStructEnd()
29136 
 
29137 
  def validate(self):
29138 
    return
29139 
 
29140 
 
29141 
  def __repr__(self):
29142 
    L = ['%s=%r' % (key, value)
29143 
      for key, value in self.__dict__.iteritems()]
29144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29145 
 
29146 
  def __eq__(self, other):
29147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29148 
 
29149 
  def __ne__(self, other):
29150 
    return not (self == other)
6159 rajveer 29151 
 
29152 
class getPlansForOperator_args:
29153 
  """
29154 
  Attributes:
29155 
   - operatorId
29156 
  """
29157 
 
29158 
  thrift_spec = (
29159 
    None, # 0
29160 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29161 
  )
29162 
 
29163 
  def __init__(self, operatorId=None,):
29164 
    self.operatorId = operatorId
29165 
 
29166 
  def read(self, iprot):
29167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29169 
      return
29170 
    iprot.readStructBegin()
29171 
    while True:
29172 
      (fname, ftype, fid) = iprot.readFieldBegin()
29173 
      if ftype == TType.STOP:
29174 
        break
29175 
      if fid == 1:
29176 
        if ftype == TType.I64:
29177 
          self.operatorId = iprot.readI64();
29178 
        else:
29179 
          iprot.skip(ftype)
29180 
      else:
29181 
        iprot.skip(ftype)
29182 
      iprot.readFieldEnd()
29183 
    iprot.readStructEnd()
29184 
 
29185 
  def write(self, oprot):
29186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29188 
      return
29189 
    oprot.writeStructBegin('getPlansForOperator_args')
29190 
    if self.operatorId is not None:
29191 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29192 
      oprot.writeI64(self.operatorId)
29193 
      oprot.writeFieldEnd()
29194 
    oprot.writeFieldStop()
29195 
    oprot.writeStructEnd()
29196 
 
29197 
  def validate(self):
29198 
    return
29199 
 
29200 
 
29201 
  def __repr__(self):
29202 
    L = ['%s=%r' % (key, value)
29203 
      for key, value in self.__dict__.iteritems()]
29204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29205 
 
29206 
  def __eq__(self, other):
29207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29208 
 
29209 
  def __ne__(self, other):
29210 
    return not (self == other)
29211 
 
29212 
class getPlansForOperator_result:
29213 
  """
29214 
  Attributes:
29215 
   - success
29216 
  """
29217 
 
29218 
  thrift_spec = (
29219 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29220 
  )
29221 
 
29222 
  def __init__(self, success=None,):
29223 
    self.success = success
29224 
 
29225 
  def read(self, iprot):
29226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29228 
      return
29229 
    iprot.readStructBegin()
29230 
    while True:
29231 
      (fname, ftype, fid) = iprot.readFieldBegin()
29232 
      if ftype == TType.STOP:
29233 
        break
29234 
      if fid == 0:
29235 
        if ftype == TType.LIST:
29236 
          self.success = []
6188 rajveer 29237 
          (_etype696, _size693) = iprot.readListBegin()
29238 
          for _i697 in xrange(_size693):
29239 
            _elem698 = RechargePlan()
29240 
            _elem698.read(iprot)
29241 
            self.success.append(_elem698)
6159 rajveer 29242 
          iprot.readListEnd()
29243 
        else:
29244 
          iprot.skip(ftype)
29245 
      else:
29246 
        iprot.skip(ftype)
29247 
      iprot.readFieldEnd()
29248 
    iprot.readStructEnd()
29249 
 
29250 
  def write(self, oprot):
29251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29253 
      return
29254 
    oprot.writeStructBegin('getPlansForOperator_result')
29255 
    if self.success is not None:
29256 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29257 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29258 
      for iter699 in self.success:
29259 
        iter699.write(oprot)
6159 rajveer 29260 
      oprot.writeListEnd()
29261 
      oprot.writeFieldEnd()
29262 
    oprot.writeFieldStop()
29263 
    oprot.writeStructEnd()
29264 
 
29265 
  def validate(self):
29266 
    return
29267 
 
29268 
 
29269 
  def __repr__(self):
29270 
    L = ['%s=%r' % (key, value)
29271 
      for key, value in self.__dict__.iteritems()]
29272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29273 
 
29274 
  def __eq__(self, other):
29275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29276 
 
29277 
  def __ne__(self, other):
29278 
    return not (self == other)
6289 anupam.sin 29279 
 
29280 
class getRechargeDenominations_args:
29281 
  """
29282 
  Attributes:
29283 
   - operatorId
6307 anupam.sin 29284 
   - circleCode
6289 anupam.sin 29285 
   - denominationType
29286 
  """
29287 
 
29288 
  thrift_spec = (
29289 
    None, # 0
29290 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29291 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29292 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29293 
  )
29294 
 
6307 anupam.sin 29295 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29296 
    self.operatorId = operatorId
6307 anupam.sin 29297 
    self.circleCode = circleCode
6289 anupam.sin 29298 
    self.denominationType = denominationType
29299 
 
29300 
  def read(self, iprot):
29301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29303 
      return
29304 
    iprot.readStructBegin()
29305 
    while True:
29306 
      (fname, ftype, fid) = iprot.readFieldBegin()
29307 
      if ftype == TType.STOP:
29308 
        break
29309 
      if fid == 1:
29310 
        if ftype == TType.I64:
29311 
          self.operatorId = iprot.readI64();
29312 
        else:
29313 
          iprot.skip(ftype)
29314 
      elif fid == 2:
29315 
        if ftype == TType.STRING:
6307 anupam.sin 29316 
          self.circleCode = iprot.readString();
6289 anupam.sin 29317 
        else:
29318 
          iprot.skip(ftype)
29319 
      elif fid == 3:
29320 
        if ftype == TType.I32:
29321 
          self.denominationType = iprot.readI32();
29322 
        else:
29323 
          iprot.skip(ftype)
29324 
      else:
29325 
        iprot.skip(ftype)
29326 
      iprot.readFieldEnd()
29327 
    iprot.readStructEnd()
29328 
 
29329 
  def write(self, oprot):
29330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29332 
      return
29333 
    oprot.writeStructBegin('getRechargeDenominations_args')
29334 
    if self.operatorId is not None:
29335 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29336 
      oprot.writeI64(self.operatorId)
29337 
      oprot.writeFieldEnd()
6307 anupam.sin 29338 
    if self.circleCode is not None:
29339 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29340 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29341 
      oprot.writeFieldEnd()
29342 
    if self.denominationType is not None:
29343 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29344 
      oprot.writeI32(self.denominationType)
29345 
      oprot.writeFieldEnd()
29346 
    oprot.writeFieldStop()
29347 
    oprot.writeStructEnd()
29348 
 
29349 
  def validate(self):
29350 
    return
29351 
 
29352 
 
29353 
  def __repr__(self):
29354 
    L = ['%s=%r' % (key, value)
29355 
      for key, value in self.__dict__.iteritems()]
29356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29357 
 
29358 
  def __eq__(self, other):
29359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29360 
 
29361 
  def __ne__(self, other):
29362 
    return not (self == other)
29363 
 
29364 
class getRechargeDenominations_result:
29365 
  """
29366 
  Attributes:
29367 
   - success
29368 
   - ex
29369 
  """
29370 
 
29371 
  thrift_spec = (
29372 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29374 
  )
29375 
 
29376 
  def __init__(self, success=None, ex=None,):
29377 
    self.success = success
29378 
    self.ex = ex
29379 
 
29380 
  def read(self, iprot):
29381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29383 
      return
29384 
    iprot.readStructBegin()
29385 
    while True:
29386 
      (fname, ftype, fid) = iprot.readFieldBegin()
29387 
      if ftype == TType.STOP:
29388 
        break
29389 
      if fid == 0:
29390 
        if ftype == TType.LIST:
29391 
          self.success = []
29392 
          (_etype703, _size700) = iprot.readListBegin()
29393 
          for _i704 in xrange(_size700):
29394 
            _elem705 = RechargeDenomination()
29395 
            _elem705.read(iprot)
29396 
            self.success.append(_elem705)
29397 
          iprot.readListEnd()
29398 
        else:
29399 
          iprot.skip(ftype)
29400 
      elif fid == 1:
29401 
        if ftype == TType.STRUCT:
29402 
          self.ex = TransactionServiceException()
29403 
          self.ex.read(iprot)
29404 
        else:
29405 
          iprot.skip(ftype)
29406 
      else:
29407 
        iprot.skip(ftype)
29408 
      iprot.readFieldEnd()
29409 
    iprot.readStructEnd()
29410 
 
29411 
  def write(self, oprot):
29412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29414 
      return
29415 
    oprot.writeStructBegin('getRechargeDenominations_result')
29416 
    if self.success is not None:
29417 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29418 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29419 
      for iter706 in self.success:
29420 
        iter706.write(oprot)
29421 
      oprot.writeListEnd()
29422 
      oprot.writeFieldEnd()
29423 
    if self.ex is not None:
29424 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29425 
      self.ex.write(oprot)
29426 
      oprot.writeFieldEnd()
29427 
    oprot.writeFieldStop()
29428 
    oprot.writeStructEnd()
29429 
 
29430 
  def validate(self):
29431 
    return
29432 
 
29433 
 
29434 
  def __repr__(self):
29435 
    L = ['%s=%r' % (key, value)
29436 
      for key, value in self.__dict__.iteritems()]
29437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29438 
 
29439 
  def __eq__(self, other):
29440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29441 
 
29442 
  def __ne__(self, other):
29443 
    return not (self == other)
6371 rajveer 29444 
 
29445 
class updateAvailabilityStatus_args:
29446 
  """
29447 
  Attributes:
29448 
   - operatorId
29449 
   - circleId
29450 
   - isAvailable
29451 
  """
29452 
 
29453 
  thrift_spec = (
29454 
    None, # 0
29455 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29456 
    (2, TType.I64, 'circleId', None, None, ), # 2
29457 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29458 
  )
29459 
 
29460 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29461 
    self.operatorId = operatorId
29462 
    self.circleId = circleId
29463 
    self.isAvailable = isAvailable
29464 
 
29465 
  def read(self, iprot):
29466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29468 
      return
29469 
    iprot.readStructBegin()
29470 
    while True:
29471 
      (fname, ftype, fid) = iprot.readFieldBegin()
29472 
      if ftype == TType.STOP:
29473 
        break
29474 
      if fid == 1:
29475 
        if ftype == TType.I64:
29476 
          self.operatorId = iprot.readI64();
29477 
        else:
29478 
          iprot.skip(ftype)
29479 
      elif fid == 2:
29480 
        if ftype == TType.I64:
29481 
          self.circleId = iprot.readI64();
29482 
        else:
29483 
          iprot.skip(ftype)
29484 
      elif fid == 3:
29485 
        if ftype == TType.BOOL:
29486 
          self.isAvailable = iprot.readBool();
29487 
        else:
29488 
          iprot.skip(ftype)
29489 
      else:
29490 
        iprot.skip(ftype)
29491 
      iprot.readFieldEnd()
29492 
    iprot.readStructEnd()
29493 
 
29494 
  def write(self, oprot):
29495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29497 
      return
29498 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29499 
    if self.operatorId is not None:
29500 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29501 
      oprot.writeI64(self.operatorId)
29502 
      oprot.writeFieldEnd()
29503 
    if self.circleId is not None:
29504 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29505 
      oprot.writeI64(self.circleId)
29506 
      oprot.writeFieldEnd()
29507 
    if self.isAvailable is not None:
29508 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29509 
      oprot.writeBool(self.isAvailable)
29510 
      oprot.writeFieldEnd()
29511 
    oprot.writeFieldStop()
29512 
    oprot.writeStructEnd()
29513 
 
29514 
  def validate(self):
29515 
    return
29516 
 
29517 
 
29518 
  def __repr__(self):
29519 
    L = ['%s=%r' % (key, value)
29520 
      for key, value in self.__dict__.iteritems()]
29521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29522 
 
29523 
  def __eq__(self, other):
29524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29525 
 
29526 
  def __ne__(self, other):
29527 
    return not (self == other)
29528 
 
29529 
class updateAvailabilityStatus_result:
29530 
 
29531 
  thrift_spec = (
29532 
  )
29533 
 
29534 
  def read(self, iprot):
29535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29537 
      return
29538 
    iprot.readStructBegin()
29539 
    while True:
29540 
      (fname, ftype, fid) = iprot.readFieldBegin()
29541 
      if ftype == TType.STOP:
29542 
        break
29543 
      else:
29544 
        iprot.skip(ftype)
29545 
      iprot.readFieldEnd()
29546 
    iprot.readStructEnd()
29547 
 
29548 
  def write(self, oprot):
29549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29551 
      return
29552 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29553 
    oprot.writeFieldStop()
29554 
    oprot.writeStructEnd()
29555 
 
29556 
  def validate(self):
29557 
    return
29558 
 
29559 
 
29560 
  def __repr__(self):
29561 
    L = ['%s=%r' % (key, value)
29562 
      for key, value in self.__dict__.iteritems()]
29563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29564 
 
29565 
  def __eq__(self, other):
29566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29567 
 
29568 
  def __ne__(self, other):
29569 
    return not (self == other)
6389 rajveer 29570 
 
29571 
class getAvailableEmiSchemes_args:
29572 
 
29573 
  thrift_spec = (
29574 
  )
29575 
 
29576 
  def read(self, iprot):
29577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29579 
      return
29580 
    iprot.readStructBegin()
29581 
    while True:
29582 
      (fname, ftype, fid) = iprot.readFieldBegin()
29583 
      if ftype == TType.STOP:
29584 
        break
29585 
      else:
29586 
        iprot.skip(ftype)
29587 
      iprot.readFieldEnd()
29588 
    iprot.readStructEnd()
29589 
 
29590 
  def write(self, oprot):
29591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29593 
      return
29594 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29595 
    oprot.writeFieldStop()
29596 
    oprot.writeStructEnd()
29597 
 
29598 
  def validate(self):
29599 
    return
29600 
 
29601 
 
29602 
  def __repr__(self):
29603 
    L = ['%s=%r' % (key, value)
29604 
      for key, value in self.__dict__.iteritems()]
29605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29606 
 
29607 
  def __eq__(self, other):
29608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29609 
 
29610 
  def __ne__(self, other):
29611 
    return not (self == other)
29612 
 
29613 
class getAvailableEmiSchemes_result:
29614 
  """
29615 
  Attributes:
29616 
   - success
29617 
  """
29618 
 
29619 
  thrift_spec = (
29620 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29621 
  )
29622 
 
29623 
  def __init__(self, success=None,):
29624 
    self.success = success
29625 
 
29626 
  def read(self, iprot):
29627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29629 
      return
29630 
    iprot.readStructBegin()
29631 
    while True:
29632 
      (fname, ftype, fid) = iprot.readFieldBegin()
29633 
      if ftype == TType.STOP:
29634 
        break
29635 
      if fid == 0:
29636 
        if ftype == TType.LIST:
29637 
          self.success = []
29638 
          (_etype710, _size707) = iprot.readListBegin()
29639 
          for _i711 in xrange(_size707):
29640 
            _elem712 = EmiScheme()
29641 
            _elem712.read(iprot)
29642 
            self.success.append(_elem712)
29643 
          iprot.readListEnd()
29644 
        else:
29645 
          iprot.skip(ftype)
29646 
      else:
29647 
        iprot.skip(ftype)
29648 
      iprot.readFieldEnd()
29649 
    iprot.readStructEnd()
29650 
 
29651 
  def write(self, oprot):
29652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29654 
      return
29655 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29656 
    if self.success is not None:
29657 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29658 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29659 
      for iter713 in self.success:
29660 
        iter713.write(oprot)
29661 
      oprot.writeListEnd()
29662 
      oprot.writeFieldEnd()
29663 
    oprot.writeFieldStop()
29664 
    oprot.writeStructEnd()
29665 
 
29666 
  def validate(self):
29667 
    return
29668 
 
29669 
 
29670 
  def __repr__(self):
29671 
    L = ['%s=%r' % (key, value)
29672 
      for key, value in self.__dict__.iteritems()]
29673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29674 
 
29675 
  def __eq__(self, other):
29676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29677 
 
29678 
  def __ne__(self, other):
29679 
    return not (self == other)
29680 
 
29681 
class getMiscCharges_args:
29682 
  """
29683 
  Attributes:
29684 
   - transactionId
29685 
  """
29686 
 
29687 
  thrift_spec = (
29688 
    None, # 0
29689 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29690 
  )
29691 
 
29692 
  def __init__(self, transactionId=None,):
29693 
    self.transactionId = transactionId
29694 
 
29695 
  def read(self, iprot):
29696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29698 
      return
29699 
    iprot.readStructBegin()
29700 
    while True:
29701 
      (fname, ftype, fid) = iprot.readFieldBegin()
29702 
      if ftype == TType.STOP:
29703 
        break
29704 
      if fid == 1:
29705 
        if ftype == TType.I64:
29706 
          self.transactionId = iprot.readI64();
29707 
        else:
29708 
          iprot.skip(ftype)
29709 
      else:
29710 
        iprot.skip(ftype)
29711 
      iprot.readFieldEnd()
29712 
    iprot.readStructEnd()
29713 
 
29714 
  def write(self, oprot):
29715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29717 
      return
29718 
    oprot.writeStructBegin('getMiscCharges_args')
29719 
    if self.transactionId is not None:
29720 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29721 
      oprot.writeI64(self.transactionId)
29722 
      oprot.writeFieldEnd()
29723 
    oprot.writeFieldStop()
29724 
    oprot.writeStructEnd()
29725 
 
29726 
  def validate(self):
29727 
    return
29728 
 
29729 
 
29730 
  def __repr__(self):
29731 
    L = ['%s=%r' % (key, value)
29732 
      for key, value in self.__dict__.iteritems()]
29733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29734 
 
29735 
  def __eq__(self, other):
29736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29737 
 
29738 
  def __ne__(self, other):
29739 
    return not (self == other)
29740 
 
29741 
class getMiscCharges_result:
29742 
  """
29743 
  Attributes:
29744 
   - success
29745 
  """
29746 
 
29747 
  thrift_spec = (
6412 rajveer 29748 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29749 
  )
29750 
 
29751 
  def __init__(self, success=None,):
29752 
    self.success = success
29753 
 
29754 
  def read(self, iprot):
29755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29757 
      return
29758 
    iprot.readStructBegin()
29759 
    while True:
29760 
      (fname, ftype, fid) = iprot.readFieldBegin()
29761 
      if ftype == TType.STOP:
29762 
        break
29763 
      if fid == 0:
29764 
        if ftype == TType.MAP:
29765 
          self.success = {}
29766 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29767 
          for _i718 in xrange(_size714):
29768 
            _key719 = iprot.readI64();
6412 rajveer 29769 
            _val720 = iprot.readDouble();
6389 rajveer 29770 
            self.success[_key719] = _val720
29771 
          iprot.readMapEnd()
29772 
        else:
29773 
          iprot.skip(ftype)
29774 
      else:
29775 
        iprot.skip(ftype)
29776 
      iprot.readFieldEnd()
29777 
    iprot.readStructEnd()
29778 
 
29779 
  def write(self, oprot):
29780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29782 
      return
29783 
    oprot.writeStructBegin('getMiscCharges_result')
29784 
    if self.success is not None:
29785 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29786 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29787 
      for kiter721,viter722 in self.success.items():
29788 
        oprot.writeI64(kiter721)
6412 rajveer 29789 
        oprot.writeDouble(viter722)
6389 rajveer 29790 
      oprot.writeMapEnd()
29791 
      oprot.writeFieldEnd()
29792 
    oprot.writeFieldStop()
29793 
    oprot.writeStructEnd()
29794 
 
29795 
  def validate(self):
29796 
    return
29797 
 
29798 
 
29799 
  def __repr__(self):
29800 
    L = ['%s=%r' % (key, value)
29801 
      for key, value in self.__dict__.iteritems()]
29802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29803 
 
29804 
  def __eq__(self, other):
29805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29806 
 
29807 
  def __ne__(self, other):
29808 
    return not (self == other)
6507 anupam.sin 29809 
 
29810 
class refundRechargeOrder_args:
29811 
  """
29812 
  Attributes:
29813 
   - rechargeOrderId
29814 
  """
29815 
 
29816 
  thrift_spec = (
29817 
    None, # 0
29818 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29819 
  )
29820 
 
29821 
  def __init__(self, rechargeOrderId=None,):
29822 
    self.rechargeOrderId = rechargeOrderId
29823 
 
29824 
  def read(self, iprot):
29825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29827 
      return
29828 
    iprot.readStructBegin()
29829 
    while True:
29830 
      (fname, ftype, fid) = iprot.readFieldBegin()
29831 
      if ftype == TType.STOP:
29832 
        break
29833 
      if fid == 1:
29834 
        if ftype == TType.I64:
29835 
          self.rechargeOrderId = iprot.readI64();
29836 
        else:
29837 
          iprot.skip(ftype)
29838 
      else:
29839 
        iprot.skip(ftype)
29840 
      iprot.readFieldEnd()
29841 
    iprot.readStructEnd()
29842 
 
29843 
  def write(self, oprot):
29844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29846 
      return
29847 
    oprot.writeStructBegin('refundRechargeOrder_args')
29848 
    if self.rechargeOrderId is not None:
29849 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29850 
      oprot.writeI64(self.rechargeOrderId)
29851 
      oprot.writeFieldEnd()
29852 
    oprot.writeFieldStop()
29853 
    oprot.writeStructEnd()
29854 
 
29855 
  def validate(self):
29856 
    return
29857 
 
29858 
 
29859 
  def __repr__(self):
29860 
    L = ['%s=%r' % (key, value)
29861 
      for key, value in self.__dict__.iteritems()]
29862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29863 
 
29864 
  def __eq__(self, other):
29865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29866 
 
29867 
  def __ne__(self, other):
29868 
    return not (self == other)
29869 
 
29870 
class refundRechargeOrder_result:
29871 
  """
29872 
  Attributes:
29873 
   - success
29874 
   - ex
29875 
  """
29876 
 
29877 
  thrift_spec = (
29878 
    (0, TType.BOOL, 'success', None, None, ), # 0
29879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29880 
  )
29881 
 
29882 
  def __init__(self, success=None, ex=None,):
29883 
    self.success = success
29884 
    self.ex = ex
29885 
 
29886 
  def read(self, iprot):
29887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29889 
      return
29890 
    iprot.readStructBegin()
29891 
    while True:
29892 
      (fname, ftype, fid) = iprot.readFieldBegin()
29893 
      if ftype == TType.STOP:
29894 
        break
29895 
      if fid == 0:
29896 
        if ftype == TType.BOOL:
29897 
          self.success = iprot.readBool();
29898 
        else:
29899 
          iprot.skip(ftype)
29900 
      elif fid == 1:
29901 
        if ftype == TType.STRUCT:
29902 
          self.ex = TransactionServiceException()
29903 
          self.ex.read(iprot)
29904 
        else:
29905 
          iprot.skip(ftype)
29906 
      else:
29907 
        iprot.skip(ftype)
29908 
      iprot.readFieldEnd()
29909 
    iprot.readStructEnd()
29910 
 
29911 
  def write(self, oprot):
29912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29914 
      return
29915 
    oprot.writeStructBegin('refundRechargeOrder_result')
29916 
    if self.success is not None:
29917 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29918 
      oprot.writeBool(self.success)
29919 
      oprot.writeFieldEnd()
29920 
    if self.ex is not None:
29921 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29922 
      self.ex.write(oprot)
29923 
      oprot.writeFieldEnd()
29924 
    oprot.writeFieldStop()
29925 
    oprot.writeStructEnd()
29926 
 
29927 
  def validate(self):
29928 
    return
29929 
 
29930 
 
29931 
  def __repr__(self):
29932 
    L = ['%s=%r' % (key, value)
29933 
      for key, value in self.__dict__.iteritems()]
29934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29935 
 
29936 
  def __eq__(self, other):
29937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29938 
 
29939 
  def __ne__(self, other):
29940 
    return not (self == other)
6821 amar.kumar 29941 
 
29942 
class getPhysicalOrders_args:
29943 
  """
29944 
  Attributes:
29945 
   - fromDate
29946 
   - toDate
29947 
  """
29948 
 
29949 
  thrift_spec = (
29950 
    None, # 0
29951 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29952 
    (2, TType.I64, 'toDate', None, None, ), # 2
29953 
  )
29954 
 
29955 
  def __init__(self, fromDate=None, toDate=None,):
29956 
    self.fromDate = fromDate
29957 
    self.toDate = toDate
29958 
 
29959 
  def read(self, iprot):
29960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29962 
      return
29963 
    iprot.readStructBegin()
29964 
    while True:
29965 
      (fname, ftype, fid) = iprot.readFieldBegin()
29966 
      if ftype == TType.STOP:
29967 
        break
29968 
      if fid == 1:
29969 
        if ftype == TType.I64:
29970 
          self.fromDate = iprot.readI64();
29971 
        else:
29972 
          iprot.skip(ftype)
29973 
      elif fid == 2:
29974 
        if ftype == TType.I64:
29975 
          self.toDate = iprot.readI64();
29976 
        else:
29977 
          iprot.skip(ftype)
29978 
      else:
29979 
        iprot.skip(ftype)
29980 
      iprot.readFieldEnd()
29981 
    iprot.readStructEnd()
29982 
 
29983 
  def write(self, oprot):
29984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29986 
      return
29987 
    oprot.writeStructBegin('getPhysicalOrders_args')
29988 
    if self.fromDate is not None:
29989 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29990 
      oprot.writeI64(self.fromDate)
29991 
      oprot.writeFieldEnd()
29992 
    if self.toDate is not None:
29993 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29994 
      oprot.writeI64(self.toDate)
29995 
      oprot.writeFieldEnd()
29996 
    oprot.writeFieldStop()
29997 
    oprot.writeStructEnd()
29998 
 
29999 
  def validate(self):
30000 
    return
30001 
 
30002 
 
30003 
  def __repr__(self):
30004 
    L = ['%s=%r' % (key, value)
30005 
      for key, value in self.__dict__.iteritems()]
30006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30007 
 
30008 
  def __eq__(self, other):
30009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30010 
 
30011 
  def __ne__(self, other):
30012 
    return not (self == other)
30013 
 
30014 
class getPhysicalOrders_result:
30015 
  """
30016 
  Attributes:
30017 
   - success
30018 
  """
30019 
 
30020 
  thrift_spec = (
30021 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30022 
  )
30023 
 
30024 
  def __init__(self, success=None,):
30025 
    self.success = success
30026 
 
30027 
  def read(self, iprot):
30028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30030 
      return
30031 
    iprot.readStructBegin()
30032 
    while True:
30033 
      (fname, ftype, fid) = iprot.readFieldBegin()
30034 
      if ftype == TType.STOP:
30035 
        break
30036 
      if fid == 0:
30037 
        if ftype == TType.LIST:
30038 
          self.success = []
30039 
          (_etype726, _size723) = iprot.readListBegin()
30040 
          for _i727 in xrange(_size723):
30041 
            _elem728 = Order()
30042 
            _elem728.read(iprot)
30043 
            self.success.append(_elem728)
30044 
          iprot.readListEnd()
30045 
        else:
30046 
          iprot.skip(ftype)
30047 
      else:
30048 
        iprot.skip(ftype)
30049 
      iprot.readFieldEnd()
30050 
    iprot.readStructEnd()
30051 
 
30052 
  def write(self, oprot):
30053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30055 
      return
30056 
    oprot.writeStructBegin('getPhysicalOrders_result')
30057 
    if self.success is not None:
30058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30060 
      for iter729 in self.success:
30061 
        iter729.write(oprot)
30062 
      oprot.writeListEnd()
30063 
      oprot.writeFieldEnd()
30064 
    oprot.writeFieldStop()
30065 
    oprot.writeStructEnd()
30066 
 
30067 
  def validate(self):
30068 
    return
30069 
 
30070 
 
30071 
  def __repr__(self):
30072 
    L = ['%s=%r' % (key, value)
30073 
      for key, value in self.__dict__.iteritems()]
30074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30075 
 
30076 
  def __eq__(self, other):
30077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30078 
 
30079 
  def __ne__(self, other):
30080 
    return not (self == other)
6906 rajveer 30081 
 
30082 
class getDocument_args:
30083 
  """
30084 
  Attributes:
30085 
   - docType
30086 
   - docSource
30087 
  """
30088 
 
30089 
  thrift_spec = (
30090 
    None, # 0
30091 
    (1, TType.I64, 'docType', None, None, ), # 1
30092 
    (2, TType.I64, 'docSource', None, None, ), # 2
30093 
  )
30094 
 
30095 
  def __init__(self, docType=None, docSource=None,):
30096 
    self.docType = docType
30097 
    self.docSource = docSource
30098 
 
30099 
  def read(self, iprot):
30100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30102 
      return
30103 
    iprot.readStructBegin()
30104 
    while True:
30105 
      (fname, ftype, fid) = iprot.readFieldBegin()
30106 
      if ftype == TType.STOP:
30107 
        break
30108 
      if fid == 1:
30109 
        if ftype == TType.I64:
30110 
          self.docType = iprot.readI64();
30111 
        else:
30112 
          iprot.skip(ftype)
30113 
      elif fid == 2:
30114 
        if ftype == TType.I64:
30115 
          self.docSource = iprot.readI64();
30116 
        else:
30117 
          iprot.skip(ftype)
30118 
      else:
30119 
        iprot.skip(ftype)
30120 
      iprot.readFieldEnd()
30121 
    iprot.readStructEnd()
30122 
 
30123 
  def write(self, oprot):
30124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30126 
      return
30127 
    oprot.writeStructBegin('getDocument_args')
30128 
    if self.docType is not None:
30129 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30130 
      oprot.writeI64(self.docType)
30131 
      oprot.writeFieldEnd()
30132 
    if self.docSource is not None:
30133 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30134 
      oprot.writeI64(self.docSource)
30135 
      oprot.writeFieldEnd()
30136 
    oprot.writeFieldStop()
30137 
    oprot.writeStructEnd()
30138 
 
30139 
  def validate(self):
30140 
    return
30141 
 
30142 
 
30143 
  def __repr__(self):
30144 
    L = ['%s=%r' % (key, value)
30145 
      for key, value in self.__dict__.iteritems()]
30146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30147 
 
30148 
  def __eq__(self, other):
30149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30150 
 
30151 
  def __ne__(self, other):
30152 
    return not (self == other)
30153 
 
30154 
class getDocument_result:
30155 
  """
30156 
  Attributes:
30157 
   - success
30158 
  """
30159 
 
30160 
  thrift_spec = (
30161 
    (0, TType.STRING, 'success', None, None, ), # 0
30162 
  )
30163 
 
30164 
  def __init__(self, success=None,):
30165 
    self.success = success
30166 
 
30167 
  def read(self, iprot):
30168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30170 
      return
30171 
    iprot.readStructBegin()
30172 
    while True:
30173 
      (fname, ftype, fid) = iprot.readFieldBegin()
30174 
      if ftype == TType.STOP:
30175 
        break
30176 
      if fid == 0:
30177 
        if ftype == TType.STRING:
30178 
          self.success = iprot.readString();
30179 
        else:
30180 
          iprot.skip(ftype)
30181 
      else:
30182 
        iprot.skip(ftype)
30183 
      iprot.readFieldEnd()
30184 
    iprot.readStructEnd()
30185 
 
30186 
  def write(self, oprot):
30187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30189 
      return
30190 
    oprot.writeStructBegin('getDocument_result')
30191 
    if self.success is not None:
30192 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30193 
      oprot.writeString(self.success)
30194 
      oprot.writeFieldEnd()
30195 
    oprot.writeFieldStop()
30196 
    oprot.writeStructEnd()
30197 
 
30198 
  def validate(self):
30199 
    return
30200 
 
30201 
 
30202 
  def __repr__(self):
30203 
    L = ['%s=%r' % (key, value)
30204 
      for key, value in self.__dict__.iteritems()]
30205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30206 
 
30207 
  def __eq__(self, other):
30208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30209 
 
30210 
  def __ne__(self, other):
30211 
    return not (self == other)
6985 anupam.sin 30212 
 
30213 
class changeShippingAddress_args:
30214 
  """
30215 
  Attributes:
30216 
   - orderId
30217 
   - line1
30218 
   - line2
30219 
   - city
30220 
   - state
30221 
   - pin
30222 
  """
30223 
 
30224 
  thrift_spec = (
30225 
    None, # 0
30226 
    (1, TType.I64, 'orderId', None, None, ), # 1
30227 
    (2, TType.STRING, 'line1', None, None, ), # 2
30228 
    (3, TType.STRING, 'line2', None, None, ), # 3
30229 
    (4, TType.STRING, 'city', None, None, ), # 4
30230 
    (5, TType.STRING, 'state', None, None, ), # 5
30231 
    (6, TType.STRING, 'pin', None, None, ), # 6
30232 
  )
30233 
 
30234 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30235 
    self.orderId = orderId
30236 
    self.line1 = line1
30237 
    self.line2 = line2
30238 
    self.city = city
30239 
    self.state = state
30240 
    self.pin = pin
30241 
 
30242 
  def read(self, iprot):
30243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30245 
      return
30246 
    iprot.readStructBegin()
30247 
    while True:
30248 
      (fname, ftype, fid) = iprot.readFieldBegin()
30249 
      if ftype == TType.STOP:
30250 
        break
30251 
      if fid == 1:
30252 
        if ftype == TType.I64:
30253 
          self.orderId = iprot.readI64();
30254 
        else:
30255 
          iprot.skip(ftype)
30256 
      elif fid == 2:
30257 
        if ftype == TType.STRING:
30258 
          self.line1 = iprot.readString();
30259 
        else:
30260 
          iprot.skip(ftype)
30261 
      elif fid == 3:
30262 
        if ftype == TType.STRING:
30263 
          self.line2 = iprot.readString();
30264 
        else:
30265 
          iprot.skip(ftype)
30266 
      elif fid == 4:
30267 
        if ftype == TType.STRING:
30268 
          self.city = iprot.readString();
30269 
        else:
30270 
          iprot.skip(ftype)
30271 
      elif fid == 5:
30272 
        if ftype == TType.STRING:
30273 
          self.state = iprot.readString();
30274 
        else:
30275 
          iprot.skip(ftype)
30276 
      elif fid == 6:
30277 
        if ftype == TType.STRING:
30278 
          self.pin = iprot.readString();
30279 
        else:
30280 
          iprot.skip(ftype)
30281 
      else:
30282 
        iprot.skip(ftype)
30283 
      iprot.readFieldEnd()
30284 
    iprot.readStructEnd()
30285 
 
30286 
  def write(self, oprot):
30287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30289 
      return
30290 
    oprot.writeStructBegin('changeShippingAddress_args')
30291 
    if self.orderId is not None:
30292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30293 
      oprot.writeI64(self.orderId)
30294 
      oprot.writeFieldEnd()
30295 
    if self.line1 is not None:
30296 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30297 
      oprot.writeString(self.line1)
30298 
      oprot.writeFieldEnd()
30299 
    if self.line2 is not None:
30300 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30301 
      oprot.writeString(self.line2)
30302 
      oprot.writeFieldEnd()
30303 
    if self.city is not None:
30304 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30305 
      oprot.writeString(self.city)
30306 
      oprot.writeFieldEnd()
30307 
    if self.state is not None:
30308 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30309 
      oprot.writeString(self.state)
30310 
      oprot.writeFieldEnd()
30311 
    if self.pin is not None:
30312 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30313 
      oprot.writeString(self.pin)
30314 
      oprot.writeFieldEnd()
30315 
    oprot.writeFieldStop()
30316 
    oprot.writeStructEnd()
30317 
 
30318 
  def validate(self):
30319 
    return
30320 
 
30321 
 
30322 
  def __repr__(self):
30323 
    L = ['%s=%r' % (key, value)
30324 
      for key, value in self.__dict__.iteritems()]
30325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30326 
 
30327 
  def __eq__(self, other):
30328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30329 
 
30330 
  def __ne__(self, other):
30331 
    return not (self == other)
30332 
 
30333 
class changeShippingAddress_result:
30334 
  """
30335 
  Attributes:
30336 
   - success
30337 
  """
30338 
 
30339 
  thrift_spec = (
30340 
    (0, TType.BOOL, 'success', None, None, ), # 0
30341 
  )
30342 
 
30343 
  def __init__(self, success=None,):
30344 
    self.success = success
30345 
 
30346 
  def read(self, iprot):
30347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30349 
      return
30350 
    iprot.readStructBegin()
30351 
    while True:
30352 
      (fname, ftype, fid) = iprot.readFieldBegin()
30353 
      if ftype == TType.STOP:
30354 
        break
30355 
      if fid == 0:
30356 
        if ftype == TType.BOOL:
30357 
          self.success = iprot.readBool();
30358 
        else:
30359 
          iprot.skip(ftype)
30360 
      else:
30361 
        iprot.skip(ftype)
30362 
      iprot.readFieldEnd()
30363 
    iprot.readStructEnd()
30364 
 
30365 
  def write(self, oprot):
30366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30368 
      return
30369 
    oprot.writeStructBegin('changeShippingAddress_result')
30370 
    if self.success is not None:
30371 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30372 
      oprot.writeBool(self.success)
30373 
      oprot.writeFieldEnd()
30374 
    oprot.writeFieldStop()
30375 
    oprot.writeStructEnd()
30376 
 
30377 
  def validate(self):
30378 
    return
30379 
 
30380 
 
30381 
  def __repr__(self):
30382 
    L = ['%s=%r' % (key, value)
30383 
      for key, value in self.__dict__.iteritems()]
30384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30385 
 
30386 
  def __eq__(self, other):
30387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30388 
 
30389 
  def __ne__(self, other):
30390 
    return not (self == other)
6988 rajveer 30391 
 
30392 
class retrieveInvoice_args:
30393 
  """
30394 
  Attributes:
30395 
   - orderId
7075 rajveer 30396 
   - userId
6988 rajveer 30397 
  """
30398 
 
30399 
  thrift_spec = (
30400 
    None, # 0
30401 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30402 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30403 
  )
30404 
 
7075 rajveer 30405 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30406 
    self.orderId = orderId
7075 rajveer 30407 
    self.userId = userId
6988 rajveer 30408 
 
30409 
  def read(self, iprot):
30410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30412 
      return
30413 
    iprot.readStructBegin()
30414 
    while True:
30415 
      (fname, ftype, fid) = iprot.readFieldBegin()
30416 
      if ftype == TType.STOP:
30417 
        break
30418 
      if fid == 1:
30419 
        if ftype == TType.I64:
30420 
          self.orderId = iprot.readI64();
30421 
        else:
30422 
          iprot.skip(ftype)
7075 rajveer 30423 
      elif fid == 2:
30424 
        if ftype == TType.I64:
30425 
          self.userId = iprot.readI64();
30426 
        else:
30427 
          iprot.skip(ftype)
6988 rajveer 30428 
      else:
30429 
        iprot.skip(ftype)
30430 
      iprot.readFieldEnd()
30431 
    iprot.readStructEnd()
30432 
 
30433 
  def write(self, oprot):
30434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30436 
      return
30437 
    oprot.writeStructBegin('retrieveInvoice_args')
30438 
    if self.orderId is not None:
30439 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30440 
      oprot.writeI64(self.orderId)
30441 
      oprot.writeFieldEnd()
7075 rajveer 30442 
    if self.userId is not None:
30443 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30444 
      oprot.writeI64(self.userId)
30445 
      oprot.writeFieldEnd()
6988 rajveer 30446 
    oprot.writeFieldStop()
30447 
    oprot.writeStructEnd()
30448 
 
30449 
  def validate(self):
30450 
    return
30451 
 
30452 
 
30453 
  def __repr__(self):
30454 
    L = ['%s=%r' % (key, value)
30455 
      for key, value in self.__dict__.iteritems()]
30456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30457 
 
30458 
  def __eq__(self, other):
30459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30460 
 
30461 
  def __ne__(self, other):
30462 
    return not (self == other)
30463 
 
30464 
class retrieveInvoice_result:
30465 
  """
30466 
  Attributes:
30467 
   - success
30468 
  """
30469 
 
30470 
  thrift_spec = (
30471 
    (0, TType.STRING, 'success', None, None, ), # 0
30472 
  )
30473 
 
30474 
  def __init__(self, success=None,):
30475 
    self.success = success
30476 
 
30477 
  def read(self, iprot):
30478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30480 
      return
30481 
    iprot.readStructBegin()
30482 
    while True:
30483 
      (fname, ftype, fid) = iprot.readFieldBegin()
30484 
      if ftype == TType.STOP:
30485 
        break
30486 
      if fid == 0:
30487 
        if ftype == TType.STRING:
30488 
          self.success = iprot.readString();
30489 
        else:
30490 
          iprot.skip(ftype)
30491 
      else:
30492 
        iprot.skip(ftype)
30493 
      iprot.readFieldEnd()
30494 
    iprot.readStructEnd()
30495 
 
30496 
  def write(self, oprot):
30497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30499 
      return
30500 
    oprot.writeStructBegin('retrieveInvoice_result')
30501 
    if self.success is not None:
30502 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30503 
      oprot.writeString(self.success)
30504 
      oprot.writeFieldEnd()
30505 
    oprot.writeFieldStop()
30506 
    oprot.writeStructEnd()
30507 
 
30508 
  def validate(self):
30509 
    return
30510 
 
30511 
 
30512 
  def __repr__(self):
30513 
    L = ['%s=%r' % (key, value)
30514 
      for key, value in self.__dict__.iteritems()]
30515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30516 
 
30517 
  def __eq__(self, other):
30518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30519 
 
30520 
  def __ne__(self, other):
30521 
    return not (self == other)
7026 rajveer 30522 
 
30523 
class receiveUpdatesForRedExpress_args:
30524 
  """
30525 
  Attributes:
30526 
   - awbNumber
30527 
  """
30528 
 
30529 
  thrift_spec = (
30530 
    None, # 0
30531 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30532 
  )
30533 
 
30534 
  def __init__(self, awbNumber=None,):
30535 
    self.awbNumber = awbNumber
30536 
 
30537 
  def read(self, iprot):
30538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30540 
      return
30541 
    iprot.readStructBegin()
30542 
    while True:
30543 
      (fname, ftype, fid) = iprot.readFieldBegin()
30544 
      if ftype == TType.STOP:
30545 
        break
30546 
      if fid == 1:
30547 
        if ftype == TType.STRING:
30548 
          self.awbNumber = iprot.readString();
30549 
        else:
30550 
          iprot.skip(ftype)
30551 
      else:
30552 
        iprot.skip(ftype)
30553 
      iprot.readFieldEnd()
30554 
    iprot.readStructEnd()
30555 
 
30556 
  def write(self, oprot):
30557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30559 
      return
30560 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30561 
    if self.awbNumber is not None:
30562 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30563 
      oprot.writeString(self.awbNumber)
30564 
      oprot.writeFieldEnd()
30565 
    oprot.writeFieldStop()
30566 
    oprot.writeStructEnd()
30567 
 
30568 
  def validate(self):
30569 
    return
30570 
 
30571 
 
30572 
  def __repr__(self):
30573 
    L = ['%s=%r' % (key, value)
30574 
      for key, value in self.__dict__.iteritems()]
30575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30576 
 
30577 
  def __eq__(self, other):
30578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30579 
 
30580 
  def __ne__(self, other):
30581 
    return not (self == other)
30582 
 
30583 
class receiveUpdatesForRedExpress_result:
30584 
  """
30585 
  Attributes:
30586 
   - success
30587 
  """
30588 
 
30589 
  thrift_spec = (
30590 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30591 
  )
30592 
 
30593 
  def __init__(self, success=None,):
30594 
    self.success = success
30595 
 
30596 
  def read(self, iprot):
30597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30599 
      return
30600 
    iprot.readStructBegin()
30601 
    while True:
30602 
      (fname, ftype, fid) = iprot.readFieldBegin()
30603 
      if ftype == TType.STOP:
30604 
        break
30605 
      if fid == 0:
30606 
        if ftype == TType.LIST:
30607 
          self.success = []
30608 
          (_etype733, _size730) = iprot.readListBegin()
30609 
          for _i734 in xrange(_size730):
30610 
            _elem735 = iprot.readString();
30611 
            self.success.append(_elem735)
30612 
          iprot.readListEnd()
30613 
        else:
30614 
          iprot.skip(ftype)
30615 
      else:
30616 
        iprot.skip(ftype)
30617 
      iprot.readFieldEnd()
30618 
    iprot.readStructEnd()
30619 
 
30620 
  def write(self, oprot):
30621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30623 
      return
30624 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30625 
    if self.success is not None:
30626 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30627 
      oprot.writeListBegin(TType.STRING, len(self.success))
30628 
      for iter736 in self.success:
30629 
        oprot.writeString(iter736)
30630 
      oprot.writeListEnd()
30631 
      oprot.writeFieldEnd()
30632 
    oprot.writeFieldStop()
30633 
    oprot.writeStructEnd()
30634 
 
30635 
  def validate(self):
30636 
    return
30637 
 
30638 
 
30639 
  def __repr__(self):
30640 
    L = ['%s=%r' % (key, value)
30641 
      for key, value in self.__dict__.iteritems()]
30642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30643 
 
30644 
  def __eq__(self, other):
30645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30646 
 
30647 
  def __ne__(self, other):
30648 
    return not (self == other)
7073 anupam.sin 30649 
 
30650 
class createRechargeTransaction_args:
30651 
  """
30652 
  Attributes:
30653 
   - thriftRechargeTransaction
30654 
  """
30655 
 
30656 
  thrift_spec = (
30657 
    None, # 0
30658 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30659 
  )
30660 
 
30661 
  def __init__(self, thriftRechargeTransaction=None,):
30662 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30663 
 
30664 
  def read(self, iprot):
30665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30667 
      return
30668 
    iprot.readStructBegin()
30669 
    while True:
30670 
      (fname, ftype, fid) = iprot.readFieldBegin()
30671 
      if ftype == TType.STOP:
30672 
        break
30673 
      if fid == 1:
30674 
        if ftype == TType.STRUCT:
30675 
          self.thriftRechargeTransaction = RechargeTransaction()
30676 
          self.thriftRechargeTransaction.read(iprot)
30677 
        else:
30678 
          iprot.skip(ftype)
30679 
      else:
30680 
        iprot.skip(ftype)
30681 
      iprot.readFieldEnd()
30682 
    iprot.readStructEnd()
30683 
 
30684 
  def write(self, oprot):
30685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30687 
      return
30688 
    oprot.writeStructBegin('createRechargeTransaction_args')
30689 
    if self.thriftRechargeTransaction is not None:
30690 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30691 
      self.thriftRechargeTransaction.write(oprot)
30692 
      oprot.writeFieldEnd()
30693 
    oprot.writeFieldStop()
30694 
    oprot.writeStructEnd()
30695 
 
30696 
  def validate(self):
30697 
    return
30698 
 
30699 
 
30700 
  def __repr__(self):
30701 
    L = ['%s=%r' % (key, value)
30702 
      for key, value in self.__dict__.iteritems()]
30703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30704 
 
30705 
  def __eq__(self, other):
30706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30707 
 
30708 
  def __ne__(self, other):
30709 
    return not (self == other)
30710 
 
30711 
class createRechargeTransaction_result:
30712 
  """
30713 
  Attributes:
30714 
   - success
30715 
  """
30716 
 
30717 
  thrift_spec = (
30718 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30719 
  )
30720 
 
30721 
  def __init__(self, success=None,):
30722 
    self.success = success
30723 
 
30724 
  def read(self, iprot):
30725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30727 
      return
30728 
    iprot.readStructBegin()
30729 
    while True:
30730 
      (fname, ftype, fid) = iprot.readFieldBegin()
30731 
      if ftype == TType.STOP:
30732 
        break
30733 
      if fid == 0:
30734 
        if ftype == TType.STRUCT:
30735 
          self.success = RechargeTransaction()
30736 
          self.success.read(iprot)
30737 
        else:
30738 
          iprot.skip(ftype)
30739 
      else:
30740 
        iprot.skip(ftype)
30741 
      iprot.readFieldEnd()
30742 
    iprot.readStructEnd()
30743 
 
30744 
  def write(self, oprot):
30745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30747 
      return
30748 
    oprot.writeStructBegin('createRechargeTransaction_result')
30749 
    if self.success is not None:
30750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30751 
      self.success.write(oprot)
30752 
      oprot.writeFieldEnd()
30753 
    oprot.writeFieldStop()
30754 
    oprot.writeStructEnd()
30755 
 
30756 
  def validate(self):
30757 
    return
30758 
 
30759 
 
30760 
  def __repr__(self):
30761 
    L = ['%s=%r' % (key, value)
30762 
      for key, value in self.__dict__.iteritems()]
30763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30764 
 
30765 
  def __eq__(self, other):
30766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30767 
 
30768 
  def __ne__(self, other):
30769 
    return not (self == other)
7080 anupam.sin 30770 
 
7085 rajveer 30771 
class getRechargeTransactions_args:
30772 
  """
30773 
  Attributes:
30774 
   - storeId
30775 
  """
30776 
 
30777 
  thrift_spec = (
30778 
    None, # 0
30779 
    (1, TType.I64, 'storeId', None, None, ), # 1
30780 
  )
30781 
 
30782 
  def __init__(self, storeId=None,):
30783 
    self.storeId = storeId
30784 
 
30785 
  def read(self, iprot):
30786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30788 
      return
30789 
    iprot.readStructBegin()
30790 
    while True:
30791 
      (fname, ftype, fid) = iprot.readFieldBegin()
30792 
      if ftype == TType.STOP:
30793 
        break
30794 
      if fid == 1:
30795 
        if ftype == TType.I64:
30796 
          self.storeId = iprot.readI64();
30797 
        else:
30798 
          iprot.skip(ftype)
30799 
      else:
30800 
        iprot.skip(ftype)
30801 
      iprot.readFieldEnd()
30802 
    iprot.readStructEnd()
30803 
 
30804 
  def write(self, oprot):
30805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30807 
      return
30808 
    oprot.writeStructBegin('getRechargeTransactions_args')
30809 
    if self.storeId is not None:
30810 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
30811 
      oprot.writeI64(self.storeId)
30812 
      oprot.writeFieldEnd()
30813 
    oprot.writeFieldStop()
30814 
    oprot.writeStructEnd()
30815 
 
30816 
  def validate(self):
30817 
    return
30818 
 
30819 
 
30820 
  def __repr__(self):
30821 
    L = ['%s=%r' % (key, value)
30822 
      for key, value in self.__dict__.iteritems()]
30823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30824 
 
30825 
  def __eq__(self, other):
30826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30827 
 
30828 
  def __ne__(self, other):
30829 
    return not (self == other)
30830 
 
30831 
class getRechargeTransactions_result:
30832 
  """
30833 
  Attributes:
30834 
   - success
30835 
  """
30836 
 
30837 
  thrift_spec = (
30838 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
30839 
  )
30840 
 
30841 
  def __init__(self, success=None,):
30842 
    self.success = success
30843 
 
30844 
  def read(self, iprot):
30845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30847 
      return
30848 
    iprot.readStructBegin()
30849 
    while True:
30850 
      (fname, ftype, fid) = iprot.readFieldBegin()
30851 
      if ftype == TType.STOP:
30852 
        break
30853 
      if fid == 0:
30854 
        if ftype == TType.LIST:
30855 
          self.success = []
30856 
          (_etype740, _size737) = iprot.readListBegin()
30857 
          for _i741 in xrange(_size737):
30858 
            _elem742 = RechargeTransaction()
30859 
            _elem742.read(iprot)
30860 
            self.success.append(_elem742)
30861 
          iprot.readListEnd()
30862 
        else:
30863 
          iprot.skip(ftype)
30864 
      else:
30865 
        iprot.skip(ftype)
30866 
      iprot.readFieldEnd()
30867 
    iprot.readStructEnd()
30868 
 
30869 
  def write(self, oprot):
30870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30872 
      return
30873 
    oprot.writeStructBegin('getRechargeTransactions_result')
30874 
    if self.success is not None:
30875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30877 
      for iter743 in self.success:
30878 
        iter743.write(oprot)
30879 
      oprot.writeListEnd()
30880 
      oprot.writeFieldEnd()
30881 
    oprot.writeFieldStop()
30882 
    oprot.writeStructEnd()
30883 
 
30884 
  def validate(self):
30885 
    return
30886 
 
30887 
 
30888 
  def __repr__(self):
30889 
    L = ['%s=%r' % (key, value)
30890 
      for key, value in self.__dict__.iteritems()]
30891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30892 
 
30893 
  def __eq__(self, other):
30894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30895 
 
30896 
  def __ne__(self, other):
30897 
    return not (self == other)
30898 
 
7080 anupam.sin 30899 
class getRechargeTransaction_args:
30900 
  """
30901 
  Attributes:
30902 
   - rechargeId
30903 
  """
30904 
 
30905 
  thrift_spec = (
30906 
    None, # 0
30907 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
30908 
  )
30909 
 
30910 
  def __init__(self, rechargeId=None,):
30911 
    self.rechargeId = rechargeId
30912 
 
30913 
  def read(self, iprot):
30914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30916 
      return
30917 
    iprot.readStructBegin()
30918 
    while True:
30919 
      (fname, ftype, fid) = iprot.readFieldBegin()
30920 
      if ftype == TType.STOP:
30921 
        break
30922 
      if fid == 1:
30923 
        if ftype == TType.I64:
30924 
          self.rechargeId = iprot.readI64();
30925 
        else:
30926 
          iprot.skip(ftype)
30927 
      else:
30928 
        iprot.skip(ftype)
30929 
      iprot.readFieldEnd()
30930 
    iprot.readStructEnd()
30931 
 
30932 
  def write(self, oprot):
30933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30935 
      return
30936 
    oprot.writeStructBegin('getRechargeTransaction_args')
30937 
    if self.rechargeId is not None:
30938 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
30939 
      oprot.writeI64(self.rechargeId)
30940 
      oprot.writeFieldEnd()
30941 
    oprot.writeFieldStop()
30942 
    oprot.writeStructEnd()
30943 
 
30944 
  def validate(self):
30945 
    return
30946 
 
30947 
 
30948 
  def __repr__(self):
30949 
    L = ['%s=%r' % (key, value)
30950 
      for key, value in self.__dict__.iteritems()]
30951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30952 
 
30953 
  def __eq__(self, other):
30954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30955 
 
30956 
  def __ne__(self, other):
30957 
    return not (self == other)
30958 
 
30959 
class getRechargeTransaction_result:
30960 
  """
30961 
  Attributes:
30962 
   - success
30963 
  """
30964 
 
30965 
  thrift_spec = (
30966 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30967 
  )
30968 
 
30969 
  def __init__(self, success=None,):
30970 
    self.success = success
30971 
 
30972 
  def read(self, iprot):
30973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30975 
      return
30976 
    iprot.readStructBegin()
30977 
    while True:
30978 
      (fname, ftype, fid) = iprot.readFieldBegin()
30979 
      if ftype == TType.STOP:
30980 
        break
30981 
      if fid == 0:
30982 
        if ftype == TType.STRUCT:
30983 
          self.success = RechargeTransaction()
30984 
          self.success.read(iprot)
30985 
        else:
30986 
          iprot.skip(ftype)
30987 
      else:
30988 
        iprot.skip(ftype)
30989 
      iprot.readFieldEnd()
30990 
    iprot.readStructEnd()
30991 
 
30992 
  def write(self, oprot):
30993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30995 
      return
30996 
    oprot.writeStructBegin('getRechargeTransaction_result')
30997 
    if self.success is not None:
30998 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30999 
      self.success.write(oprot)
31000 
      oprot.writeFieldEnd()
31001 
    oprot.writeFieldStop()
31002 
    oprot.writeStructEnd()
31003 
 
31004 
  def validate(self):
31005 
    return
31006 
 
31007 
 
31008 
  def __repr__(self):
31009 
    L = ['%s=%r' % (key, value)
31010 
      for key, value in self.__dict__.iteritems()]
31011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31012 
 
31013 
  def __eq__(self, other):
31014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31015 
 
31016 
  def __ne__(self, other):
31017 
    return not (self == other)
31018 
 
31019 
class getFRCs_args:
31020 
  """
31021 
  Attributes:
31022 
   - circleId
31023 
   - operatorId
31024 
  """
31025 
 
31026 
  thrift_spec = (
31027 
    None, # 0
31028 
    (1, TType.I64, 'circleId', None, None, ), # 1
31029 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31030 
  )
31031 
 
31032 
  def __init__(self, circleId=None, operatorId=None,):
31033 
    self.circleId = circleId
31034 
    self.operatorId = operatorId
31035 
 
31036 
  def read(self, iprot):
31037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31039 
      return
31040 
    iprot.readStructBegin()
31041 
    while True:
31042 
      (fname, ftype, fid) = iprot.readFieldBegin()
31043 
      if ftype == TType.STOP:
31044 
        break
31045 
      if fid == 1:
31046 
        if ftype == TType.I64:
31047 
          self.circleId = iprot.readI64();
31048 
        else:
31049 
          iprot.skip(ftype)
31050 
      elif fid == 2:
31051 
        if ftype == TType.I64:
31052 
          self.operatorId = iprot.readI64();
31053 
        else:
31054 
          iprot.skip(ftype)
31055 
      else:
31056 
        iprot.skip(ftype)
31057 
      iprot.readFieldEnd()
31058 
    iprot.readStructEnd()
31059 
 
31060 
  def write(self, oprot):
31061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31063 
      return
31064 
    oprot.writeStructBegin('getFRCs_args')
31065 
    if self.circleId is not None:
31066 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31067 
      oprot.writeI64(self.circleId)
31068 
      oprot.writeFieldEnd()
31069 
    if self.operatorId is not None:
31070 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31071 
      oprot.writeI64(self.operatorId)
31072 
      oprot.writeFieldEnd()
31073 
    oprot.writeFieldStop()
31074 
    oprot.writeStructEnd()
31075 
 
31076 
  def validate(self):
31077 
    return
31078 
 
31079 
 
31080 
  def __repr__(self):
31081 
    L = ['%s=%r' % (key, value)
31082 
      for key, value in self.__dict__.iteritems()]
31083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31084 
 
31085 
  def __eq__(self, other):
31086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31087 
 
31088 
  def __ne__(self, other):
31089 
    return not (self == other)
31090 
 
31091 
class getFRCs_result:
31092 
  """
31093 
  Attributes:
31094 
   - success
31095 
  """
31096 
 
31097 
  thrift_spec = (
31098 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31099 
  )
31100 
 
31101 
  def __init__(self, success=None,):
31102 
    self.success = success
31103 
 
31104 
  def read(self, iprot):
31105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31107 
      return
31108 
    iprot.readStructBegin()
31109 
    while True:
31110 
      (fname, ftype, fid) = iprot.readFieldBegin()
31111 
      if ftype == TType.STOP:
31112 
        break
31113 
      if fid == 0:
31114 
        if ftype == TType.LIST:
31115 
          self.success = []
7085 rajveer 31116 
          (_etype747, _size744) = iprot.readListBegin()
31117 
          for _i748 in xrange(_size744):
31118 
            _elem749 = FRC()
31119 
            _elem749.read(iprot)
31120 
            self.success.append(_elem749)
7080 anupam.sin 31121 
          iprot.readListEnd()
31122 
        else:
31123 
          iprot.skip(ftype)
31124 
      else:
31125 
        iprot.skip(ftype)
31126 
      iprot.readFieldEnd()
31127 
    iprot.readStructEnd()
31128 
 
31129 
  def write(self, oprot):
31130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31132 
      return
31133 
    oprot.writeStructBegin('getFRCs_result')
31134 
    if self.success is not None:
31135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7085 rajveer 31137 
      for iter750 in self.success:
31138 
        iter750.write(oprot)
7080 anupam.sin 31139 
      oprot.writeListEnd()
31140 
      oprot.writeFieldEnd()
31141 
    oprot.writeFieldStop()
31142 
    oprot.writeStructEnd()
31143 
 
31144 
  def validate(self):
31145 
    return
31146 
 
31147 
 
31148 
  def __repr__(self):
31149 
    L = ['%s=%r' % (key, value)
31150 
      for key, value in self.__dict__.iteritems()]
31151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31152 
 
31153 
  def __eq__(self, other):
31154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31155 
 
31156 
  def __ne__(self, other):
31157 
    return not (self == other)