Subversion Repositories SmartDukaan

Rev

Rev 7073 | Rev 7080 | 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 
 
7073 anupam.sin 1497 
 
3376 rajveer 1498 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1499 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1500 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1501 
 
1502 
  def createTransaction(self, transaction):
1503 
    """
1504 
    Parameters:
1505 
     - transaction
1506 
    """
1507 
    self.send_createTransaction(transaction)
132 ashish 1508 
    return self.recv_createTransaction()
94 ashish 1509 
 
1510 
  def send_createTransaction(self, transaction):
1511 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1512 
    args = createTransaction_args()
1513 
    args.transaction = transaction
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_createTransaction(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = createTransaction_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
3431 rajveer 1528 
    if result.success is not None:
132 ashish 1529 
      return result.success
3431 rajveer 1530 
    if result.ex is not None:
94 ashish 1531 
      raise result.ex
132 ashish 1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1533 
 
1534 
  def getTransaction(self, id):
1535 
    """
1536 
    Parameters:
1537 
     - id
1538 
    """
1539 
    self.send_getTransaction(id)
1540 
    return self.recv_getTransaction()
1541 
 
1542 
  def send_getTransaction(self, id):
1543 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1544 
    args = getTransaction_args()
1545 
    args.id = id
1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_getTransaction(self, ):
1551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1552 
    if mtype == TMessageType.EXCEPTION:
1553 
      x = TApplicationException()
1554 
      x.read(self._iprot)
1555 
      self._iprot.readMessageEnd()
1556 
      raise x
1557 
    result = getTransaction_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
3431 rajveer 1560 
    if result.success is not None:
94 ashish 1561 
      return result.success
3431 rajveer 1562 
    if result.ex is not None:
94 ashish 1563 
      raise result.ex
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1565 
 
1566 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1567 
    """
1568 
    Parameters:
1569 
     - customerId
1570 
     - from_date
1571 
     - to_date
1572 
     - status
1573 
    """
1574 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1575 
    return self.recv_getTransactionsForCustomer()
1576 
 
1577 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1578 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1579 
    args = getTransactionsForCustomer_args()
1580 
    args.customerId = customerId
1581 
    args.from_date = from_date
1582 
    args.to_date = to_date
1583 
    args.status = status
1584 
    args.write(self._oprot)
1585 
    self._oprot.writeMessageEnd()
1586 
    self._oprot.trans.flush()
1587 
 
1588 
  def recv_getTransactionsForCustomer(self, ):
1589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1590 
    if mtype == TMessageType.EXCEPTION:
1591 
      x = TApplicationException()
1592 
      x.read(self._iprot)
1593 
      self._iprot.readMessageEnd()
1594 
      raise x
1595 
    result = getTransactionsForCustomer_result()
1596 
    result.read(self._iprot)
1597 
    self._iprot.readMessageEnd()
3431 rajveer 1598 
    if result.success is not None:
94 ashish 1599 
      return result.success
3431 rajveer 1600 
    if result.ex is not None:
94 ashish 1601 
      raise result.ex
1602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1603 
 
132 ashish 1604 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1605 
    """
1606 
    Parameters:
1607 
     - shoppingCartId
1608 
    """
1609 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1610 
    return self.recv_getTransactionsForShoppingCartId()
1611 
 
1612 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1613 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1614 
    args = getTransactionsForShoppingCartId_args()
1615 
    args.shoppingCartId = shoppingCartId
1616 
    args.write(self._oprot)
1617 
    self._oprot.writeMessageEnd()
1618 
    self._oprot.trans.flush()
1619 
 
1620 
  def recv_getTransactionsForShoppingCartId(self, ):
1621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1622 
    if mtype == TMessageType.EXCEPTION:
1623 
      x = TApplicationException()
1624 
      x.read(self._iprot)
1625 
      self._iprot.readMessageEnd()
1626 
      raise x
1627 
    result = getTransactionsForShoppingCartId_result()
1628 
    result.read(self._iprot)
1629 
    self._iprot.readMessageEnd()
3431 rajveer 1630 
    if result.success is not None:
132 ashish 1631 
      return result.success
3431 rajveer 1632 
    if result.ex is not None:
132 ashish 1633 
      raise result.ex
1634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1635 
 
94 ashish 1636 
  def getTransactionStatus(self, transactionId):
1637 
    """
1638 
    Parameters:
1639 
     - transactionId
1640 
    """
1641 
    self.send_getTransactionStatus(transactionId)
1642 
    return self.recv_getTransactionStatus()
1643 
 
1644 
  def send_getTransactionStatus(self, transactionId):
1645 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1646 
    args = getTransactionStatus_args()
1647 
    args.transactionId = transactionId
1648 
    args.write(self._oprot)
1649 
    self._oprot.writeMessageEnd()
1650 
    self._oprot.trans.flush()
1651 
 
1652 
  def recv_getTransactionStatus(self, ):
1653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1654 
    if mtype == TMessageType.EXCEPTION:
1655 
      x = TApplicationException()
1656 
      x.read(self._iprot)
1657 
      self._iprot.readMessageEnd()
1658 
      raise x
1659 
    result = getTransactionStatus_result()
1660 
    result.read(self._iprot)
1661 
    self._iprot.readMessageEnd()
3431 rajveer 1662 
    if result.success is not None:
94 ashish 1663 
      return result.success
3431 rajveer 1664 
    if result.ex is not None:
94 ashish 1665 
      raise result.ex
1666 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1667 
 
5527 anupam.sin 1668 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1669 
    """
1670 
    Parameters:
1671 
     - transactionId
1672 
     - status
1673 
     - description
5527 anupam.sin 1674 
     - pickUp
1675 
     - orderType
94 ashish 1676 
    """
5527 anupam.sin 1677 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1678 
    return self.recv_changeTransactionStatus()
1679 
 
5527 anupam.sin 1680 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1681 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1682 
    args = changeTransactionStatus_args()
1683 
    args.transactionId = transactionId
1684 
    args.status = status
1685 
    args.description = description
5527 anupam.sin 1686 
    args.pickUp = pickUp
1687 
    args.orderType = orderType
94 ashish 1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
1692 
  def recv_changeTransactionStatus(self, ):
1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
1699 
    result = changeTransactionStatus_result()
1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
3431 rajveer 1702 
    if result.success is not None:
94 ashish 1703 
      return result.success
3431 rajveer 1704 
    if result.ex is not None:
94 ashish 1705 
      raise result.ex
1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1707 
 
1398 varun.gupt 1708 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1709 
    """
1710 
    Parameters:
1711 
     - transactionId
1712 
    """
1398 varun.gupt 1713 
    self.send_enqueueTransactionInfoEmail(transactionId)
1714 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1715 
 
1398 varun.gupt 1716 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1717 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1718 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1719 
    args.transactionId = transactionId
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1398 varun.gupt 1724 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1398 varun.gupt 1731 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
3431 rajveer 1734 
    if result.success is not None:
1382 varun.gupt 1735 
      return result.success
3431 rajveer 1736 
    if result.ex is not None:
1382 varun.gupt 1737 
      raise result.ex
1398 varun.gupt 1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1739 
 
4801 anupam.sin 1740 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1741 
    """
1742 
    Parameters:
4801 anupam.sin 1743 
     - statuses
483 rajveer 1744 
     - from_date
1745 
     - to_date
1746 
     - warehouse_id
94 ashish 1747 
    """
4801 anupam.sin 1748 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1749 
    return self.recv_getAllOrders()
94 ashish 1750 
 
4801 anupam.sin 1751 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1752 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1753 
    args = getAllOrders_args()
4801 anupam.sin 1754 
    args.statuses = statuses
483 rajveer 1755 
    args.from_date = from_date
1756 
    args.to_date = to_date
1757 
    args.warehouse_id = warehouse_id
94 ashish 1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
483 rajveer 1762 
  def recv_getAllOrders(self, ):
94 ashish 1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
483 rajveer 1769 
    result = getAllOrders_result()
94 ashish 1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
3431 rajveer 1772 
    if result.success is not None:
94 ashish 1773 
      return result.success
3431 rajveer 1774 
    if result.ex is not None:
94 ashish 1775 
      raise result.ex
483 rajveer 1776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1777 
 
4133 chandransh 1778 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1779 
    """
1780 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1781 
    Pass the status as null and the limit as 0 to ignore them.
1782 
 
1783 
    Parameters:
1784 
     - statuses
1785 
     - offset
1786 
     - limit
1787 
     - warehouse_id
1788 
    """
1789 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1790 
    return self.recv_getOrdersInBatch()
1791 
 
1792 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1793 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1794 
    args = getOrdersInBatch_args()
1795 
    args.statuses = statuses
1796 
    args.offset = offset
1797 
    args.limit = limit
1798 
    args.warehouse_id = warehouse_id
1799 
    args.write(self._oprot)
1800 
    self._oprot.writeMessageEnd()
1801 
    self._oprot.trans.flush()
1802 
 
1803 
  def recv_getOrdersInBatch(self, ):
1804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1805 
    if mtype == TMessageType.EXCEPTION:
1806 
      x = TApplicationException()
1807 
      x.read(self._iprot)
1808 
      self._iprot.readMessageEnd()
1809 
      raise x
1810 
    result = getOrdersInBatch_result()
1811 
    result.read(self._iprot)
1812 
    self._iprot.readMessageEnd()
1813 
    if result.success is not None:
1814 
      return result.success
1815 
    if result.ex is not None:
1816 
      raise result.ex
1817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1818 
 
1819 
  def getOrderCount(self, statuses, warehouseId):
1820 
    """
1821 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1822 
 
1823 
    Parameters:
1824 
     - statuses
1825 
     - warehouseId
1826 
    """
1827 
    self.send_getOrderCount(statuses, warehouseId)
1828 
    return self.recv_getOrderCount()
1829 
 
1830 
  def send_getOrderCount(self, statuses, warehouseId):
1831 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1832 
    args = getOrderCount_args()
1833 
    args.statuses = statuses
1834 
    args.warehouseId = warehouseId
1835 
    args.write(self._oprot)
1836 
    self._oprot.writeMessageEnd()
1837 
    self._oprot.trans.flush()
1838 
 
1839 
  def recv_getOrderCount(self, ):
1840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1841 
    if mtype == TMessageType.EXCEPTION:
1842 
      x = TApplicationException()
1843 
      x.read(self._iprot)
1844 
      self._iprot.readMessageEnd()
1845 
      raise x
1846 
    result = getOrderCount_result()
1847 
    result.read(self._iprot)
1848 
    self._iprot.readMessageEnd()
1849 
    if result.success is not None:
1850 
      return result.success
1851 
    if result.ex is not None:
1852 
      raise result.ex
1853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1854 
 
999 varun.gupt 1855 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1856 
    """
1132 chandransh 1857 
    Returns orders within a range of their billing dates
3431 rajveer 1858 
 
999 varun.gupt 1859 
    Parameters:
1860 
     - status
1861 
     - start_billing_date
1862 
     - end_billing_date
1863 
     - warehouse_id
1864 
    """
1865 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1866 
    return self.recv_getOrdersByBillingDate()
1867 
 
1868 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1869 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1870 
    args = getOrdersByBillingDate_args()
1871 
    args.status = status
1872 
    args.start_billing_date = start_billing_date
1873 
    args.end_billing_date = end_billing_date
1874 
    args.warehouse_id = warehouse_id
1875 
    args.write(self._oprot)
1876 
    self._oprot.writeMessageEnd()
1877 
    self._oprot.trans.flush()
1878 
 
1879 
  def recv_getOrdersByBillingDate(self, ):
1880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1881 
    if mtype == TMessageType.EXCEPTION:
1882 
      x = TApplicationException()
1883 
      x.read(self._iprot)
1884 
      self._iprot.readMessageEnd()
1885 
      raise x
1886 
    result = getOrdersByBillingDate_result()
1887 
    result.read(self._iprot)
1888 
    self._iprot.readMessageEnd()
3431 rajveer 1889 
    if result.success is not None:
999 varun.gupt 1890 
      return result.success
3431 rajveer 1891 
    if result.ex is not None:
999 varun.gupt 1892 
      raise result.ex
1893 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1894 
 
3451 chandransh 1895 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1896 
    """
1897 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1898 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1899 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1900 
 
3427 chandransh 1901 
    Parameters:
1902 
     - fromShippingDate
1903 
     - toShippingDate
1904 
     - providerId
1905 
     - warehouseId
3451 chandransh 1906 
     - cod
3427 chandransh 1907 
    """
3451 chandransh 1908 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1909 
    return self.recv_getOrdersByShippingDate()
1910 
 
3451 chandransh 1911 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1912 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1913 
    args = getOrdersByShippingDate_args()
1914 
    args.fromShippingDate = fromShippingDate
1915 
    args.toShippingDate = toShippingDate
1916 
    args.providerId = providerId
1917 
    args.warehouseId = warehouseId
3451 chandransh 1918 
    args.cod = cod
3427 chandransh 1919 
    args.write(self._oprot)
1920 
    self._oprot.writeMessageEnd()
1921 
    self._oprot.trans.flush()
1922 
 
1923 
  def recv_getOrdersByShippingDate(self, ):
1924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1925 
    if mtype == TMessageType.EXCEPTION:
1926 
      x = TApplicationException()
1927 
      x.read(self._iprot)
1928 
      self._iprot.readMessageEnd()
1929 
      raise x
1930 
    result = getOrdersByShippingDate_result()
1931 
    result.read(self._iprot)
1932 
    self._iprot.readMessageEnd()
3431 rajveer 1933 
    if result.success is not None:
3427 chandransh 1934 
      return result.success
3431 rajveer 1935 
    if result.ex is not None:
3427 chandransh 1936 
      raise result.ex
1937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1938 
 
1382 varun.gupt 1939 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1940 
    """
1941 
    Returns order ids for orders which can be returned
3431 rajveer 1942 
 
1382 varun.gupt 1943 
    Parameters:
1944 
     - customer_id
1945 
     - limit
1946 
    """
1947 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1948 
    return self.recv_getReturnableOrdersForCustomer()
1949 
 
1950 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1951 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1952 
    args = getReturnableOrdersForCustomer_args()
1953 
    args.customer_id = customer_id
1954 
    args.limit = limit
1955 
    args.write(self._oprot)
1956 
    self._oprot.writeMessageEnd()
1957 
    self._oprot.trans.flush()
1958 
 
1959 
  def recv_getReturnableOrdersForCustomer(self, ):
1960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1961 
    if mtype == TMessageType.EXCEPTION:
1962 
      x = TApplicationException()
1963 
      x.read(self._iprot)
1964 
      self._iprot.readMessageEnd()
1965 
      raise x
1966 
    result = getReturnableOrdersForCustomer_result()
1967 
    result.read(self._iprot)
1968 
    self._iprot.readMessageEnd()
3431 rajveer 1969 
    if result.success is not None:
1382 varun.gupt 1970 
      return result.success
3431 rajveer 1971 
    if result.ex is not None:
1382 varun.gupt 1972 
      raise result.ex
1973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1974 
 
1975 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1976 
    """
1977 
    Returns order ids for orders which can be cancelled
3431 rajveer 1978 
 
1382 varun.gupt 1979 
    Parameters:
1980 
     - customer_id
1981 
     - limit
1982 
    """
1983 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1984 
    return self.recv_getCancellableOrdersForCustomer()
1985 
 
1986 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1987 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1988 
    args = getCancellableOrdersForCustomer_args()
1989 
    args.customer_id = customer_id
1990 
    args.limit = limit
1991 
    args.write(self._oprot)
1992 
    self._oprot.writeMessageEnd()
1993 
    self._oprot.trans.flush()
1994 
 
1995 
  def recv_getCancellableOrdersForCustomer(self, ):
1996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1997 
    if mtype == TMessageType.EXCEPTION:
1998 
      x = TApplicationException()
1999 
      x.read(self._iprot)
2000 
      self._iprot.readMessageEnd()
2001 
      raise x
2002 
    result = getCancellableOrdersForCustomer_result()
2003 
    result.read(self._iprot)
2004 
    self._iprot.readMessageEnd()
3431 rajveer 2005 
    if result.success is not None:
1382 varun.gupt 2006 
      return result.success
3431 rajveer 2007 
    if result.ex is not None:
1382 varun.gupt 2008 
      raise result.ex
2009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2010 
 
483 rajveer 2011 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2012 
    """
2013 
    Parameters:
483 rajveer 2014 
     - orderId
2015 
     - status
2016 
     - description
94 ashish 2017 
    """
483 rajveer 2018 
    self.send_changeOrderStatus(orderId, status, description)
2019 
    return self.recv_changeOrderStatus()
94 ashish 2020 
 
483 rajveer 2021 
  def send_changeOrderStatus(self, orderId, status, description):
2022 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2023 
    args = changeOrderStatus_args()
2024 
    args.orderId = orderId
2025 
    args.status = status
2026 
    args.description = description
94 ashish 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
483 rajveer 2031 
  def recv_changeOrderStatus(self, ):
94 ashish 2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
483 rajveer 2038 
    result = changeOrderStatus_result()
94 ashish 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
94 ashish 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
94 ashish 2044 
      raise result.ex
483 rajveer 2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2046 
 
1528 ankur.sing 2047 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2048 
    """
1528 ankur.sing 2049 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2050 
    only user who owns the transaction can view its order details.
3431 rajveer 2051 
 
94 ashish 2052 
    Parameters:
2053 
     - transactionId
1528 ankur.sing 2054 
     - customerId
94 ashish 2055 
    """
1528 ankur.sing 2056 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2057 
    return self.recv_getOrdersForTransaction()
94 ashish 2058 
 
1528 ankur.sing 2059 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2060 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2061 
    args = getOrdersForTransaction_args()
94 ashish 2062 
    args.transactionId = transactionId
1528 ankur.sing 2063 
    args.customerId = customerId
94 ashish 2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
483 rajveer 2068 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
483 rajveer 2075 
    result = getOrdersForTransaction_result()
94 ashish 2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
3431 rajveer 2078 
    if result.success is not None:
94 ashish 2079 
      return result.success
3431 rajveer 2080 
    if result.ex is not None:
94 ashish 2081 
      raise result.ex
483 rajveer 2082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2083 
 
3014 chandransh 2084 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2085 
    """
3014 chandransh 2086 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2087 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2088 
 
94 ashish 2089 
    Parameters:
483 rajveer 2090 
     - customerId
2091 
     - from_date
2092 
     - to_date
3014 chandransh 2093 
     - statuses
94 ashish 2094 
    """
3014 chandransh 2095 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2096 
    return self.recv_getOrdersForCustomer()
94 ashish 2097 
 
3014 chandransh 2098 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2099 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2100 
    args = getOrdersForCustomer_args()
2101 
    args.customerId = customerId
2102 
    args.from_date = from_date
2103 
    args.to_date = to_date
3014 chandransh 2104 
    args.statuses = statuses
94 ashish 2105 
    args.write(self._oprot)
2106 
    self._oprot.writeMessageEnd()
2107 
    self._oprot.trans.flush()
2108 
 
483 rajveer 2109 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2111 
    if mtype == TMessageType.EXCEPTION:
2112 
      x = TApplicationException()
2113 
      x.read(self._iprot)
2114 
      self._iprot.readMessageEnd()
2115 
      raise x
483 rajveer 2116 
    result = getOrdersForCustomer_result()
94 ashish 2117 
    result.read(self._iprot)
2118 
    self._iprot.readMessageEnd()
3431 rajveer 2119 
    if result.success is not None:
94 ashish 2120 
      return result.success
3431 rajveer 2121 
    if result.ex is not None:
94 ashish 2122 
      raise result.ex
483 rajveer 2123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2124 
 
483 rajveer 2125 
  def createOrder(self, order):
94 ashish 2126 
    """
2127 
    Parameters:
483 rajveer 2128 
     - order
94 ashish 2129 
    """
483 rajveer 2130 
    self.send_createOrder(order)
2131 
    return self.recv_createOrder()
94 ashish 2132 
 
483 rajveer 2133 
  def send_createOrder(self, order):
2134 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2135 
    args = createOrder_args()
2136 
    args.order = order
94 ashish 2137 
    args.write(self._oprot)
2138 
    self._oprot.writeMessageEnd()
2139 
    self._oprot.trans.flush()
2140 
 
483 rajveer 2141 
  def recv_createOrder(self, ):
94 ashish 2142 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2143 
    if mtype == TMessageType.EXCEPTION:
2144 
      x = TApplicationException()
2145 
      x.read(self._iprot)
2146 
      self._iprot.readMessageEnd()
2147 
      raise x
483 rajveer 2148 
    result = createOrder_result()
94 ashish 2149 
    result.read(self._iprot)
2150 
    self._iprot.readMessageEnd()
3431 rajveer 2151 
    if result.success is not None:
94 ashish 2152 
      return result.success
3431 rajveer 2153 
    if result.ex is not None:
94 ashish 2154 
      raise result.ex
483 rajveer 2155 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2156 
 
483 rajveer 2157 
  def getOrder(self, id):
94 ashish 2158 
    """
2159 
    Parameters:
483 rajveer 2160 
     - id
94 ashish 2161 
    """
483 rajveer 2162 
    self.send_getOrder(id)
2163 
    return self.recv_getOrder()
94 ashish 2164 
 
483 rajveer 2165 
  def send_getOrder(self, id):
2166 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2167 
    args = getOrder_args()
2168 
    args.id = id
94 ashish 2169 
    args.write(self._oprot)
2170 
    self._oprot.writeMessageEnd()
2171 
    self._oprot.trans.flush()
2172 
 
483 rajveer 2173 
  def recv_getOrder(self, ):
94 ashish 2174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2175 
    if mtype == TMessageType.EXCEPTION:
2176 
      x = TApplicationException()
2177 
      x.read(self._iprot)
2178 
      self._iprot.readMessageEnd()
2179 
      raise x
483 rajveer 2180 
    result = getOrder_result()
94 ashish 2181 
    result.read(self._iprot)
2182 
    self._iprot.readMessageEnd()
3431 rajveer 2183 
    if result.success is not None:
94 ashish 2184 
      return result.success
3431 rajveer 2185 
    if result.ex is not None:
94 ashish 2186 
      raise result.ex
483 rajveer 2187 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2188 
 
483 rajveer 2189 
  def getLineItemsForOrder(self, orderId):
94 ashish 2190 
    """
2191 
    Parameters:
483 rajveer 2192 
     - orderId
94 ashish 2193 
    """
483 rajveer 2194 
    self.send_getLineItemsForOrder(orderId)
2195 
    return self.recv_getLineItemsForOrder()
94 ashish 2196 
 
483 rajveer 2197 
  def send_getLineItemsForOrder(self, orderId):
2198 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2199 
    args = getLineItemsForOrder_args()
2200 
    args.orderId = orderId
94 ashish 2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
483 rajveer 2205 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
483 rajveer 2212 
    result = getLineItemsForOrder_result()
94 ashish 2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
3431 rajveer 2215 
    if result.success is not None:
94 ashish 2216 
      return result.success
3431 rajveer 2217 
    if result.ex is not None:
94 ashish 2218 
      raise result.ex
483 rajveer 2219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2220 
 
4999 phani.kuma 2221 
  def getOrderList(self, order_ids):
2222 
    """
2223 
    Parameters:
2224 
     - order_ids
2225 
    """
2226 
    self.send_getOrderList(order_ids)
2227 
    return self.recv_getOrderList()
2228 
 
2229 
  def send_getOrderList(self, order_ids):
2230 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2231 
    args = getOrderList_args()
2232 
    args.order_ids = order_ids
2233 
    args.write(self._oprot)
2234 
    self._oprot.writeMessageEnd()
2235 
    self._oprot.trans.flush()
2236 
 
2237 
  def recv_getOrderList(self, ):
2238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2239 
    if mtype == TMessageType.EXCEPTION:
2240 
      x = TApplicationException()
2241 
      x.read(self._iprot)
2242 
      self._iprot.readMessageEnd()
2243 
      raise x
2244 
    result = getOrderList_result()
2245 
    result.read(self._iprot)
2246 
    self._iprot.readMessageEnd()
2247 
    if result.success is not None:
2248 
      return result.success
2249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2250 
 
5386 phani.kuma 2251 
  def getOrderListForVendor(self, order_ids, vendorId):
2252 
    """
2253 
    Parameters:
2254 
     - order_ids
2255 
     - vendorId
2256 
    """
2257 
    self.send_getOrderListForVendor(order_ids, vendorId)
2258 
    return self.recv_getOrderListForVendor()
2259 
 
2260 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2261 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2262 
    args = getOrderListForVendor_args()
2263 
    args.order_ids = order_ids
2264 
    args.vendorId = vendorId
2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
2269 
  def recv_getOrderListForVendor(self, ):
2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
2276 
    result = getOrderListForVendor_result()
2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
2279 
    if result.success is not None:
2280 
      return result.success
2281 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2282 
 
1528 ankur.sing 2283 
  def getOrderForCustomer(self, orderId, customerId):
2284 
    """
2285 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2286 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2287 
 
1528 ankur.sing 2288 
    Parameters:
2289 
     - orderId
2290 
     - customerId
2291 
    """
2292 
    self.send_getOrderForCustomer(orderId, customerId)
2293 
    return self.recv_getOrderForCustomer()
2294 
 
2295 
  def send_getOrderForCustomer(self, orderId, customerId):
2296 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2297 
    args = getOrderForCustomer_args()
2298 
    args.orderId = orderId
2299 
    args.customerId = customerId
2300 
    args.write(self._oprot)
2301 
    self._oprot.writeMessageEnd()
2302 
    self._oprot.trans.flush()
2303 
 
2304 
  def recv_getOrderForCustomer(self, ):
2305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2306 
    if mtype == TMessageType.EXCEPTION:
2307 
      x = TApplicationException()
2308 
      x.read(self._iprot)
2309 
      self._iprot.readMessageEnd()
2310 
      raise x
2311 
    result = getOrderForCustomer_result()
2312 
    result.read(self._iprot)
2313 
    self._iprot.readMessageEnd()
3431 rajveer 2314 
    if result.success is not None:
1528 ankur.sing 2315 
      return result.success
3431 rajveer 2316 
    if result.ex is not None:
1528 ankur.sing 2317 
      raise result.ex
2318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2319 
 
4444 rajveer 2320 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2321 
    """
2322 
    Parameters:
4394 rajveer 2323 
     - type
4444 rajveer 2324 
     - warehouseId
4394 rajveer 2325 
     - status
2326 
     - timestamp
3064 chandransh 2327 
    """
4444 rajveer 2328 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2329 
    return self.recv_getAlerts()
2330 
 
4444 rajveer 2331 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2332 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2333 
    args = getAlerts_args()
4394 rajveer 2334 
    args.type = type
4444 rajveer 2335 
    args.warehouseId = warehouseId
4394 rajveer 2336 
    args.status = status
2337 
    args.timestamp = timestamp
3064 chandransh 2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
2342 
  def recv_getAlerts(self, ):
2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
2349 
    result = getAlerts_result()
2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
3431 rajveer 2352 
    if result.success is not None:
3064 chandransh 2353 
      return result.success
2354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2355 
 
4444 rajveer 2356 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2357 
    """
2358 
    Parameters:
2359 
     - type
4444 rajveer 2360 
     - warehouseId
4394 rajveer 2361 
     - description
3064 chandransh 2362 
    """
4444 rajveer 2363 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2364 
    self.recv_addAlert()
3064 chandransh 2365 
 
4444 rajveer 2366 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2367 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2368 
    args = addAlert_args()
3064 chandransh 2369 
    args.type = type
4444 rajveer 2370 
    args.warehouseId = warehouseId
4394 rajveer 2371 
    args.description = description
3064 chandransh 2372 
    args.write(self._oprot)
2373 
    self._oprot.writeMessageEnd()
2374 
    self._oprot.trans.flush()
2375 
 
4394 rajveer 2376 
  def recv_addAlert(self, ):
3064 chandransh 2377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2378 
    if mtype == TMessageType.EXCEPTION:
2379 
      x = TApplicationException()
2380 
      x.read(self._iprot)
2381 
      self._iprot.readMessageEnd()
2382 
      raise x
4394 rajveer 2383 
    result = addAlert_result()
3064 chandransh 2384 
    result.read(self._iprot)
2385 
    self._iprot.readMessageEnd()
2386 
    return
2387 
 
4444 rajveer 2388 
  def markAlertsAsSeen(self, warehouseId):
2389 
    """
2390 
    Parameters:
2391 
     - warehouseId
2392 
    """
2393 
    self.send_markAlertsAsSeen(warehouseId)
2394 
    self.recv_markAlertsAsSeen()
2395 
 
2396 
  def send_markAlertsAsSeen(self, warehouseId):
2397 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2398 
    args = markAlertsAsSeen_args()
2399 
    args.warehouseId = warehouseId
2400 
    args.write(self._oprot)
2401 
    self._oprot.writeMessageEnd()
2402 
    self._oprot.trans.flush()
2403 
 
2404 
  def recv_markAlertsAsSeen(self, ):
2405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2406 
    if mtype == TMessageType.EXCEPTION:
2407 
      x = TApplicationException()
2408 
      x.read(self._iprot)
2409 
      self._iprot.readMessageEnd()
2410 
      raise x
2411 
    result = markAlertsAsSeen_result()
2412 
    result.read(self._iprot)
2413 
    self._iprot.readMessageEnd()
2414 
    return
2415 
 
3064 chandransh 2416 
  def getValidOrderCount(self, ):
2417 
    """
2418 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2419 
    """
2420 
    self.send_getValidOrderCount()
2421 
    return self.recv_getValidOrderCount()
2422 
 
2423 
  def send_getValidOrderCount(self, ):
2424 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2425 
    args = getValidOrderCount_args()
2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_getValidOrderCount(self, ):
2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
2437 
    result = getValidOrderCount_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
3431 rajveer 2440 
    if result.success is not None:
3064 chandransh 2441 
      return result.success
2442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2443 
 
2444 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2445 
    """
2446 
    Returns the number of distinct customers who have done successful transactions
2447 
    """
2448 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2449 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2450 
 
2451 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2452 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2453 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2454 
    args.write(self._oprot)
2455 
    self._oprot.writeMessageEnd()
2456 
    self._oprot.trans.flush()
2457 
 
2458 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2460 
    if mtype == TMessageType.EXCEPTION:
2461 
      x = TApplicationException()
2462 
      x.read(self._iprot)
2463 
      self._iprot.readMessageEnd()
2464 
      raise x
2465 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2466 
    result.read(self._iprot)
2467 
    self._iprot.readMessageEnd()
3431 rajveer 2468 
    if result.success is not None:
3064 chandransh 2469 
      return result.success
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2471 
 
2472 
  def getValidOrdersAmountRange(self, ):
2473 
    """
2474 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2475 
    List contains two values, first minimum amount and second maximum amount.
2476 
    """
2477 
    self.send_getValidOrdersAmountRange()
2478 
    return self.recv_getValidOrdersAmountRange()
2479 
 
2480 
  def send_getValidOrdersAmountRange(self, ):
2481 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2482 
    args = getValidOrdersAmountRange_args()
2483 
    args.write(self._oprot)
2484 
    self._oprot.writeMessageEnd()
2485 
    self._oprot.trans.flush()
2486 
 
2487 
  def recv_getValidOrdersAmountRange(self, ):
2488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2489 
    if mtype == TMessageType.EXCEPTION:
2490 
      x = TApplicationException()
2491 
      x.read(self._iprot)
2492 
      self._iprot.readMessageEnd()
2493 
      raise x
2494 
    result = getValidOrdersAmountRange_result()
2495 
    result.read(self._iprot)
2496 
    self._iprot.readMessageEnd()
3431 rajveer 2497 
    if result.success is not None:
3064 chandransh 2498 
      return result.success
2499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2500 
 
5874 rajveer 2501 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2502 
    """
2503 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2504 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2505 
 
3064 chandransh 2506 
    Parameters:
2507 
     - limit
5874 rajveer 2508 
     - onlyStore
3064 chandransh 2509 
    """
5874 rajveer 2510 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2511 
    return self.recv_getValidOrders()
2512 
 
5874 rajveer 2513 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2514 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2515 
    args = getValidOrders_args()
2516 
    args.limit = limit
5874 rajveer 2517 
    args.onlyStore = onlyStore
3064 chandransh 2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
2522 
  def recv_getValidOrders(self, ):
2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
2529 
    result = getValidOrders_result()
2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
3431 rajveer 2532 
    if result.success is not None:
3064 chandransh 2533 
      return result.success
2534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2535 
 
1220 chandransh 2536 
  def batchOrders(self, warehouseId):
2537 
    """
2538 
    Create a batch of all the pending orders for the given warehouse.
2539 
    The returned list is orderd by created_timestamp.
2540 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2541 
 
1220 chandransh 2542 
    Parameters:
2543 
     - warehouseId
2544 
    """
2545 
    self.send_batchOrders(warehouseId)
2546 
    return self.recv_batchOrders()
2547 
 
2548 
  def send_batchOrders(self, warehouseId):
2549 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2550 
    args = batchOrders_args()
2551 
    args.warehouseId = warehouseId
2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2556 
  def recv_batchOrders(self, ):
2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2563 
    result = batchOrders_result()
2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
3431 rajveer 2566 
    if result.success is not None:
1220 chandransh 2567 
      return result.success
3431 rajveer 2568 
    if result.ex is not None:
1220 chandransh 2569 
      raise result.ex
2570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2571 
 
1208 chandransh 2572 
  def markOrderAsOutOfStock(self, orderId):
2573 
    """
2574 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2575 
 
1208 chandransh 2576 
    Parameters:
2577 
     - orderId
2578 
    """
2579 
    self.send_markOrderAsOutOfStock(orderId)
2580 
    return self.recv_markOrderAsOutOfStock()
2581 
 
2582 
  def send_markOrderAsOutOfStock(self, orderId):
2583 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2584 
    args = markOrderAsOutOfStock_args()
2585 
    args.orderId = orderId
2586 
    args.write(self._oprot)
2587 
    self._oprot.writeMessageEnd()
2588 
    self._oprot.trans.flush()
2589 
 
2590 
  def recv_markOrderAsOutOfStock(self, ):
2591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2592 
    if mtype == TMessageType.EXCEPTION:
2593 
      x = TApplicationException()
2594 
      x.read(self._iprot)
2595 
      self._iprot.readMessageEnd()
2596 
      raise x
2597 
    result = markOrderAsOutOfStock_result()
2598 
    result.read(self._iprot)
2599 
    self._iprot.readMessageEnd()
3431 rajveer 2600 
    if result.success is not None:
1208 chandransh 2601 
      return result.success
3431 rajveer 2602 
    if result.ex is not None:
1208 chandransh 2603 
      raise result.ex
2604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2605 
 
3064 chandransh 2606 
  def verifyOrder(self, orderId):
759 chandransh 2607 
    """
3064 chandransh 2608 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2609 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2610 
    used for all other orders as well.
2611 
    Throws an exception if no such order exists.
3431 rajveer 2612 
 
759 chandransh 2613 
    Parameters:
3064 chandransh 2614 
     - orderId
759 chandransh 2615 
    """
3064 chandransh 2616 
    self.send_verifyOrder(orderId)
2617 
    return self.recv_verifyOrder()
759 chandransh 2618 
 
3064 chandransh 2619 
  def send_verifyOrder(self, orderId):
2620 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2621 
    args = verifyOrder_args()
2622 
    args.orderId = orderId
759 chandransh 2623 
    args.write(self._oprot)
2624 
    self._oprot.writeMessageEnd()
2625 
    self._oprot.trans.flush()
2626 
 
3064 chandransh 2627 
  def recv_verifyOrder(self, ):
759 chandransh 2628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2629 
    if mtype == TMessageType.EXCEPTION:
2630 
      x = TApplicationException()
2631 
      x.read(self._iprot)
2632 
      self._iprot.readMessageEnd()
2633 
      raise x
3064 chandransh 2634 
    result = verifyOrder_result()
759 chandransh 2635 
    result.read(self._iprot)
2636 
    self._iprot.readMessageEnd()
3431 rajveer 2637 
    if result.success is not None:
759 chandransh 2638 
      return result.success
3431 rajveer 2639 
    if result.ex is not None:
759 chandransh 2640 
      raise result.ex
3064 chandransh 2641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2642 
 
3064 chandransh 2643 
  def acceptOrder(self, orderId):
1113 chandransh 2644 
    """
3064 chandransh 2645 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2646 
    given order is not a COD order, it also captures the payment if the same has
2647 
    not been captured.
2648 
    Throws an exception if no such order exists.
3431 rajveer 2649 
 
1113 chandransh 2650 
    Parameters:
3064 chandransh 2651 
     - orderId
1113 chandransh 2652 
    """
3064 chandransh 2653 
    self.send_acceptOrder(orderId)
2654 
    return self.recv_acceptOrder()
1113 chandransh 2655 
 
3064 chandransh 2656 
  def send_acceptOrder(self, orderId):
2657 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2658 
    args = acceptOrder_args()
2659 
    args.orderId = orderId
1113 chandransh 2660 
    args.write(self._oprot)
2661 
    self._oprot.writeMessageEnd()
2662 
    self._oprot.trans.flush()
2663 
 
3064 chandransh 2664 
  def recv_acceptOrder(self, ):
1113 chandransh 2665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2666 
    if mtype == TMessageType.EXCEPTION:
2667 
      x = TApplicationException()
2668 
      x.read(self._iprot)
2669 
      self._iprot.readMessageEnd()
2670 
      raise x
3064 chandransh 2671 
    result = acceptOrder_result()
1113 chandransh 2672 
    result.read(self._iprot)
2673 
    self._iprot.readMessageEnd()
3431 rajveer 2674 
    if result.success is not None:
1113 chandransh 2675 
      return result.success
3431 rajveer 2676 
    if result.ex is not None:
1113 chandransh 2677 
      raise result.ex
3064 chandransh 2678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2679 
 
5110 mandeep.dh 2680 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2681 
    """
3064 chandransh 2682 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2683 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2684 
    the IMEI no. if a -1 is supplied.
2685 
    Also, it generates an invoice number for the order, marks the order as
2686 
    BILLED and sets the billing timestamp.
2687 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2688 
 
1135 chandransh 2689 
    Parameters:
3064 chandransh 2690 
     - orderId
2691 
     - invoice_number
4658 mandeep.dh 2692 
     - serialNumber
4283 anupam.sin 2693 
     - itemNumber
3064 chandransh 2694 
     - billed_by
4264 rajveer 2695 
     - jacketNumber
4283 anupam.sin 2696 
     - billingType
5110 mandeep.dh 2697 
     - fulfilmentWarehouseId
4763 rajveer 2698 
     - authorize
1135 chandransh 2699 
    """
5110 mandeep.dh 2700 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2701 
    return self.recv_addBillingDetails()
1135 chandransh 2702 
 
5110 mandeep.dh 2703 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2704 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2705 
    args = addBillingDetails_args()
2706 
    args.orderId = orderId
2707 
    args.invoice_number = invoice_number
4658 mandeep.dh 2708 
    args.serialNumber = serialNumber
4283 anupam.sin 2709 
    args.itemNumber = itemNumber
3064 chandransh 2710 
    args.billed_by = billed_by
4264 rajveer 2711 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2712 
    args.billingType = billingType
5110 mandeep.dh 2713 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2714 
    args.authorize = authorize
1135 chandransh 2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
3064 chandransh 2719 
  def recv_addBillingDetails(self, ):
1135 chandransh 2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
3064 chandransh 2726 
    result = addBillingDetails_result()
1135 chandransh 2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
3431 rajveer 2729 
    if result.success is not None:
3064 chandransh 2730 
      return result.success
3431 rajveer 2731 
    if result.ex is not None:
1135 chandransh 2732 
      raise result.ex
3064 chandransh 2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2734 
 
6756 amar.kumar 2735 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2736 
    """
2737 
    Add the invoice number to the order.
2738 
 
2739 
    Parameters:
2740 
     - orderId
2741 
     - invoiceNumber
4763 rajveer 2742 
     - color
6756 amar.kumar 2743 
     - serialNumber
2744 
     - itemNumber
4579 rajveer 2745 
    """
6756 amar.kumar 2746 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2747 
    self.recv_addInvoiceNumber()
2748 
 
6756 amar.kumar 2749 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2750 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2751 
    args = addInvoiceNumber_args()
2752 
    args.orderId = orderId
2753 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2754 
    args.color = color
6756 amar.kumar 2755 
    args.serialNumber = serialNumber
2756 
    args.itemNumber = itemNumber
4579 rajveer 2757 
    args.write(self._oprot)
2758 
    self._oprot.writeMessageEnd()
2759 
    self._oprot.trans.flush()
2760 
 
2761 
  def recv_addInvoiceNumber(self, ):
2762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2763 
    if mtype == TMessageType.EXCEPTION:
2764 
      x = TApplicationException()
2765 
      x.read(self._iprot)
2766 
      self._iprot.readMessageEnd()
2767 
      raise x
2768 
    result = addInvoiceNumber_result()
2769 
    result.read(self._iprot)
2770 
    self._iprot.readMessageEnd()
2771 
    if result.ex is not None:
2772 
      raise result.ex
2773 
    return
2774 
 
4910 phani.kuma 2775 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2776 
    """
3064 chandransh 2777 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2778 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2779 
 
1408 ankur.sing 2780 
    Parameters:
3064 chandransh 2781 
     - warehouseId
1408 ankur.sing 2782 
     - providerId
3064 chandransh 2783 
     - cod
4910 phani.kuma 2784 
     - orderIds
1408 ankur.sing 2785 
    """
4910 phani.kuma 2786 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2787 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2788 
 
4910 phani.kuma 2789 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2790 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2791 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2792 
    args.warehouseId = warehouseId
1408 ankur.sing 2793 
    args.providerId = providerId
3064 chandransh 2794 
    args.cod = cod
4910 phani.kuma 2795 
    args.orderIds = orderIds
1408 ankur.sing 2796 
    args.write(self._oprot)
2797 
    self._oprot.writeMessageEnd()
2798 
    self._oprot.trans.flush()
2799 
 
4910 phani.kuma 2800 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2802 
    if mtype == TMessageType.EXCEPTION:
2803 
      x = TApplicationException()
2804 
      x.read(self._iprot)
2805 
      self._iprot.readMessageEnd()
2806 
      raise x
4910 phani.kuma 2807 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2808 
    result.read(self._iprot)
2809 
    self._iprot.readMessageEnd()
3431 rajveer 2810 
    if result.success is not None:
1408 ankur.sing 2811 
      return result.success
3431 rajveer 2812 
    if result.ex is not None:
3064 chandransh 2813 
      raise result.ex
4910 phani.kuma 2814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2815 
 
5713 rajveer 2816 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2817 
    """
2818 
    Parameters:
2819 
     - providerId
2820 
     - orderIds
5713 rajveer 2821 
     - awbs
5676 rajveer 2822 
    """
5713 rajveer 2823 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2824 
    return self.recv_markOrdersAsReturnedFromStore()
2825 
 
5713 rajveer 2826 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2827 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2828 
    args = markOrdersAsReturnedFromStore_args()
2829 
    args.providerId = providerId
2830 
    args.orderIds = orderIds
5713 rajveer 2831 
    args.awbs = awbs
5676 rajveer 2832 
    args.write(self._oprot)
2833 
    self._oprot.writeMessageEnd()
2834 
    self._oprot.trans.flush()
2835 
 
2836 
  def recv_markOrdersAsReturnedFromStore(self, ):
2837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2838 
    if mtype == TMessageType.EXCEPTION:
2839 
      x = TApplicationException()
2840 
      x.read(self._iprot)
2841 
      self._iprot.readMessageEnd()
2842 
      raise x
2843 
    result = markOrdersAsReturnedFromStore_result()
2844 
    result.read(self._iprot)
2845 
    self._iprot.readMessageEnd()
2846 
    if result.success is not None:
2847 
      return result.success
2848 
    if result.ex is not None:
2849 
      raise result.ex
2850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2851 
 
4910 phani.kuma 2852 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2853 
    """
4910 phani.kuma 2854 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2855 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2856 
 
2857 
    Parameters:
2858 
     - providerId
4910 phani.kuma 2859 
     - pickupDetails
4410 rajveer 2860 
    """
4910 phani.kuma 2861 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2862 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2863 
 
4910 phani.kuma 2864 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2865 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2866 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2867 
    args.providerId = providerId
4910 phani.kuma 2868 
    args.pickupDetails = pickupDetails
4410 rajveer 2869 
    args.write(self._oprot)
2870 
    self._oprot.writeMessageEnd()
2871 
    self._oprot.trans.flush()
2872 
 
4910 phani.kuma 2873 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2875 
    if mtype == TMessageType.EXCEPTION:
2876 
      x = TApplicationException()
2877 
      x.read(self._iprot)
2878 
      self._iprot.readMessageEnd()
2879 
      raise x
4910 phani.kuma 2880 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2881 
    result.read(self._iprot)
2882 
    self._iprot.readMessageEnd()
2883 
    if result.ex is not None:
2884 
      raise result.ex
4910 phani.kuma 2885 
    return
4410 rajveer 2886 
 
4910 phani.kuma 2887 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2888 
    """
3064 chandransh 2889 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2890 
 
94 ashish 2891 
    Parameters:
3064 chandransh 2892 
     - providerId
304 ashish 2893 
    """
4910 phani.kuma 2894 
    self.send_getOrdersNotPickedUp(providerId)
2895 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2896 
 
4910 phani.kuma 2897 
  def send_getOrdersNotPickedUp(self, providerId):
2898 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2899 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2900 
    args.providerId = providerId
304 ashish 2901 
    args.write(self._oprot)
2902 
    self._oprot.writeMessageEnd()
2903 
    self._oprot.trans.flush()
2904 
 
4910 phani.kuma 2905 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2907 
    if mtype == TMessageType.EXCEPTION:
2908 
      x = TApplicationException()
2909 
      x.read(self._iprot)
2910 
      self._iprot.readMessageEnd()
2911 
      raise x
4910 phani.kuma 2912 
    result = getOrdersNotPickedUp_result()
304 ashish 2913 
    result.read(self._iprot)
2914 
    self._iprot.readMessageEnd()
3431 rajveer 2915 
    if result.success is not None:
304 ashish 2916 
      return result.success
4910 phani.kuma 2917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2918 
 
3064 chandransh 2919 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2920 
    """
3064 chandransh 2921 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2922 
    the name of the receiver.
2923 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2924 
 
304 ashish 2925 
    Parameters:
3064 chandransh 2926 
     - providerId
2927 
     - deliveredOrders
304 ashish 2928 
    """
3064 chandransh 2929 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2930 
    self.recv_markOrdersAsDelivered()
304 ashish 2931 
 
3064 chandransh 2932 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2933 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2934 
    args = markOrdersAsDelivered_args()
2935 
    args.providerId = providerId
2936 
    args.deliveredOrders = deliveredOrders
304 ashish 2937 
    args.write(self._oprot)
2938 
    self._oprot.writeMessageEnd()
2939 
    self._oprot.trans.flush()
2940 
 
3064 chandransh 2941 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2943 
    if mtype == TMessageType.EXCEPTION:
2944 
      x = TApplicationException()
2945 
      x.read(self._iprot)
2946 
      self._iprot.readMessageEnd()
2947 
      raise x
3064 chandransh 2948 
    result = markOrdersAsDelivered_result()
304 ashish 2949 
    result.read(self._iprot)
2950 
    self._iprot.readMessageEnd()
3431 rajveer 2951 
    if result.ex is not None:
3064 chandransh 2952 
      raise result.ex
304 ashish 2953 
    return
2954 
 
4910 phani.kuma 2955 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2956 
    """
4910 phani.kuma 2957 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2958 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2959 
 
3064 chandransh 2960 
    Parameters:
2961 
     - providerId
2962 
     - returnedOrders
1596 ankur.sing 2963 
    """
4910 phani.kuma 2964 
    self.send_markAsRTOrders(providerId, returnedOrders)
2965 
    self.recv_markAsRTOrders()
304 ashish 2966 
 
4910 phani.kuma 2967 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2968 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2969 
    args = markAsRTOrders_args()
3064 chandransh 2970 
    args.providerId = providerId
2971 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
4910 phani.kuma 2976 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2977 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2978 
    if mtype == TMessageType.EXCEPTION:
2979 
      x = TApplicationException()
2980 
      x.read(self._iprot)
2981 
      self._iprot.readMessageEnd()
2982 
      raise x
4910 phani.kuma 2983 
    result = markAsRTOrders_result()
1596 ankur.sing 2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
3431 rajveer 2986 
    if result.ex is not None:
3064 chandransh 2987 
      raise result.ex
2988 
    return
1596 ankur.sing 2989 
 
4910 phani.kuma 2990 
  def getRTOrders(self, providerId):
2991 
    """
2992 
    Returns a list of orders that were returned by courier.
2993 
 
2994 
    Parameters:
2995 
     - providerId
2996 
    """
2997 
    self.send_getRTOrders(providerId)
2998 
    return self.recv_getRTOrders()
2999 
 
3000 
  def send_getRTOrders(self, providerId):
3001 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3002 
    args = getRTOrders_args()
3003 
    args.providerId = providerId
3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3008 
  def recv_getRTOrders(self, ):
3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3015 
    result = getRTOrders_result()
3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
3018 
    if result.success is not None:
3019 
      return result.success
3020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3021 
 
3064 chandransh 3022 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3023 
    """
3064 chandransh 3024 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3025 
 
3064 chandransh 3026 
    Parameters:
3027 
     - providerId
3028 
     - undeliveredOrders
1627 ankur.sing 3029 
    """
3064 chandransh 3030 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3031 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3032 
 
3064 chandransh 3033 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3034 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3035 
    args = updateNonDeliveryReason_args()
3036 
    args.providerId = providerId
3037 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3038 
    args.write(self._oprot)
3039 
    self._oprot.writeMessageEnd()
3040 
    self._oprot.trans.flush()
3041 
 
3064 chandransh 3042 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3043 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3044 
    if mtype == TMessageType.EXCEPTION:
3045 
      x = TApplicationException()
3046 
      x.read(self._iprot)
3047 
      self._iprot.readMessageEnd()
3048 
      raise x
3064 chandransh 3049 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3050 
    result.read(self._iprot)
3051 
    self._iprot.readMessageEnd()
4910 phani.kuma 3052 
    if result.ex is not None:
3053 
      raise result.ex
3054 
    return
3055 
 
3056 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3057 
    """
3058 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3059 
 
3060 
    Parameters:
3061 
     - providerId
3062 
    """
3063 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3064 
    return self.recv_getNonDeliveredOrdersbyCourier()
3065 
 
3066 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3067 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3068 
    args = getNonDeliveredOrdersbyCourier_args()
3069 
    args.providerId = providerId
3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = getNonDeliveredOrdersbyCourier_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
4581 phani.kuma 3084 
    if result.success is not None:
3085 
      return result.success
4910 phani.kuma 3086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3087 
 
3088 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3089 
    """
3090 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3091 
 
3092 
    Parameters:
3093 
     - providerId
3094 
     - local_connected_orders
3095 
    """
3096 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3097 
    self.recv_markOrdersAsLocalConnected()
3098 
 
3099 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3100 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3101 
    args = markOrdersAsLocalConnected_args()
3102 
    args.providerId = providerId
3103 
    args.local_connected_orders = local_connected_orders
3104 
    args.write(self._oprot)
3105 
    self._oprot.writeMessageEnd()
3106 
    self._oprot.trans.flush()
3107 
 
3108 
  def recv_markOrdersAsLocalConnected(self, ):
3109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3110 
    if mtype == TMessageType.EXCEPTION:
3111 
      x = TApplicationException()
3112 
      x.read(self._iprot)
3113 
      self._iprot.readMessageEnd()
3114 
      raise x
3115 
    result = markOrdersAsLocalConnected_result()
3116 
    result.read(self._iprot)
3117 
    self._iprot.readMessageEnd()
3431 rajveer 3118 
    if result.ex is not None:
3064 chandransh 3119 
      raise result.ex
4910 phani.kuma 3120 
    return
1627 ankur.sing 3121 
 
4910 phani.kuma 3122 
  def getOrdersNotLocalConnected(self, providerId):
3123 
    """
3124 
    Returns a list of orders that were picked up or shipped but pending local connection.
3125 
 
3126 
    Parameters:
3127 
     - providerId
3128 
    """
3129 
    self.send_getOrdersNotLocalConnected(providerId)
3130 
    return self.recv_getOrdersNotLocalConnected()
3131 
 
3132 
  def send_getOrdersNotLocalConnected(self, providerId):
3133 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3134 
    args = getOrdersNotLocalConnected_args()
3135 
    args.providerId = providerId
3136 
    args.write(self._oprot)
3137 
    self._oprot.writeMessageEnd()
3138 
    self._oprot.trans.flush()
3139 
 
3140 
  def recv_getOrdersNotLocalConnected(self, ):
3141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3142 
    if mtype == TMessageType.EXCEPTION:
3143 
      x = TApplicationException()
3144 
      x.read(self._iprot)
3145 
      self._iprot.readMessageEnd()
3146 
      raise x
3147 
    result = getOrdersNotLocalConnected_result()
3148 
    result.read(self._iprot)
3149 
    self._iprot.readMessageEnd()
3150 
    if result.success is not None:
3151 
      return result.success
3152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3153 
 
3154 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3155 
    """
3156 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3157 
 
3158 
    Parameters:
3159 
     - providerId
3160 
     - destination_city_reached_orders
3161 
    """
3162 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3163 
    self.recv_markOrdersAsDestinationCityReached()
3164 
 
3165 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3166 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3167 
    args = markOrdersAsDestinationCityReached_args()
3168 
    args.providerId = providerId
3169 
    args.destination_city_reached_orders = destination_city_reached_orders
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_markOrdersAsDestinationCityReached(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = markOrdersAsDestinationCityReached_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3184 
    if result.ex is not None:
3185 
      raise result.ex
3186 
    return
3187 
 
3188 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3189 
    """
3190 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3191 
 
3192 
    Parameters:
3193 
     - providerId
3194 
     - first_atdl_orders
3195 
    """
3196 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3197 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3198 
 
3199 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3200 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3201 
    args = markOrdersAsFirstDeliveryAttempted_args()
3202 
    args.providerId = providerId
3203 
    args.first_atdl_orders = first_atdl_orders
3204 
    args.write(self._oprot)
3205 
    self._oprot.writeMessageEnd()
3206 
    self._oprot.trans.flush()
3207 
 
3208 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3209 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3210 
    if mtype == TMessageType.EXCEPTION:
3211 
      x = TApplicationException()
3212 
      x.read(self._iprot)
3213 
      self._iprot.readMessageEnd()
3214 
      raise x
3215 
    result = markOrdersAsFirstDeliveryAttempted_result()
3216 
    result.read(self._iprot)
3217 
    self._iprot.readMessageEnd()
3218 
    if result.ex is not None:
3219 
      raise result.ex
3220 
    return
3221 
 
3064 chandransh 3222 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3223 
    """
3064 chandransh 3224 
    Returns the list of orders whose delivery time has passed but have not been
3225 
    delivered yet for the given provider and warehouse. To get a complete list of
3226 
    undelivered orders, pass them as -1.
3227 
    Returns an empty list if no such orders exist.
3431 rajveer 3228 
 
1886 ankur.sing 3229 
    Parameters:
3064 chandransh 3230 
     - providerId
3231 
     - warehouseId
1886 ankur.sing 3232 
    """
3064 chandransh 3233 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3234 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3235 
 
3064 chandransh 3236 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3237 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3238 
    args = getUndeliveredOrders_args()
3239 
    args.providerId = providerId
3240 
    args.warehouseId = warehouseId
1886 ankur.sing 3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3064 chandransh 3245 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3064 chandransh 3252 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3431 rajveer 3255 
    if result.success is not None:
1886 ankur.sing 3256 
      return result.success
3064 chandransh 3257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3258 
 
4783 phani.kuma 3259 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3260 
    """
3261 
    Returns the list of orders whose expected delivery date has passed but have not been
3262 
    delivered yet.
3263 
    Returns an empty list if no such orders exist.
3264 
    """
3265 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3266 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3267 
 
3268 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3269 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3270 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3285 
    if result.success is not None:
3286 
      return result.success
3287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3288 
 
2536 chandransh 3289 
  def toggleDOAFlag(self, orderId):
3290 
    """
3291 
    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.
3292 
    Returns the final flag status.
3293 
    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 3294 
 
2536 chandransh 3295 
    Parameters:
3296 
     - orderId
3297 
    """
3298 
    self.send_toggleDOAFlag(orderId)
3299 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3300 
 
2536 chandransh 3301 
  def send_toggleDOAFlag(self, orderId):
3302 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3303 
    args = toggleDOAFlag_args()
3304 
    args.orderId = orderId
3305 
    args.write(self._oprot)
3306 
    self._oprot.writeMessageEnd()
3307 
    self._oprot.trans.flush()
3308 
 
3309 
  def recv_toggleDOAFlag(self, ):
3310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3311 
    if mtype == TMessageType.EXCEPTION:
3312 
      x = TApplicationException()
3313 
      x.read(self._iprot)
3314 
      self._iprot.readMessageEnd()
3315 
      raise x
3316 
    result = toggleDOAFlag_result()
3317 
    result.read(self._iprot)
3318 
    self._iprot.readMessageEnd()
3431 rajveer 3319 
    if result.success is not None:
2536 chandransh 3320 
      return result.success
3431 rajveer 3321 
    if result.ex is not None:
2536 chandransh 3322 
      raise result.ex
3323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3324 
 
4712 rajveer 3325 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3326 
    """
3327 
    Parameters:
3328 
     - orderId
3329 
     - deliveryTimestamp
3330 
     - receiver
3331 
    """
3332 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3333 
    self.recv_markOrderAsDelivered()
3334 
 
3335 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3336 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3337 
    args = markOrderAsDelivered_args()
3338 
    args.orderId = orderId
3339 
    args.deliveryTimestamp = deliveryTimestamp
3340 
    args.receiver = receiver
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_markOrderAsDelivered(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = markOrderAsDelivered_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3355 
    if result.ex is not None:
3356 
      raise result.ex
3357 
    return
3358 
 
5553 rajveer 3359 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3360 
    """
3361 
    Parameters:
3362 
     - orderId
3363 
     - deliveryTimestamp
3364 
    """
3365 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3366 
    self.recv_markOrderAsReceivedAtStore()
3367 
 
3368 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3369 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3370 
    args = markOrderAsReceivedAtStore_args()
3371 
    args.orderId = orderId
3372 
    args.deliveryTimestamp = deliveryTimestamp
3373 
    args.write(self._oprot)
3374 
    self._oprot.writeMessageEnd()
3375 
    self._oprot.trans.flush()
3376 
 
3377 
  def recv_markOrderAsReceivedAtStore(self, ):
3378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3379 
    if mtype == TMessageType.EXCEPTION:
3380 
      x = TApplicationException()
3381 
      x.read(self._iprot)
3382 
      self._iprot.readMessageEnd()
3383 
      raise x
3384 
    result = markOrderAsReceivedAtStore_result()
3385 
    result.read(self._iprot)
3386 
    self._iprot.readMessageEnd()
3387 
    if result.ex is not None:
3388 
      raise result.ex
3389 
    return
3390 
 
4454 rajveer 3391 
  def markOrderDoaRequestReceived(self, orderId):
3392 
    """
3393 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3394 
 
3395 
    Parameters:
3396 
     - orderId
3397 
    """
3398 
    self.send_markOrderDoaRequestReceived(orderId)
3399 
    return self.recv_markOrderDoaRequestReceived()
3400 
 
3401 
  def send_markOrderDoaRequestReceived(self, orderId):
3402 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3403 
    args = markOrderDoaRequestReceived_args()
3404 
    args.orderId = orderId
3405 
    args.write(self._oprot)
3406 
    self._oprot.writeMessageEnd()
3407 
    self._oprot.trans.flush()
3408 
 
3409 
  def recv_markOrderDoaRequestReceived(self, ):
3410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3411 
    if mtype == TMessageType.EXCEPTION:
3412 
      x = TApplicationException()
3413 
      x.read(self._iprot)
3414 
      self._iprot.readMessageEnd()
3415 
      raise x
3416 
    result = markOrderDoaRequestReceived_result()
3417 
    result.read(self._iprot)
3418 
    self._iprot.readMessageEnd()
3419 
    if result.success is not None:
3420 
      return result.success
3421 
    if result.ex is not None:
3422 
      raise result.ex
3423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3424 
 
3425 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3426 
    """
3427 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3428 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3429 
 
3430 
    Parameters:
3431 
     - orderId
3432 
     - isAuthorized
3433 
    """
3434 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3435 
    return self.recv_markOrderDoaRequestAuthorized()
3436 
 
3437 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3438 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3439 
    args = markOrderDoaRequestAuthorized_args()
3440 
    args.orderId = orderId
3441 
    args.isAuthorized = isAuthorized
3442 
    args.write(self._oprot)
3443 
    self._oprot.writeMessageEnd()
3444 
    self._oprot.trans.flush()
3445 
 
3446 
  def recv_markOrderDoaRequestAuthorized(self, ):
3447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3448 
    if mtype == TMessageType.EXCEPTION:
3449 
      x = TApplicationException()
3450 
      x.read(self._iprot)
3451 
      self._iprot.readMessageEnd()
3452 
      raise x
3453 
    result = markOrderDoaRequestAuthorized_result()
3454 
    result.read(self._iprot)
3455 
    self._iprot.readMessageEnd()
3456 
    if result.success is not None:
3457 
      return result.success
3458 
    if result.ex is not None:
3459 
      raise result.ex
3460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3461 
 
4488 rajveer 3462 
  def markOrderReturnRequestReceived(self, orderId):
3463 
    """
3464 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3465 
 
3466 
    Parameters:
3467 
     - orderId
3468 
    """
3469 
    self.send_markOrderReturnRequestReceived(orderId)
3470 
    return self.recv_markOrderReturnRequestReceived()
3471 
 
3472 
  def send_markOrderReturnRequestReceived(self, orderId):
3473 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3474 
    args = markOrderReturnRequestReceived_args()
3475 
    args.orderId = orderId
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_markOrderReturnRequestReceived(self, ):
3481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3482 
    if mtype == TMessageType.EXCEPTION:
3483 
      x = TApplicationException()
3484 
      x.read(self._iprot)
3485 
      self._iprot.readMessageEnd()
3486 
      raise x
3487 
    result = markOrderReturnRequestReceived_result()
3488 
    result.read(self._iprot)
3489 
    self._iprot.readMessageEnd()
3490 
    if result.success is not None:
3491 
      return result.success
3492 
    if result.ex is not None:
3493 
      raise result.ex
3494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3495 
 
3496 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3497 
    """
3498 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3499 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3500 
 
3501 
    Parameters:
3502 
     - orderId
3503 
     - isAuthorized
3504 
    """
3505 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3506 
    return self.recv_markOrderReturnRequestAuthorized()
3507 
 
3508 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3509 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3510 
    args = markOrderReturnRequestAuthorized_args()
3511 
    args.orderId = orderId
3512 
    args.isAuthorized = isAuthorized
3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
3517 
  def recv_markOrderReturnRequestAuthorized(self, ):
3518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3519 
    if mtype == TMessageType.EXCEPTION:
3520 
      x = TApplicationException()
3521 
      x.read(self._iprot)
3522 
      self._iprot.readMessageEnd()
3523 
      raise x
3524 
    result = markOrderReturnRequestAuthorized_result()
3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3527 
    if result.success is not None:
3528 
      return result.success
3529 
    if result.ex is not None:
3530 
      raise result.ex
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3532 
 
4579 rajveer 3533 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3534 
    """
3535 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3536 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3537 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3538 
    For any other status, it returns false.
3539 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3540 
 
2536 chandransh 3541 
    Parameters:
3542 
     - orderId
4579 rajveer 3543 
     - providerId
2536 chandransh 3544 
    """
4579 rajveer 3545 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3546 
    return self.recv_requestPickupNumber()
3547 
 
4579 rajveer 3548 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3549 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3550 
    args = requestPickupNumber_args()
3551 
    args.orderId = orderId
4579 rajveer 3552 
    args.providerId = providerId
2536 chandransh 3553 
    args.write(self._oprot)
3554 
    self._oprot.writeMessageEnd()
3555 
    self._oprot.trans.flush()
3556 
 
3557 
  def recv_requestPickupNumber(self, ):
3558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3559 
    if mtype == TMessageType.EXCEPTION:
3560 
      x = TApplicationException()
3561 
      x.read(self._iprot)
3562 
      self._iprot.readMessageEnd()
3563 
      raise x
3564 
    result = requestPickupNumber_result()
3565 
    result.read(self._iprot)
3566 
    self._iprot.readMessageEnd()
3431 rajveer 3567 
    if result.success is not None:
2536 chandransh 3568 
      return result.success
3431 rajveer 3569 
    if result.ex is not None:
2536 chandransh 3570 
      raise result.ex
3571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3572 
 
4602 rajveer 3573 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3574 
    """
4452 rajveer 3575 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3576 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3577 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3578 
    	3. Returns true
2591 chandransh 3579 
    If the order is in any other status, it returns false.
2536 chandransh 3580 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3581 
 
2536 chandransh 3582 
    Parameters:
3583 
     - orderId
3584 
     - pickupNumber
4602 rajveer 3585 
     - providerId
2536 chandransh 3586 
    """
4602 rajveer 3587 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3588 
    return self.recv_authorizePickup()
3589 
 
4602 rajveer 3590 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3591 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3592 
    args = authorizePickup_args()
3593 
    args.orderId = orderId
3594 
    args.pickupNumber = pickupNumber
4602 rajveer 3595 
    args.providerId = providerId
2536 chandransh 3596 
    args.write(self._oprot)
3597 
    self._oprot.writeMessageEnd()
3598 
    self._oprot.trans.flush()
3599 
 
3600 
  def recv_authorizePickup(self, ):
3601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3602 
    if mtype == TMessageType.EXCEPTION:
3603 
      x = TApplicationException()
3604 
      x.read(self._iprot)
3605 
      self._iprot.readMessageEnd()
3606 
      raise x
3607 
    result = authorizePickup_result()
3608 
    result.read(self._iprot)
3609 
    self._iprot.readMessageEnd()
3431 rajveer 3610 
    if result.success is not None:
2536 chandransh 3611 
      return result.success
3431 rajveer 3612 
    if result.ex is not None:
2536 chandransh 3613 
      raise result.ex
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3615 
 
2764 chandransh 3616 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3617 
    """
3618 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3619 
 
2764 chandransh 3620 
    Parameters:
3621 
     - providerId
3622 
     - pickupDetails
3623 
    """
3624 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3625 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3626 
 
3627 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3628 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3629 
    args = markDoasAsPickedUp_args()
3630 
    args.providerId = providerId
3631 
    args.pickupDetails = pickupDetails
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_markDoasAsPickedUp(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = markDoasAsPickedUp_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
4910 phani.kuma 3646 
    return
3647 
 
3648 
  def getDoasNotPickedUp(self, providerId):
3649 
    """
3650 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3651 
 
3652 
    Parameters:
3653 
     - providerId
3654 
    """
3655 
    self.send_getDoasNotPickedUp(providerId)
3656 
    return self.recv_getDoasNotPickedUp()
3657 
 
3658 
  def send_getDoasNotPickedUp(self, providerId):
3659 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3660 
    args = getDoasNotPickedUp_args()
3661 
    args.providerId = providerId
3662 
    args.write(self._oprot)
3663 
    self._oprot.writeMessageEnd()
3664 
    self._oprot.trans.flush()
3665 
 
3666 
  def recv_getDoasNotPickedUp(self, ):
3667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3668 
    if mtype == TMessageType.EXCEPTION:
3669 
      x = TApplicationException()
3670 
      x.read(self._iprot)
3671 
      self._iprot.readMessageEnd()
3672 
      raise x
3673 
    result = getDoasNotPickedUp_result()
3674 
    result.read(self._iprot)
3675 
    self._iprot.readMessageEnd()
3431 rajveer 3676 
    if result.success is not None:
2764 chandransh 3677 
      return result.success
4910 phani.kuma 3678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3679 
 
4741 phani.kuma 3680 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3681 
    """
3682 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3683 
 
3684 
    Parameters:
3685 
     - providerId
3686 
     - pickupDetails
3687 
    """
3688 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3689 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3690 
 
3691 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3692 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3693 
    args = markReturnOrdersAsPickedUp_args()
3694 
    args.providerId = providerId
3695 
    args.pickupDetails = pickupDetails
3696 
    args.write(self._oprot)
3697 
    self._oprot.writeMessageEnd()
3698 
    self._oprot.trans.flush()
3699 
 
3700 
  def recv_markReturnOrdersAsPickedUp(self, ):
3701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3702 
    if mtype == TMessageType.EXCEPTION:
3703 
      x = TApplicationException()
3704 
      x.read(self._iprot)
3705 
      self._iprot.readMessageEnd()
3706 
      raise x
3707 
    result = markReturnOrdersAsPickedUp_result()
3708 
    result.read(self._iprot)
3709 
    self._iprot.readMessageEnd()
4910 phani.kuma 3710 
    return
3711 
 
3712 
  def getReturnOrdersNotPickedUp(self, providerId):
3713 
    """
3714 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3715 
 
3716 
    Parameters:
3717 
     - providerId
3718 
    """
3719 
    self.send_getReturnOrdersNotPickedUp(providerId)
3720 
    return self.recv_getReturnOrdersNotPickedUp()
3721 
 
3722 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3723 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3724 
    args = getReturnOrdersNotPickedUp_args()
3725 
    args.providerId = providerId
3726 
    args.write(self._oprot)
3727 
    self._oprot.writeMessageEnd()
3728 
    self._oprot.trans.flush()
3729 
 
3730 
  def recv_getReturnOrdersNotPickedUp(self, ):
3731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3732 
    if mtype == TMessageType.EXCEPTION:
3733 
      x = TApplicationException()
3734 
      x.read(self._iprot)
3735 
      self._iprot.readMessageEnd()
3736 
      raise x
3737 
    result = getReturnOrdersNotPickedUp_result()
3738 
    result.read(self._iprot)
3739 
    self._iprot.readMessageEnd()
4741 phani.kuma 3740 
    if result.success is not None:
3741 
      return result.success
4910 phani.kuma 3742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3743 
 
4479 rajveer 3744 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3745 
    """
4452 rajveer 3746 
    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 3747 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3748 
    If the order is in any other state, it returns false.
3749 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3750 
 
2591 chandransh 3751 
    Parameters:
3752 
     - orderId
4479 rajveer 3753 
     - receiveCondition
2591 chandransh 3754 
    """
4479 rajveer 3755 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3756 
    return self.recv_receiveReturn()
2536 chandransh 3757 
 
4479 rajveer 3758 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3759 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3760 
    args = receiveReturn_args()
2591 chandransh 3761 
    args.orderId = orderId
4479 rajveer 3762 
    args.receiveCondition = receiveCondition
2591 chandransh 3763 
    args.write(self._oprot)
3764 
    self._oprot.writeMessageEnd()
3765 
    self._oprot.trans.flush()
3766 
 
2616 chandransh 3767 
  def recv_receiveReturn(self, ):
2591 chandransh 3768 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3769 
    if mtype == TMessageType.EXCEPTION:
3770 
      x = TApplicationException()
3771 
      x.read(self._iprot)
3772 
      self._iprot.readMessageEnd()
3773 
      raise x
2616 chandransh 3774 
    result = receiveReturn_result()
2591 chandransh 3775 
    result.read(self._iprot)
3776 
    self._iprot.readMessageEnd()
3431 rajveer 3777 
    if result.success is not None:
2591 chandransh 3778 
      return result.success
3431 rajveer 3779 
    if result.ex is not None:
2591 chandransh 3780 
      raise result.ex
2616 chandransh 3781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3782 
 
3783 
  def validateDoa(self, orderId, isValid):
3784 
    """
4452 rajveer 3785 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3786 
    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 3787 
    If the order is in any other state, it returns false.
3788 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3789 
 
2591 chandransh 3790 
    Parameters:
3791 
     - orderId
3792 
     - isValid
3793 
    """
3794 
    self.send_validateDoa(orderId, isValid)
3795 
    return self.recv_validateDoa()
3796 
 
3797 
  def send_validateDoa(self, orderId, isValid):
3798 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3799 
    args = validateDoa_args()
3800 
    args.orderId = orderId
3801 
    args.isValid = isValid
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_validateDoa(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = validateDoa_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3431 rajveer 3816 
    if result.success is not None:
2591 chandransh 3817 
      return result.success
3431 rajveer 3818 
    if result.ex is not None:
2591 chandransh 3819 
      raise result.ex
3820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3821 
 
4495 rajveer 3822 
  def validateReturnProduct(self, orderId, isUsable):
3823 
    """
3824 
    Parameters:
3825 
     - orderId
3826 
     - isUsable
3827 
    """
3828 
    self.send_validateReturnProduct(orderId, isUsable)
3829 
    return self.recv_validateReturnProduct()
3830 
 
3831 
  def send_validateReturnProduct(self, orderId, isUsable):
3832 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3833 
    args = validateReturnProduct_args()
3834 
    args.orderId = orderId
3835 
    args.isUsable = isUsable
3836 
    args.write(self._oprot)
3837 
    self._oprot.writeMessageEnd()
3838 
    self._oprot.trans.flush()
3839 
 
3840 
  def recv_validateReturnProduct(self, ):
3841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3842 
    if mtype == TMessageType.EXCEPTION:
3843 
      x = TApplicationException()
3844 
      x.read(self._iprot)
3845 
      self._iprot.readMessageEnd()
3846 
      raise x
3847 
    result = validateReturnProduct_result()
3848 
    result.read(self._iprot)
3849 
    self._iprot.readMessageEnd()
3850 
    if result.success is not None:
3851 
      return result.success
3852 
    if result.ex is not None:
3853 
      raise result.ex
3854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3855 
 
2616 chandransh 3856 
  def reshipOrder(self, orderId):
3857 
    """
4484 rajveer 3858 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3859 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3860 
    	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 3861 
 
3862 
    If the order is in DOA_CERT_VALID state, it does the following:
3863 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3864 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3865 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3866 
 
2616 chandransh 3867 
    Returns the id of the newly created order.
3431 rajveer 3868 
 
2616 chandransh 3869 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3870 
 
2616 chandransh 3871 
    Parameters:
3872 
     - orderId
3873 
    """
3874 
    self.send_reshipOrder(orderId)
3875 
    return self.recv_reshipOrder()
2591 chandransh 3876 
 
2616 chandransh 3877 
  def send_reshipOrder(self, orderId):
3878 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3879 
    args = reshipOrder_args()
3880 
    args.orderId = orderId
3881 
    args.write(self._oprot)
3882 
    self._oprot.writeMessageEnd()
3883 
    self._oprot.trans.flush()
3884 
 
3885 
  def recv_reshipOrder(self, ):
3886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3887 
    if mtype == TMessageType.EXCEPTION:
3888 
      x = TApplicationException()
3889 
      x.read(self._iprot)
3890 
      self._iprot.readMessageEnd()
3891 
      raise x
3892 
    result = reshipOrder_result()
3893 
    result.read(self._iprot)
3894 
    self._iprot.readMessageEnd()
3431 rajveer 3895 
    if result.success is not None:
2616 chandransh 3896 
      return result.success
3431 rajveer 3897 
    if result.ex is not None:
2616 chandransh 3898 
      raise result.ex
3899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3900 
 
3226 chandransh 3901 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3902 
    """
4484 rajveer 3903 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3904 
    	1. Creates a refund request for batch processing.
3905 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3906 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3907 
 
2616 chandransh 3908 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3909 
    	1. Creates a refund request for batch processing.
3226 chandransh 3910 
    	2. Cancels the reservation of the item in the warehouse.
3911 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3912 
 
3226 chandransh 3913 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3914 
    	1. Cancels the reservation of the item in the warehouse.
3915 
    	2. Marks the current order as CANCELED.
3916 
 
3917 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3918 
 
2616 chandransh 3919 
    Returns True if it is successful, False otherwise.
3431 rajveer 3920 
 
2616 chandransh 3921 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3922 
 
2616 chandransh 3923 
    Parameters:
3924 
     - orderId
3226 chandransh 3925 
     - refundedBy
3926 
     - reason
2616 chandransh 3927 
    """
3226 chandransh 3928 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3929 
    return self.recv_refundOrder()
3930 
 
3226 chandransh 3931 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3932 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3933 
    args = refundOrder_args()
3934 
    args.orderId = orderId
3226 chandransh 3935 
    args.refundedBy = refundedBy
3936 
    args.reason = reason
2616 chandransh 3937 
    args.write(self._oprot)
3938 
    self._oprot.writeMessageEnd()
3939 
    self._oprot.trans.flush()
3940 
 
3941 
  def recv_refundOrder(self, ):
3942 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3943 
    if mtype == TMessageType.EXCEPTION:
3944 
      x = TApplicationException()
3945 
      x.read(self._iprot)
3946 
      self._iprot.readMessageEnd()
3947 
      raise x
3948 
    result = refundOrder_result()
3949 
    result.read(self._iprot)
3950 
    self._iprot.readMessageEnd()
3431 rajveer 3951 
    if result.success is not None:
2616 chandransh 3952 
      return result.success
3431 rajveer 3953 
    if result.ex is not None:
2616 chandransh 3954 
      raise result.ex
3955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3956 
 
2690 chandransh 3957 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3958 
    """
3959 
    Get all return orders created between the from and to dates for the given warehouse.
3960 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3961 
 
2690 chandransh 3962 
    Parameters:
3963 
     - warehouseId
3964 
     - fromDate
3965 
     - toDate
3966 
    """
3967 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3968 
    return self.recv_getReturnOrders()
2616 chandransh 3969 
 
2690 chandransh 3970 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3971 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3972 
    args = getReturnOrders_args()
3973 
    args.warehouseId = warehouseId
3974 
    args.fromDate = fromDate
3975 
    args.toDate = toDate
3976 
    args.write(self._oprot)
3977 
    self._oprot.writeMessageEnd()
3978 
    self._oprot.trans.flush()
3979 
 
3980 
  def recv_getReturnOrders(self, ):
3981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3982 
    if mtype == TMessageType.EXCEPTION:
3983 
      x = TApplicationException()
3984 
      x.read(self._iprot)
3985 
      self._iprot.readMessageEnd()
3986 
      raise x
3987 
    result = getReturnOrders_result()
3988 
    result.read(self._iprot)
3989 
    self._iprot.readMessageEnd()
3431 rajveer 3990 
    if result.success is not None:
2690 chandransh 3991 
      return result.success
3992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3993 
 
5481 phani.kuma 3994 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3995 
    """
3996 
    Get all return orders created between the from and to dates.
3997 
 
3998 
    Parameters:
3999 
     - onlyNotProcessed
4000 
     - fromDate
4001 
     - toDate
4002 
    """
4003 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4004 
    return self.recv_getAllReturnOrders()
4005 
 
4006 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4007 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4008 
    args = getAllReturnOrders_args()
4009 
    args.onlyNotProcessed = onlyNotProcessed
4010 
    args.fromDate = fromDate
4011 
    args.toDate = toDate
4012 
    args.write(self._oprot)
4013 
    self._oprot.writeMessageEnd()
4014 
    self._oprot.trans.flush()
4015 
 
4016 
  def recv_getAllReturnOrders(self, ):
4017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4018 
    if mtype == TMessageType.EXCEPTION:
4019 
      x = TApplicationException()
4020 
      x.read(self._iprot)
4021 
      self._iprot.readMessageEnd()
4022 
      raise x
4023 
    result = getAllReturnOrders_result()
4024 
    result.read(self._iprot)
4025 
    self._iprot.readMessageEnd()
4026 
    if result.success is not None:
4027 
      return result.success
4028 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4029 
 
2700 chandransh 4030 
  def getReturnOrder(self, id):
4031 
    """
4032 
    Returns the ReturnOrder corresponding to the given id.
4033 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4034 
 
2700 chandransh 4035 
    Parameters:
4036 
     - id
4037 
    """
4038 
    self.send_getReturnOrder(id)
4039 
    return self.recv_getReturnOrder()
4040 
 
4041 
  def send_getReturnOrder(self, id):
4042 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4043 
    args = getReturnOrder_args()
4044 
    args.id = id
4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_getReturnOrder(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = getReturnOrder_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
3431 rajveer 4059 
    if result.success is not None:
2700 chandransh 4060 
      return result.success
3431 rajveer 4061 
    if result.ex is not None:
2700 chandransh 4062 
      raise result.ex
4063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4064 
 
2690 chandransh 4065 
  def processReturn(self, returnOrderId):
4066 
    """
4067 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4068 
 
2690 chandransh 4069 
    Parameters:
4070 
     - returnOrderId
4071 
    """
4072 
    self.send_processReturn(returnOrderId)
4073 
    self.recv_processReturn()
4074 
 
4075 
  def send_processReturn(self, returnOrderId):
4076 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4077 
    args = processReturn_args()
4078 
    args.returnOrderId = returnOrderId
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_processReturn(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = processReturn_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
3431 rajveer 4093 
    if result.ex is not None:
2690 chandransh 4094 
      raise result.ex
4095 
    return
4096 
 
3451 chandransh 4097 
  def updateWeight(self, orderId, weight):
4098 
    """
4099 
    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 4100 
 
3451 chandransh 4101 
    Parameters:
4102 
     - orderId
4103 
     - weight
4104 
    """
4105 
    self.send_updateWeight(orderId, weight)
4106 
    return self.recv_updateWeight()
4107 
 
4108 
  def send_updateWeight(self, orderId, weight):
4109 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4110 
    args = updateWeight_args()
4111 
    args.orderId = orderId
4112 
    args.weight = weight
4113 
    args.write(self._oprot)
4114 
    self._oprot.writeMessageEnd()
4115 
    self._oprot.trans.flush()
4116 
 
4117 
  def recv_updateWeight(self, ):
4118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4119 
    if mtype == TMessageType.EXCEPTION:
4120 
      x = TApplicationException()
4121 
      x.read(self._iprot)
4122 
      self._iprot.readMessageEnd()
4123 
      raise x
4124 
    result = updateWeight_result()
4125 
    result.read(self._iprot)
4126 
    self._iprot.readMessageEnd()
4127 
    if result.success is not None:
4128 
      return result.success
4129 
    if result.ex is not None:
4130 
      raise result.ex
4131 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4132 
 
3469 chandransh 4133 
  def changeItem(self, orderId, itemId):
4134 
    """
4135 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4136 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4137 
 
3469 chandransh 4138 
    Parameters:
4139 
     - orderId
4140 
     - itemId
4141 
    """
4142 
    self.send_changeItem(orderId, itemId)
4143 
    return self.recv_changeItem()
4144 
 
4145 
  def send_changeItem(self, orderId, itemId):
4146 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4147 
    args = changeItem_args()
4148 
    args.orderId = orderId
4149 
    args.itemId = itemId
4150 
    args.write(self._oprot)
4151 
    self._oprot.writeMessageEnd()
4152 
    self._oprot.trans.flush()
4153 
 
4154 
  def recv_changeItem(self, ):
4155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4156 
    if mtype == TMessageType.EXCEPTION:
4157 
      x = TApplicationException()
4158 
      x.read(self._iprot)
4159 
      self._iprot.readMessageEnd()
4160 
      raise x
4161 
    result = changeItem_result()
4162 
    result.read(self._iprot)
4163 
    self._iprot.readMessageEnd()
4164 
    if result.success is not None:
4165 
      return result.success
4166 
    if result.ex is not None:
4167 
      raise result.ex
4168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4169 
 
4170 
  def shiftToWarehouse(self, orderId, warehouseId):
4171 
    """
4172 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4173 
 
4174 
    Parameters:
4175 
     - orderId
4176 
     - warehouseId
4177 
    """
4178 
    self.send_shiftToWarehouse(orderId, warehouseId)
4179 
    return self.recv_shiftToWarehouse()
4180 
 
4181 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4182 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4183 
    args = shiftToWarehouse_args()
4184 
    args.orderId = orderId
4185 
    args.warehouseId = warehouseId
4186 
    args.write(self._oprot)
4187 
    self._oprot.writeMessageEnd()
4188 
    self._oprot.trans.flush()
4189 
 
4190 
  def recv_shiftToWarehouse(self, ):
4191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4192 
    if mtype == TMessageType.EXCEPTION:
4193 
      x = TApplicationException()
4194 
      x.read(self._iprot)
4195 
      self._iprot.readMessageEnd()
4196 
      raise x
4197 
    result = shiftToWarehouse_result()
4198 
    result.read(self._iprot)
4199 
    self._iprot.readMessageEnd()
4200 
    if result.success is not None:
4201 
      return result.success
4202 
    if result.ex is not None:
4203 
      raise result.ex
4204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4205 
 
4647 rajveer 4206 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4207 
    """
4208 
    Adds the given delay reason to the given order.
3986 chandransh 4209 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4210 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4211 
 
3553 chandransh 4212 
    Parameters:
4213 
     - orderId
4214 
     - delayReason
3986 chandransh 4215 
     - furtherDelay
4647 rajveer 4216 
     - delayReasonText
3553 chandransh 4217 
    """
4647 rajveer 4218 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4219 
    return self.recv_addDelayReason()
4220 
 
4647 rajveer 4221 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4222 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4223 
    args = addDelayReason_args()
4224 
    args.orderId = orderId
4225 
    args.delayReason = delayReason
3986 chandransh 4226 
    args.furtherDelay = furtherDelay
4647 rajveer 4227 
    args.delayReasonText = delayReasonText
3553 chandransh 4228 
    args.write(self._oprot)
4229 
    self._oprot.writeMessageEnd()
4230 
    self._oprot.trans.flush()
4231 
 
4232 
  def recv_addDelayReason(self, ):
4233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4234 
    if mtype == TMessageType.EXCEPTION:
4235 
      x = TApplicationException()
4236 
      x.read(self._iprot)
4237 
      self._iprot.readMessageEnd()
4238 
      raise x
4239 
    result = addDelayReason_result()
4240 
    result.read(self._iprot)
4241 
    self._iprot.readMessageEnd()
4242 
    if result.success is not None:
4243 
      return result.success
4244 
    if result.ex is not None:
4245 
      raise result.ex
4246 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4247 
 
3956 chandransh 4248 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4249 
    """
4250 
    Marks the COD orders with given AWB nos. as having been processed.
4251 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4252 
 
3956 chandransh 4253 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4254 
    1. There is no order corresponding to an AWB number.
4255 
    2. The captured amount for a payment exceeds the total payment.
4256 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4257 
 
4258 
    Parameters:
4259 
     - collectedAmountMap
4260 
     - xferBy
4261 
     - xferTxnId
4262 
     - xferDate
4263 
    """
4264 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4265 
    return self.recv_reconcileCodCollection()
4266 
 
4267 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4268 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4269 
    args = reconcileCodCollection_args()
4270 
    args.collectedAmountMap = collectedAmountMap
4271 
    args.xferBy = xferBy
4272 
    args.xferTxnId = xferTxnId
4273 
    args.xferDate = xferDate
4274 
    args.write(self._oprot)
4275 
    self._oprot.writeMessageEnd()
4276 
    self._oprot.trans.flush()
4277 
 
4278 
  def recv_reconcileCodCollection(self, ):
4279 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4280 
    if mtype == TMessageType.EXCEPTION:
4281 
      x = TApplicationException()
4282 
      x.read(self._iprot)
4283 
      self._iprot.readMessageEnd()
4284 
      raise x
4285 
    result = reconcileCodCollection_result()
4286 
    result.read(self._iprot)
4287 
    self._iprot.readMessageEnd()
4288 
    if result.success is not None:
4289 
      return result.success
4290 
    if result.ex is not None:
4291 
      raise result.ex
4292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4293 
 
4008 mandeep.dh 4294 
  def getTransactionsRequiringExtraProcessing(self, category):
4295 
    """
4065 mandeep.dh 4296 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4297 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4298 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4299 
 
4008 mandeep.dh 4300 
    Parameters:
4301 
     - category
4302 
    """
4303 
    self.send_getTransactionsRequiringExtraProcessing(category)
4304 
    return self.recv_getTransactionsRequiringExtraProcessing()
4305 
 
4306 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4307 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4308 
    args = getTransactionsRequiringExtraProcessing_args()
4309 
    args.category = category
4310 
    args.write(self._oprot)
4311 
    self._oprot.writeMessageEnd()
4312 
    self._oprot.trans.flush()
4313 
 
4314 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4316 
    if mtype == TMessageType.EXCEPTION:
4317 
      x = TApplicationException()
4318 
      x.read(self._iprot)
4319 
      self._iprot.readMessageEnd()
4320 
      raise x
4321 
    result = getTransactionsRequiringExtraProcessing_result()
4322 
    result.read(self._iprot)
4323 
    self._iprot.readMessageEnd()
4324 
    if result.success is not None:
4325 
      return result.success
4326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4327 
 
4328 
  def markTransactionAsProcessed(self, transactionId, category):
4329 
    """
4330 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4331 
    It essentially deletes the transaction id record for a particular
4332 
    processing type category (if present) from DB.
4333 
    This is currently used by CRM application.
4008 mandeep.dh 4334 
 
4335 
    Parameters:
4336 
     - transactionId
4337 
     - category
4338 
    """
4339 
    self.send_markTransactionAsProcessed(transactionId, category)
4340 
    self.recv_markTransactionAsProcessed()
4341 
 
4342 
  def send_markTransactionAsProcessed(self, transactionId, category):
4343 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4344 
    args = markTransactionAsProcessed_args()
4345 
    args.transactionId = transactionId
4346 
    args.category = category
4347 
    args.write(self._oprot)
4348 
    self._oprot.writeMessageEnd()
4349 
    self._oprot.trans.flush()
4350 
 
4351 
  def recv_markTransactionAsProcessed(self, ):
4352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4353 
    if mtype == TMessageType.EXCEPTION:
4354 
      x = TApplicationException()
4355 
      x.read(self._iprot)
4356 
      self._iprot.readMessageEnd()
4357 
      raise x
4358 
    result = markTransactionAsProcessed_result()
4359 
    result.read(self._iprot)
4360 
    self._iprot.readMessageEnd()
4361 
    return
4362 
 
4018 chandransh 4363 
  def getItemWiseRiskyOrdersCount(self, ):
4364 
    """
4365 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4366 
    is defined as one whose shipping date is about to expire.
4367 
    """
4368 
    self.send_getItemWiseRiskyOrdersCount()
4369 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4370 
 
4018 chandransh 4371 
  def send_getItemWiseRiskyOrdersCount(self, ):
4372 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4373 
    args = getItemWiseRiskyOrdersCount_args()
4374 
    args.write(self._oprot)
4375 
    self._oprot.writeMessageEnd()
4376 
    self._oprot.trans.flush()
4377 
 
4378 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4380 
    if mtype == TMessageType.EXCEPTION:
4381 
      x = TApplicationException()
4382 
      x.read(self._iprot)
4383 
      self._iprot.readMessageEnd()
4384 
      raise x
4385 
    result = getItemWiseRiskyOrdersCount_result()
4386 
    result.read(self._iprot)
4387 
    self._iprot.readMessageEnd()
4388 
    if result.success is not None:
4389 
      return result.success
4390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4391 
 
4295 varun.gupt 4392 
  def getOrdersForItemIds(self, itemIds):
4393 
    """
4394 
    Returns a list of all orders which have items with given id
4395 
 
4396 
    Parameters:
4397 
     - itemIds
4398 
    """
4399 
    self.send_getOrdersForItemIds(itemIds)
4400 
    return self.recv_getOrdersForItemIds()
4401 
 
4402 
  def send_getOrdersForItemIds(self, itemIds):
4403 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4404 
    args = getOrdersForItemIds_args()
4405 
    args.itemIds = itemIds
4406 
    args.write(self._oprot)
4407 
    self._oprot.writeMessageEnd()
4408 
    self._oprot.trans.flush()
4409 
 
4410 
  def recv_getOrdersForItemIds(self, ):
4411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4412 
    if mtype == TMessageType.EXCEPTION:
4413 
      x = TApplicationException()
4414 
      x.read(self._iprot)
4415 
      self._iprot.readMessageEnd()
4416 
      raise x
4417 
    result = getOrdersForItemIds_result()
4418 
    result.read(self._iprot)
4419 
    self._iprot.readMessageEnd()
4420 
    if result.success is not None:
4421 
      return result.success
4422 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4423 
 
4247 rajveer 4424 
  def markOrderCancellationRequestReceived(self, orderId):
4425 
    """
4426 
    Mark order as cancellation request received. If customer sends request of cancellation of
4427 
    a particular order, this method will be called. It will just change status of the order
4428 
    depending on its current status. It also records the previous status, so that we can move
4429 
    back to that status if cancellation request is denied.
4018 chandransh 4430 
 
4247 rajveer 4431 
    Parameters:
4432 
     - orderId
4433 
    """
4434 
    self.send_markOrderCancellationRequestReceived(orderId)
4435 
    self.recv_markOrderCancellationRequestReceived()
4436 
 
4437 
  def send_markOrderCancellationRequestReceived(self, orderId):
4438 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4439 
    args = markOrderCancellationRequestReceived_args()
4440 
    args.orderId = orderId
4441 
    args.write(self._oprot)
4442 
    self._oprot.writeMessageEnd()
4443 
    self._oprot.trans.flush()
4444 
 
4445 
  def recv_markOrderCancellationRequestReceived(self, ):
4446 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4447 
    if mtype == TMessageType.EXCEPTION:
4448 
      x = TApplicationException()
4449 
      x.read(self._iprot)
4450 
      self._iprot.readMessageEnd()
4451 
      raise x
4452 
    result = markOrderCancellationRequestReceived_result()
4453 
    result.read(self._iprot)
4454 
    self._iprot.readMessageEnd()
4455 
    if result.ex is not None:
4456 
      raise result.ex
4457 
    return
4458 
 
4459 
  def markOrderCancellationRequestConfirmed(self, orderId):
4460 
    """
4461 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4462 
    cancellation request confirmed. After this OM will be able to cancel the order.
4463 
 
4464 
    Parameters:
4465 
     - orderId
4466 
    """
4467 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4468 
    self.recv_markOrderCancellationRequestConfirmed()
4469 
 
4470 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4471 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4472 
    args = markOrderCancellationRequestConfirmed_args()
4473 
    args.orderId = orderId
4474 
    args.write(self._oprot)
4475 
    self._oprot.writeMessageEnd()
4476 
    self._oprot.trans.flush()
4477 
 
4478 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4480 
    if mtype == TMessageType.EXCEPTION:
4481 
      x = TApplicationException()
4482 
      x.read(self._iprot)
4483 
      self._iprot.readMessageEnd()
4484 
      raise x
4485 
    result = markOrderCancellationRequestConfirmed_result()
4486 
    result.read(self._iprot)
4487 
    self._iprot.readMessageEnd()
4488 
    if result.ex is not None:
4489 
      raise result.ex
4490 
    return
4491 
 
4492 
  def markOrderCancellationRequestDenied(self, orderId):
4493 
    """
4494 
    If we decide to not to cancel order, we will move the order ro previous status.
4495 
 
4496 
    Parameters:
4497 
     - orderId
4498 
    """
4499 
    self.send_markOrderCancellationRequestDenied(orderId)
4500 
    self.recv_markOrderCancellationRequestDenied()
4501 
 
4502 
  def send_markOrderCancellationRequestDenied(self, orderId):
4503 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4504 
    args = markOrderCancellationRequestDenied_args()
4505 
    args.orderId = orderId
4506 
    args.write(self._oprot)
4507 
    self._oprot.writeMessageEnd()
4508 
    self._oprot.trans.flush()
4509 
 
4510 
  def recv_markOrderCancellationRequestDenied(self, ):
4511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4512 
    if mtype == TMessageType.EXCEPTION:
4513 
      x = TApplicationException()
4514 
      x.read(self._iprot)
4515 
      self._iprot.readMessageEnd()
4516 
      raise x
4517 
    result = markOrderCancellationRequestDenied_result()
4518 
    result.read(self._iprot)
4519 
    self._iprot.readMessageEnd()
4520 
    if result.ex is not None:
4521 
      raise result.ex
4522 
    return
4523 
 
4258 rajveer 4524 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4525 
    """
4258 rajveer 4526 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4527 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4528 
 
4529 
    Parameters:
4258 rajveer 4530 
     - transactionId
4247 rajveer 4531 
    """
4258 rajveer 4532 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4533 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4534 
 
4258 rajveer 4535 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4536 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4537 
    args = markTransactionAsPaymentFlagRemoved_args()
4538 
    args.transactionId = transactionId
4247 rajveer 4539 
    args.write(self._oprot)
4540 
    self._oprot.writeMessageEnd()
4541 
    self._oprot.trans.flush()
4542 
 
4258 rajveer 4543 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4545 
    if mtype == TMessageType.EXCEPTION:
4546 
      x = TApplicationException()
4547 
      x.read(self._iprot)
4548 
      self._iprot.readMessageEnd()
4549 
      raise x
4258 rajveer 4550 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4551 
    result.read(self._iprot)
4552 
    self._iprot.readMessageEnd()
4553 
    if result.ex is not None:
4554 
      raise result.ex
4555 
    return
4556 
 
4259 anupam.sin 4557 
  def refundTransaction(self, transactionId, refundedBy, reason):
4558 
    """
4559 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4560 
    need to be cancelled
4247 rajveer 4561 
 
4259 anupam.sin 4562 
    Parameters:
4563 
     - transactionId
4564 
     - refundedBy
4565 
     - reason
4566 
    """
4567 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4568 
    self.recv_refundTransaction()
4569 
 
4570 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4571 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4572 
    args = refundTransaction_args()
4573 
    args.transactionId = transactionId
4574 
    args.refundedBy = refundedBy
4575 
    args.reason = reason
4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_refundTransaction(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = refundTransaction_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.ex is not None:
4591 
      raise result.ex
4592 
    return
4593 
 
4324 mandeep.dh 4594 
  def updateShipmentAddress(self, orderId, addressId):
4595 
    """
4596 
    Updates shipment address of an order. Delivery and shipping date estimates
4597 
    etc. are also updated here.
4598 
 
4599 
    Throws TransactionServiceException in case address change is not
4600 
    possible due to certain reasons such as new pincode in address is
4601 
    not serviceable etc.
4602 
 
4603 
    Parameters:
4604 
     - orderId
4605 
     - addressId
4606 
    """
4607 
    self.send_updateShipmentAddress(orderId, addressId)
4608 
    self.recv_updateShipmentAddress()
4609 
 
4610 
  def send_updateShipmentAddress(self, orderId, addressId):
4611 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4612 
    args = updateShipmentAddress_args()
4613 
    args.orderId = orderId
4614 
    args.addressId = addressId
4615 
    args.write(self._oprot)
4616 
    self._oprot.writeMessageEnd()
4617 
    self._oprot.trans.flush()
4618 
 
4619 
  def recv_updateShipmentAddress(self, ):
4620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4621 
    if mtype == TMessageType.EXCEPTION:
4622 
      x = TApplicationException()
4623 
      x.read(self._iprot)
4624 
      self._iprot.readMessageEnd()
4625 
      raise x
4626 
    result = updateShipmentAddress_result()
4627 
    result.read(self._iprot)
4628 
    self._iprot.readMessageEnd()
4629 
    if result.ex is not None:
4630 
      raise result.ex
4631 
    return
4632 
 
4285 rajveer 4633 
  def acceptOrdersForItemId(self, itemId, inventory):
4634 
    """
4635 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4636 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4637 
 
4285 rajveer 4638 
    Parameters:
4639 
     - itemId
4640 
     - inventory
4641 
    """
4642 
    self.send_acceptOrdersForItemId(itemId, inventory)
4643 
    return self.recv_acceptOrdersForItemId()
4644 
 
4645 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4646 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4647 
    args = acceptOrdersForItemId_args()
4648 
    args.itemId = itemId
4649 
    args.inventory = inventory
4650 
    args.write(self._oprot)
4651 
    self._oprot.writeMessageEnd()
4652 
    self._oprot.trans.flush()
4653 
 
4654 
  def recv_acceptOrdersForItemId(self, ):
4655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4656 
    if mtype == TMessageType.EXCEPTION:
4657 
      x = TApplicationException()
4658 
      x.read(self._iprot)
4659 
      self._iprot.readMessageEnd()
4660 
      raise x
4661 
    result = acceptOrdersForItemId_result()
4662 
    result.read(self._iprot)
4663 
    self._iprot.readMessageEnd()
4664 
    if result.success is not None:
4665 
      return result.success
4666 
    if result.ex is not None:
4667 
      raise result.ex
4668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4669 
 
4369 rajveer 4670 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4671 
    """
4672 
    Parameters:
4673 
     - vendorId
4674 
     - itemId
4675 
     - quantity
4676 
     - estimate
4369 rajveer 4677 
     - isReminder
4303 rajveer 4678 
    """
4369 rajveer 4679 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4680 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4681 
 
4369 rajveer 4682 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4683 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4684 
    args = markOrdersAsPORaised_args()
4685 
    args.vendorId = vendorId
4686 
    args.itemId = itemId
4687 
    args.quantity = quantity
4688 
    args.estimate = estimate
4369 rajveer 4689 
    args.isReminder = isReminder
4303 rajveer 4690 
    args.write(self._oprot)
4691 
    self._oprot.writeMessageEnd()
4692 
    self._oprot.trans.flush()
4693 
 
4694 
  def recv_markOrdersAsPORaised(self, ):
4695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4696 
    if mtype == TMessageType.EXCEPTION:
4697 
      x = TApplicationException()
4698 
      x.read(self._iprot)
4699 
      self._iprot.readMessageEnd()
4700 
      raise x
4701 
    result = markOrdersAsPORaised_result()
4702 
    result.read(self._iprot)
4703 
    self._iprot.readMessageEnd()
4704 
    if result.ex is not None:
4705 
      raise result.ex
4706 
    return
4707 
 
4369 rajveer 4708 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4709 
    """
4710 
    Parameters:
4711 
     - vendorId
4712 
     - itemId
4713 
     - quantity
4714 
     - estimate
4369 rajveer 4715 
     - isReminder
4303 rajveer 4716 
    """
4369 rajveer 4717 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4718 
    self.recv_markOrdersAsReversalInitiated()
4719 
 
4369 rajveer 4720 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4721 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4722 
    args = markOrdersAsReversalInitiated_args()
4723 
    args.vendorId = vendorId
4724 
    args.itemId = itemId
4725 
    args.quantity = quantity
4726 
    args.estimate = estimate
4369 rajveer 4727 
    args.isReminder = isReminder
4303 rajveer 4728 
    args.write(self._oprot)
4729 
    self._oprot.writeMessageEnd()
4730 
    self._oprot.trans.flush()
4731 
 
4732 
  def recv_markOrdersAsReversalInitiated(self, ):
4733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4734 
    if mtype == TMessageType.EXCEPTION:
4735 
      x = TApplicationException()
4736 
      x.read(self._iprot)
4737 
      self._iprot.readMessageEnd()
4738 
      raise x
4739 
    result = markOrdersAsReversalInitiated_result()
4740 
    result.read(self._iprot)
4741 
    self._iprot.readMessageEnd()
4742 
    if result.ex is not None:
4743 
      raise result.ex
4744 
    return
4745 
 
4369 rajveer 4746 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4747 
    """
4748 
    Parameters:
4749 
     - vendorId
4750 
     - itemId
4751 
     - quantity
4752 
     - estimate
4369 rajveer 4753 
     - isReminder
4303 rajveer 4754 
    """
4369 rajveer 4755 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4756 
    self.recv_markOrdersAsNotAvailabke()
4757 
 
4369 rajveer 4758 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4759 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4760 
    args = markOrdersAsNotAvailabke_args()
4761 
    args.vendorId = vendorId
4762 
    args.itemId = itemId
4763 
    args.quantity = quantity
4764 
    args.estimate = estimate
4369 rajveer 4765 
    args.isReminder = isReminder
4303 rajveer 4766 
    args.write(self._oprot)
4767 
    self._oprot.writeMessageEnd()
4768 
    self._oprot.trans.flush()
4769 
 
4770 
  def recv_markOrdersAsNotAvailabke(self, ):
4771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4772 
    if mtype == TMessageType.EXCEPTION:
4773 
      x = TApplicationException()
4774 
      x.read(self._iprot)
4775 
      self._iprot.readMessageEnd()
4776 
      raise x
4777 
    result = markOrdersAsNotAvailabke_result()
4778 
    result.read(self._iprot)
4779 
    self._iprot.readMessageEnd()
4780 
    if result.ex is not None:
4781 
      raise result.ex
4782 
    return
4783 
 
4369 rajveer 4784 
  def markOrdersAsTimeout(self, vendorId):
4785 
    """
4786 
    Parameters:
4787 
     - vendorId
4788 
    """
4789 
    self.send_markOrdersAsTimeout(vendorId)
4790 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4791 
 
4369 rajveer 4792 
  def send_markOrdersAsTimeout(self, vendorId):
4793 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4794 
    args = markOrdersAsTimeout_args()
4795 
    args.vendorId = vendorId
4796 
    args.write(self._oprot)
4797 
    self._oprot.writeMessageEnd()
4798 
    self._oprot.trans.flush()
4799 
 
4800 
  def recv_markOrdersAsTimeout(self, ):
4801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4802 
    if mtype == TMessageType.EXCEPTION:
4803 
      x = TApplicationException()
4804 
      x.read(self._iprot)
4805 
      self._iprot.readMessageEnd()
4806 
      raise x
4807 
    result = markOrdersAsTimeout_result()
4808 
    result.read(self._iprot)
4809 
    self._iprot.readMessageEnd()
4810 
    if result.success is not None:
4811 
      return result.success
4812 
    if result.ex is not None:
4813 
      raise result.ex
4814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4815 
 
4662 rajveer 4816 
  def markOrderAsLostInTransit(self, orderId):
4817 
    """
4818 
    Mark order as LOST_IN_TRANSIT
4819 
 
4820 
    Parameters:
4821 
     - orderId
4822 
    """
4823 
    self.send_markOrderAsLostInTransit(orderId)
4824 
    return self.recv_markOrderAsLostInTransit()
4825 
 
4826 
  def send_markOrderAsLostInTransit(self, orderId):
4827 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4828 
    args = markOrderAsLostInTransit_args()
4829 
    args.orderId = orderId
4830 
    args.write(self._oprot)
4831 
    self._oprot.writeMessageEnd()
4832 
    self._oprot.trans.flush()
4833 
 
4834 
  def recv_markOrderAsLostInTransit(self, ):
4835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4836 
    if mtype == TMessageType.EXCEPTION:
4837 
      x = TApplicationException()
4838 
      x.read(self._iprot)
4839 
      self._iprot.readMessageEnd()
4840 
      raise x
4841 
    result = markOrderAsLostInTransit_result()
4842 
    result.read(self._iprot)
4843 
    self._iprot.readMessageEnd()
4844 
    if result.success is not None:
4845 
      return result.success
4846 
    if result.ex is not None:
4847 
      raise result.ex
4848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4849 
 
4386 anupam.sin 4850 
  def getOrderForAwb(self, awb):
4851 
    """
4852 
    Returns the order corresponding to an AWB number
4369 rajveer 4853 
 
4386 anupam.sin 4854 
    Parameters:
4855 
     - awb
4856 
    """
4857 
    self.send_getOrderForAwb(awb)
4858 
    return self.recv_getOrderForAwb()
4859 
 
4860 
  def send_getOrderForAwb(self, awb):
4861 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4862 
    args = getOrderForAwb_args()
4863 
    args.awb = awb
4864 
    args.write(self._oprot)
4865 
    self._oprot.writeMessageEnd()
4866 
    self._oprot.trans.flush()
4867 
 
4868 
  def recv_getOrderForAwb(self, ):
4869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4870 
    if mtype == TMessageType.EXCEPTION:
4871 
      x = TApplicationException()
4872 
      x.read(self._iprot)
4873 
      self._iprot.readMessageEnd()
4874 
      raise x
4875 
    result = getOrderForAwb_result()
4876 
    result.read(self._iprot)
4877 
    self._iprot.readMessageEnd()
4878 
    if result.success is not None:
4879 
      return result.success
4880 
    if result.ex is not None:
4881 
      raise result.ex
4882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4883 
 
4910 phani.kuma 4884 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4885 
    """
4910 phani.kuma 4886 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4887 
 
4506 phani.kuma 4888 
    Parameters:
4889 
     - logistics_provider_id
4910 phani.kuma 4890 
     - order_status_list
4506 phani.kuma 4891 
    """
4910 phani.kuma 4892 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4893 
    return self.recv_getOrdersForProviderForStatus()
4894 
 
4910 phani.kuma 4895 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4896 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4897 
    args = getOrdersForProviderForStatus_args()
4898 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4899 
    args.order_status_list = order_status_list
4506 phani.kuma 4900 
    args.write(self._oprot)
4901 
    self._oprot.writeMessageEnd()
4902 
    self._oprot.trans.flush()
4903 
 
4904 
  def recv_getOrdersForProviderForStatus(self, ):
4905 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4906 
    if mtype == TMessageType.EXCEPTION:
4907 
      x = TApplicationException()
4908 
      x.read(self._iprot)
4909 
      self._iprot.readMessageEnd()
4910 
      raise x
4911 
    result = getOrdersForProviderForStatus_result()
4912 
    result.read(self._iprot)
4913 
    self._iprot.readMessageEnd()
4914 
    if result.success is not None:
4915 
      return result.success
4916 
    if result.ex is not None:
4917 
      raise result.ex
4918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4919 
 
4600 varun.gupt 4920 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4921 
    """
4922 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4923 
 
4600 varun.gupt 4924 
    Parameters:
4925 
     - vendorId
4926 
     - billingDateFrom
4927 
     - billingDateTo
4928 
    """
4929 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4930 
    return self.recv_getBilledOrdersForVendor()
4931 
 
4932 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4933 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4934 
    args = getBilledOrdersForVendor_args()
4935 
    args.vendorId = vendorId
4936 
    args.billingDateFrom = billingDateFrom
4937 
    args.billingDateTo = billingDateTo
4938 
    args.write(self._oprot)
4939 
    self._oprot.writeMessageEnd()
4940 
    self._oprot.trans.flush()
4941 
 
4942 
  def recv_getBilledOrdersForVendor(self, ):
4943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4944 
    if mtype == TMessageType.EXCEPTION:
4945 
      x = TApplicationException()
4946 
      x.read(self._iprot)
4947 
      self._iprot.readMessageEnd()
4948 
      raise x
4949 
    result = getBilledOrdersForVendor_result()
4950 
    result.read(self._iprot)
4951 
    self._iprot.readMessageEnd()
4952 
    if result.success is not None:
4953 
      return result.success
4954 
    if result.ex is not None:
4955 
      raise result.ex
4956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4957 
 
4607 rajveer 4958 
  def getSlippedSippingDateOrders(self, ):
4959 
    self.send_getSlippedSippingDateOrders()
4960 
    return self.recv_getSlippedSippingDateOrders()
4961 
 
4962 
  def send_getSlippedSippingDateOrders(self, ):
4963 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4964 
    args = getSlippedSippingDateOrders_args()
4965 
    args.write(self._oprot)
4966 
    self._oprot.writeMessageEnd()
4967 
    self._oprot.trans.flush()
4968 
 
4969 
  def recv_getSlippedSippingDateOrders(self, ):
4970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4971 
    if mtype == TMessageType.EXCEPTION:
4972 
      x = TApplicationException()
4973 
      x.read(self._iprot)
4974 
      self._iprot.readMessageEnd()
4975 
      raise x
4976 
    result = getSlippedSippingDateOrders_result()
4977 
    result.read(self._iprot)
4978 
    self._iprot.readMessageEnd()
4979 
    if result.success is not None:
4980 
      return result.success
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4984 
 
4709 rajveer 4985 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4986 
    """
4987 
    Parameters:
4988 
     - cancelDateFrom
4989 
     - cancelDateTo
4990 
    """
4991 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4992 
    return self.recv_getCancelledOrders()
4993 
 
4994 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4995 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4996 
    args = getCancelledOrders_args()
4997 
    args.cancelDateFrom = cancelDateFrom
4998 
    args.cancelDateTo = cancelDateTo
4999 
    args.write(self._oprot)
5000 
    self._oprot.writeMessageEnd()
5001 
    self._oprot.trans.flush()
5002 
 
5003 
  def recv_getCancelledOrders(self, ):
5004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5005 
    if mtype == TMessageType.EXCEPTION:
5006 
      x = TApplicationException()
5007 
      x.read(self._iprot)
5008 
      self._iprot.readMessageEnd()
5009 
      raise x
5010 
    result = getCancelledOrders_result()
5011 
    result.read(self._iprot)
5012 
    self._iprot.readMessageEnd()
5013 
    if result.success is not None:
5014 
      return result.success
5015 
    if result.ex is not None:
5016 
      raise result.ex
5017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5018 
 
4600 varun.gupt 5019 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5020 
    """
5021 
    Parameters:
5022 
     - mapAWBAndAmount
5023 
    """
5024 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5025 
    self.recv_saveBluedartSettlements()
5026 
 
5027 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5028 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5029 
    args = saveBluedartSettlements_args()
5030 
    args.mapAWBAndAmount = mapAWBAndAmount
5031 
    args.write(self._oprot)
5032 
    self._oprot.writeMessageEnd()
5033 
    self._oprot.trans.flush()
5034 
 
5035 
  def recv_saveBluedartSettlements(self, ):
5036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5037 
    if mtype == TMessageType.EXCEPTION:
5038 
      x = TApplicationException()
5039 
      x.read(self._iprot)
5040 
      self._iprot.readMessageEnd()
5041 
      raise x
5042 
    result = saveBluedartSettlements_result()
5043 
    result.read(self._iprot)
5044 
    self._iprot.readMessageEnd()
5045 
    if result.ex is not None:
5046 
      raise result.ex
5047 
    return
5048 
 
4905 varun.gupt 5049 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5050 
    """
5051 
    Parameters:
5052 
     - settlementDate
5053 
     - paymentGatewayId
4905 varun.gupt 5054 
     - referenceId
4600 varun.gupt 5055 
     - serviceTax
5056 
     - otherCharges
5057 
     - netCollection
5058 
    """
4905 varun.gupt 5059 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5060 
    self.recv_savePaymentSettlements()
5061 
 
4905 varun.gupt 5062 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5063 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5064 
    args = savePaymentSettlements_args()
5065 
    args.settlementDate = settlementDate
5066 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5067 
    args.referenceId = referenceId
4600 varun.gupt 5068 
    args.serviceTax = serviceTax
5069 
    args.otherCharges = otherCharges
5070 
    args.netCollection = netCollection
5071 
    args.write(self._oprot)
5072 
    self._oprot.writeMessageEnd()
5073 
    self._oprot.trans.flush()
5074 
 
5075 
  def recv_savePaymentSettlements(self, ):
5076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5077 
    if mtype == TMessageType.EXCEPTION:
5078 
      x = TApplicationException()
5079 
      x.read(self._iprot)
5080 
      self._iprot.readMessageEnd()
5081 
      raise x
5082 
    result = savePaymentSettlements_result()
5083 
    result.read(self._iprot)
5084 
    self._iprot.readMessageEnd()
5085 
    if result.ex is not None:
5086 
      raise result.ex
5087 
    return
5088 
 
5089 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5090 
    """
5091 
    Parameters:
5092 
     - settlementId
5093 
     - settlementDate
5094 
     - transactionDateFrom
5095 
     - transactionDateTo
5096 
     - amount
5097 
    """
5098 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5099 
    self.recv_saveEBSSettlementSummary()
5100 
 
5101 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5102 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5103 
    args = saveEBSSettlementSummary_args()
5104 
    args.settlementId = settlementId
5105 
    args.settlementDate = settlementDate
5106 
    args.transactionDateFrom = transactionDateFrom
5107 
    args.transactionDateTo = transactionDateTo
5108 
    args.amount = amount
5109 
    args.write(self._oprot)
5110 
    self._oprot.writeMessageEnd()
5111 
    self._oprot.trans.flush()
5112 
 
5113 
  def recv_saveEBSSettlementSummary(self, ):
5114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5115 
    if mtype == TMessageType.EXCEPTION:
5116 
      x = TApplicationException()
5117 
      x.read(self._iprot)
5118 
      self._iprot.readMessageEnd()
5119 
      raise x
5120 
    result = saveEBSSettlementSummary_result()
5121 
    result.read(self._iprot)
5122 
    self._iprot.readMessageEnd()
5123 
    if result.ex is not None:
5124 
      raise result.ex
5125 
    return
5126 
 
5386 phani.kuma 5127 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5128 
    """
5129 
    Parameters:
5189 varun.gupt 5130 
     - referenceId
5131 
     - isRefund
4600 varun.gupt 5132 
    """
5386 phani.kuma 5133 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5134 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5135 
 
5386 phani.kuma 5136 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5137 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5138 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5139 
    args.referenceId = referenceId
5140 
    args.isRefund = isRefund
4600 varun.gupt 5141 
    args.write(self._oprot)
5142 
    self._oprot.writeMessageEnd()
5143 
    self._oprot.trans.flush()
5144 
 
5386 phani.kuma 5145 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5147 
    if mtype == TMessageType.EXCEPTION:
5148 
      x = TApplicationException()
5149 
      x.read(self._iprot)
5150 
      self._iprot.readMessageEnd()
5151 
      raise x
5386 phani.kuma 5152 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5153 
    result.read(self._iprot)
5154 
    self._iprot.readMessageEnd()
5155 
    if result.success is not None:
5156 
      return result.success
5157 
    if result.ex is not None:
5158 
      raise result.ex
5386 phani.kuma 5159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5160 
 
5386 phani.kuma 5161 
  def getSettlementForCod(self, orderId, isRefund):
5162 
    """
5163 
    Parameters:
5164 
     - orderId
5165 
     - isRefund
5166 
    """
5167 
    self.send_getSettlementForCod(orderId, isRefund)
5168 
    return self.recv_getSettlementForCod()
5169 
 
5170 
  def send_getSettlementForCod(self, orderId, isRefund):
5171 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5172 
    args = getSettlementForCod_args()
5173 
    args.orderId = orderId
5174 
    args.isRefund = isRefund
5175 
    args.write(self._oprot)
5176 
    self._oprot.writeMessageEnd()
5177 
    self._oprot.trans.flush()
5178 
 
5179 
  def recv_getSettlementForCod(self, ):
5180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5181 
    if mtype == TMessageType.EXCEPTION:
5182 
      x = TApplicationException()
5183 
      x.read(self._iprot)
5184 
      self._iprot.readMessageEnd()
5185 
      raise x
5186 
    result = getSettlementForCod_result()
5187 
    result.read(self._iprot)
5188 
    self._iprot.readMessageEnd()
5189 
    if result.success is not None:
5190 
      return result.success
5191 
    if result.ex is not None:
5192 
      raise result.ex
5193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5194 
 
4600 varun.gupt 5195 
  def getEBSSettlementSummaries(self, ):
5196 
    self.send_getEBSSettlementSummaries()
5197 
    return self.recv_getEBSSettlementSummaries()
5198 
 
5199 
  def send_getEBSSettlementSummaries(self, ):
5200 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5201 
    args = getEBSSettlementSummaries_args()
5202 
    args.write(self._oprot)
5203 
    self._oprot.writeMessageEnd()
5204 
    self._oprot.trans.flush()
5205 
 
5206 
  def recv_getEBSSettlementSummaries(self, ):
5207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5208 
    if mtype == TMessageType.EXCEPTION:
5209 
      x = TApplicationException()
5210 
      x.read(self._iprot)
5211 
      self._iprot.readMessageEnd()
5212 
      raise x
5213 
    result = getEBSSettlementSummaries_result()
5214 
    result.read(self._iprot)
5215 
    self._iprot.readMessageEnd()
5216 
    if result.success is not None:
5217 
      return result.success
5218 
    if result.ex is not None:
5219 
      raise result.ex
5220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5221 
 
5222 
  def markEBSSettlementUploaded(self, settlementId):
5223 
    """
5224 
    Parameters:
5225 
     - settlementId
5226 
    """
5227 
    self.send_markEBSSettlementUploaded(settlementId)
5228 
    self.recv_markEBSSettlementUploaded()
5229 
 
5230 
  def send_markEBSSettlementUploaded(self, settlementId):
5231 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5232 
    args = markEBSSettlementUploaded_args()
5233 
    args.settlementId = settlementId
5234 
    args.write(self._oprot)
5235 
    self._oprot.writeMessageEnd()
5236 
    self._oprot.trans.flush()
5237 
 
5238 
  def recv_markEBSSettlementUploaded(self, ):
5239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5240 
    if mtype == TMessageType.EXCEPTION:
5241 
      x = TApplicationException()
5242 
      x.read(self._iprot)
5243 
      self._iprot.readMessageEnd()
5244 
      raise x
5245 
    result = markEBSSettlementUploaded_result()
5246 
    result.read(self._iprot)
5247 
    self._iprot.readMessageEnd()
5248 
    if result.ex is not None:
5249 
      raise result.ex
5250 
    return
5251 
 
5252 
  def getEBSSettlementDate(self, settlementId):
5253 
    """
5254 
    Parameters:
5255 
     - settlementId
5256 
    """
5257 
    self.send_getEBSSettlementDate(settlementId)
5258 
    return self.recv_getEBSSettlementDate()
5259 
 
5260 
  def send_getEBSSettlementDate(self, settlementId):
5261 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5262 
    args = getEBSSettlementDate_args()
5263 
    args.settlementId = settlementId
5264 
    args.write(self._oprot)
5265 
    self._oprot.writeMessageEnd()
5266 
    self._oprot.trans.flush()
5267 
 
5268 
  def recv_getEBSSettlementDate(self, ):
5269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5270 
    if mtype == TMessageType.EXCEPTION:
5271 
      x = TApplicationException()
5272 
      x.read(self._iprot)
5273 
      self._iprot.readMessageEnd()
5274 
      raise x
5275 
    result = getEBSSettlementDate_result()
5276 
    result.read(self._iprot)
5277 
    self._iprot.readMessageEnd()
5278 
    if result.success is not None:
5279 
      return result.success
5280 
    if result.ex is not None:
5281 
      raise result.ex
5282 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5283 
 
4715 varun.gupt 5284 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5285 
    """
5286 
    Parameters:
5287 
     - settlementDateFrom
5288 
     - settlementDateTo
5289 
     - isRefund
5290 
    """
5291 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5292 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5293 
 
4715 varun.gupt 5294 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5295 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5296 
    args = getSettlementsByDate_args()
5297 
    args.settlementDateFrom = settlementDateFrom
5298 
    args.settlementDateTo = settlementDateTo
5299 
    args.isRefund = isRefund
5300 
    args.write(self._oprot)
5301 
    self._oprot.writeMessageEnd()
5302 
    self._oprot.trans.flush()
5303 
 
5304 
  def recv_getSettlementsByDate(self, ):
5305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5306 
    if mtype == TMessageType.EXCEPTION:
5307 
      x = TApplicationException()
5308 
      x.read(self._iprot)
5309 
      self._iprot.readMessageEnd()
5310 
      raise x
5311 
    result = getSettlementsByDate_result()
5312 
    result.read(self._iprot)
5313 
    self._iprot.readMessageEnd()
5314 
    if result.success is not None:
5315 
      return result.success
5316 
    if result.ex is not None:
5317 
      raise result.ex
5318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5319 
 
5320 
  def getReshippedOrderIds(self, orderIds):
5321 
    """
5322 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5323 
 
5324 
    Parameters:
5325 
     - orderIds
5326 
    """
5327 
    self.send_getReshippedOrderIds(orderIds)
5328 
    return self.recv_getReshippedOrderIds()
5329 
 
5330 
  def send_getReshippedOrderIds(self, orderIds):
5331 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5332 
    args = getReshippedOrderIds_args()
5333 
    args.orderIds = orderIds
5334 
    args.write(self._oprot)
5335 
    self._oprot.writeMessageEnd()
5336 
    self._oprot.trans.flush()
5337 
 
5338 
  def recv_getReshippedOrderIds(self, ):
5339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5340 
    if mtype == TMessageType.EXCEPTION:
5341 
      x = TApplicationException()
5342 
      x.read(self._iprot)
5343 
      self._iprot.readMessageEnd()
5344 
      raise x
5345 
    result = getReshippedOrderIds_result()
5346 
    result.read(self._iprot)
5347 
    self._iprot.readMessageEnd()
5348 
    if result.success is not None:
5349 
      return result.success
5350 
    if result.ex is not None:
5351 
      raise result.ex
5352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5353 
 
5481 phani.kuma 5354 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5355 
    """
5356 
    Parameters:
5357 
     - vendorId
5481 phani.kuma 5358 
     - onlyVendorNotPaid
5359 
     - billingDateFrom
5360 
     - billingDateTo
4875 varun.gupt 5361 
    """
5481 phani.kuma 5362 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5363 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5364 
 
5481 phani.kuma 5365 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5366 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5367 
    args = getBilledOrders_args()
4875 varun.gupt 5368 
    args.vendorId = vendorId
5481 phani.kuma 5369 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5370 
    args.billingDateFrom = billingDateFrom
5371 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5372 
    args.write(self._oprot)
5373 
    self._oprot.writeMessageEnd()
5374 
    self._oprot.trans.flush()
5375 
 
5481 phani.kuma 5376 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5378 
    if mtype == TMessageType.EXCEPTION:
5379 
      x = TApplicationException()
5380 
      x.read(self._iprot)
5381 
      self._iprot.readMessageEnd()
5382 
      raise x
5481 phani.kuma 5383 
    result = getBilledOrders_result()
4875 varun.gupt 5384 
    result.read(self._iprot)
5385 
    self._iprot.readMessageEnd()
5386 
    if result.success is not None:
5387 
      return result.success
5388 
    if result.ex is not None:
5389 
      raise result.ex
5481 phani.kuma 5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5391 
 
5031 varun.gupt 5392 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5393 
    """
5394 
    Parameters:
5395 
     - startDate
5396 
     - endDate
5397 
    """
5398 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5399 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5400 
 
5031 varun.gupt 5401 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5402 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5403 
    args = getStatusDistributionOfOrders_args()
5404 
    args.startDate = startDate
5405 
    args.endDate = endDate
5406 
    args.write(self._oprot)
5407 
    self._oprot.writeMessageEnd()
5408 
    self._oprot.trans.flush()
5409 
 
5410 
  def recv_getStatusDistributionOfOrders(self, ):
5411 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5412 
    if mtype == TMessageType.EXCEPTION:
5413 
      x = TApplicationException()
5414 
      x.read(self._iprot)
5415 
      self._iprot.readMessageEnd()
5416 
      raise x
5417 
    result = getStatusDistributionOfOrders_result()
5418 
    result.read(self._iprot)
5419 
    self._iprot.readMessageEnd()
5420 
    if result.success is not None:
5421 
      return result.success
5422 
    if result.ex is not None:
5423 
      raise result.ex
5424 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5425 
 
5067 varun.gupt 5426 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5427 
    """
5428 
    Parameters:
5429 
     - status
5430 
     - startDatetime
5431 
     - endDatetime
5432 
    """
5433 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5434 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5435 
 
5067 varun.gupt 5436 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5437 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5438 
    args = getOrderIdsForStatus_args()
5439 
    args.status = status
5440 
    args.startDatetime = startDatetime
5441 
    args.endDatetime = endDatetime
5442 
    args.write(self._oprot)
5443 
    self._oprot.writeMessageEnd()
5444 
    self._oprot.trans.flush()
5445 
 
5446 
  def recv_getOrderIdsForStatus(self, ):
5447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5448 
    if mtype == TMessageType.EXCEPTION:
5449 
      x = TApplicationException()
5450 
      x.read(self._iprot)
5451 
      self._iprot.readMessageEnd()
5452 
      raise x
5453 
    result = getOrderIdsForStatus_result()
5454 
    result.read(self._iprot)
5455 
    self._iprot.readMessageEnd()
5456 
    if result.success is not None:
5457 
      return result.success
5458 
    if result.ex is not None:
5459 
      raise result.ex
5460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5461 
 
5348 anupam.sin 5462 
  def updateCODAgent(self, agent, orderId):
5463 
    """
5464 
    Updates the agent who handled the COD verification call
5465 
 
5466 
    Parameters:
5467 
     - agent
5468 
     - orderId
5469 
    """
5470 
    self.send_updateCODAgent(agent, orderId)
5471 
    self.recv_updateCODAgent()
5472 
 
5473 
  def send_updateCODAgent(self, agent, orderId):
5474 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5475 
    args = updateCODAgent_args()
5476 
    args.agent = agent
5477 
    args.orderId = orderId
5478 
    args.write(self._oprot)
5479 
    self._oprot.writeMessageEnd()
5480 
    self._oprot.trans.flush()
5481 
 
5482 
  def recv_updateCODAgent(self, ):
5483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5484 
    if mtype == TMessageType.EXCEPTION:
5485 
      x = TApplicationException()
5486 
      x.read(self._iprot)
5487 
      self._iprot.readMessageEnd()
5488 
      raise x
5489 
    result = updateCODAgent_result()
5490 
    result.read(self._iprot)
5491 
    self._iprot.readMessageEnd()
5492 
    if result.ex is not None:
5493 
      raise result.ex
5494 
    return
5495 
 
5099 varun.gupt 5496 
  def updateOrderAsPaidToVendor(self, orderId):
5497 
    """
5498 
    Parameters:
5499 
     - orderId
5500 
    """
5501 
    self.send_updateOrderAsPaidToVendor(orderId)
5502 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5503 
 
5099 varun.gupt 5504 
  def send_updateOrderAsPaidToVendor(self, orderId):
5505 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5506 
    args = updateOrderAsPaidToVendor_args()
5507 
    args.orderId = orderId
5508 
    args.write(self._oprot)
5509 
    self._oprot.writeMessageEnd()
5510 
    self._oprot.trans.flush()
5511 
 
5512 
  def recv_updateOrderAsPaidToVendor(self, ):
5513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5514 
    if mtype == TMessageType.EXCEPTION:
5515 
      x = TApplicationException()
5516 
      x.read(self._iprot)
5517 
      self._iprot.readMessageEnd()
5518 
      raise x
5519 
    result = updateOrderAsPaidToVendor_result()
5520 
    result.read(self._iprot)
5521 
    self._iprot.readMessageEnd()
5522 
    if result.ex is not None:
5523 
      raise result.ex
5524 
    return
5525 
 
5386 phani.kuma 5526 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5527 
    """
5528 
    Parameters:
5529 
     - orderId
5530 
    """
5531 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5532 
    self.recv_updateOrderOnlyAsPaidToVendor()
5533 
 
5534 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5535 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5536 
    args = updateOrderOnlyAsPaidToVendor_args()
5537 
    args.orderId = orderId
5538 
    args.write(self._oprot)
5539 
    self._oprot.writeMessageEnd()
5540 
    self._oprot.trans.flush()
5541 
 
5542 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5544 
    if mtype == TMessageType.EXCEPTION:
5545 
      x = TApplicationException()
5546 
      x.read(self._iprot)
5547 
      self._iprot.readMessageEnd()
5548 
      raise x
5549 
    result = updateOrderOnlyAsPaidToVendor_result()
5550 
    result.read(self._iprot)
5551 
    self._iprot.readMessageEnd()
5552 
    if result.ex is not None:
5553 
      raise result.ex
5554 
    return
5555 
 
5208 varun.gupt 5556 
  def getRefundedOrdersMarkedPaid(self, ):
5557 
    self.send_getRefundedOrdersMarkedPaid()
5558 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5559 
 
5208 varun.gupt 5560 
  def send_getRefundedOrdersMarkedPaid(self, ):
5561 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5562 
    args = getRefundedOrdersMarkedPaid_args()
5563 
    args.write(self._oprot)
5564 
    self._oprot.writeMessageEnd()
5565 
    self._oprot.trans.flush()
5566 
 
5567 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5569 
    if mtype == TMessageType.EXCEPTION:
5570 
      x = TApplicationException()
5571 
      x.read(self._iprot)
5572 
      self._iprot.readMessageEnd()
5573 
      raise x
5574 
    result = getRefundedOrdersMarkedPaid_result()
5575 
    result.read(self._iprot)
5576 
    self._iprot.readMessageEnd()
5577 
    if result.success is not None:
5578 
      return result.success
5579 
    if result.ex is not None:
5580 
      raise result.ex
5581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5582 
 
5447 anupam.sin 5583 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5584 
    """
5585 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5586 
 
5447 anupam.sin 5587 
 
5588 
    Parameters:
5589 
     - minOrderId
5590 
     - maxOrderId
5591 
    """
5592 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5593 
    return self.recv_getAllVerificationAgents()
5594 
 
5595 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5596 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5597 
    args = getAllVerificationAgents_args()
5598 
    args.minOrderId = minOrderId
5599 
    args.maxOrderId = maxOrderId
5600 
    args.write(self._oprot)
5601 
    self._oprot.writeMessageEnd()
5602 
    self._oprot.trans.flush()
5603 
 
5604 
  def recv_getAllVerificationAgents(self, ):
5605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5606 
    if mtype == TMessageType.EXCEPTION:
5607 
      x = TApplicationException()
5608 
      x.read(self._iprot)
5609 
      self._iprot.readMessageEnd()
5610 
      raise x
5611 
    result = getAllVerificationAgents_result()
5612 
    result.read(self._iprot)
5613 
    self._iprot.readMessageEnd()
5614 
    if result.success is not None:
5615 
      return result.success
5616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5617 
 
5527 anupam.sin 5618 
  def getAllAttributesForOrderId(self, orderId):
5619 
    """
5620 
    gets all attributes for a given orderId
5447 anupam.sin 5621 
 
5527 anupam.sin 5622 
    Parameters:
5623 
     - orderId
5624 
    """
5625 
    self.send_getAllAttributesForOrderId(orderId)
5626 
    return self.recv_getAllAttributesForOrderId()
5627 
 
5628 
  def send_getAllAttributesForOrderId(self, orderId):
5629 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5630 
    args = getAllAttributesForOrderId_args()
5631 
    args.orderId = orderId
5632 
    args.write(self._oprot)
5633 
    self._oprot.writeMessageEnd()
5634 
    self._oprot.trans.flush()
5635 
 
5636 
  def recv_getAllAttributesForOrderId(self, ):
5637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5638 
    if mtype == TMessageType.EXCEPTION:
5639 
      x = TApplicationException()
5640 
      x.read(self._iprot)
5641 
      self._iprot.readMessageEnd()
5642 
      raise x
5643 
    result = getAllAttributesForOrderId_result()
5644 
    result.read(self._iprot)
5645 
    self._iprot.readMessageEnd()
5646 
    if result.success is not None:
5647 
      return result.success
5648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5649 
 
5676 rajveer 5650 
  def setOrderAttributes(self, orderId, attributes):
5651 
    """
5652 
    sets attributes for an order
5653 
 
5654 
    Parameters:
5655 
     - orderId
5656 
     - attributes
5657 
    """
5658 
    self.send_setOrderAttributes(orderId, attributes)
5659 
    self.recv_setOrderAttributes()
5660 
 
5661 
  def send_setOrderAttributes(self, orderId, attributes):
5662 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5663 
    args = setOrderAttributes_args()
5664 
    args.orderId = orderId
5665 
    args.attributes = attributes
5666 
    args.write(self._oprot)
5667 
    self._oprot.writeMessageEnd()
5668 
    self._oprot.trans.flush()
5669 
 
5670 
  def recv_setOrderAttributes(self, ):
5671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5672 
    if mtype == TMessageType.EXCEPTION:
5673 
      x = TApplicationException()
5674 
      x.read(self._iprot)
5675 
      self._iprot.readMessageEnd()
5676 
      raise x
5677 
    result = setOrderAttributes_result()
5678 
    result.read(self._iprot)
5679 
    self._iprot.readMessageEnd()
5680 
    return
5681 
 
5527 anupam.sin 5682 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5683 
    """
5684 
    sets attributes for all orders in a transaction
5685 
 
5686 
    Parameters:
5687 
     - transactionId
5688 
     - attribute
5689 
    """
5690 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5691 
    self.recv_setOrderAttributeForTransaction()
5692 
 
5693 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5694 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5695 
    args = setOrderAttributeForTransaction_args()
5696 
    args.transactionId = transactionId
5697 
    args.attribute = attribute
5698 
    args.write(self._oprot)
5699 
    self._oprot.writeMessageEnd()
5700 
    self._oprot.trans.flush()
5701 
 
5702 
  def recv_setOrderAttributeForTransaction(self, ):
5703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5704 
    if mtype == TMessageType.EXCEPTION:
5705 
      x = TApplicationException()
5706 
      x.read(self._iprot)
5707 
      self._iprot.readMessageEnd()
5708 
      raise x
5709 
    result = setOrderAttributeForTransaction_result()
5710 
    result.read(self._iprot)
5711 
    self._iprot.readMessageEnd()
5712 
    return
5713 
 
5553 rajveer 5714 
  def getReceivePendingOrders(self, storeId):
5715 
    """
5716 
    Parameters:
5717 
     - storeId
5718 
    """
5719 
    self.send_getReceivePendingOrders(storeId)
5720 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5721 
 
5553 rajveer 5722 
  def send_getReceivePendingOrders(self, storeId):
5723 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5724 
    args = getReceivePendingOrders_args()
5725 
    args.storeId = storeId
5726 
    args.write(self._oprot)
5727 
    self._oprot.writeMessageEnd()
5728 
    self._oprot.trans.flush()
5729 
 
5730 
  def recv_getReceivePendingOrders(self, ):
5731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5732 
    if mtype == TMessageType.EXCEPTION:
5733 
      x = TApplicationException()
5734 
      x.read(self._iprot)
5735 
      self._iprot.readMessageEnd()
5736 
      raise x
5737 
    result = getReceivePendingOrders_result()
5738 
    result.read(self._iprot)
5739 
    self._iprot.readMessageEnd()
5740 
    if result.success is not None:
5741 
      return result.success
5742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5743 
 
5744 
  def getReceivedAtStoreOrders(self, storeId):
5745 
    """
5746 
    Parameters:
5747 
     - storeId
5748 
    """
5749 
    self.send_getReceivedAtStoreOrders(storeId)
5750 
    return self.recv_getReceivedAtStoreOrders()
5751 
 
5752 
  def send_getReceivedAtStoreOrders(self, storeId):
5753 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5754 
    args = getReceivedAtStoreOrders_args()
5755 
    args.storeId = storeId
5756 
    args.write(self._oprot)
5757 
    self._oprot.writeMessageEnd()
5758 
    self._oprot.trans.flush()
5759 
 
5760 
  def recv_getReceivedAtStoreOrders(self, ):
5761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5762 
    if mtype == TMessageType.EXCEPTION:
5763 
      x = TApplicationException()
5764 
      x.read(self._iprot)
5765 
      self._iprot.readMessageEnd()
5766 
      raise x
5767 
    result = getReceivedAtStoreOrders_result()
5768 
    result.read(self._iprot)
5769 
    self._iprot.readMessageEnd()
5770 
    if result.success is not None:
5771 
      return result.success
5772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5773 
 
5713 rajveer 5774 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5775 
    """
5776 
    Parameters:
5777 
     - storeId
5778 
     - fromDate
5779 
     - toDate
5780 
     - onlyCod
5781 
    """
5782 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5783 
    return self.recv_getOrdersCollectionAtStore()
5784 
 
5785 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5786 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5787 
    args = getOrdersCollectionAtStore_args()
5788 
    args.storeId = storeId
5789 
    args.fromDate = fromDate
5790 
    args.toDate = toDate
5791 
    args.onlyCod = onlyCod
5792 
    args.write(self._oprot)
5793 
    self._oprot.writeMessageEnd()
5794 
    self._oprot.trans.flush()
5795 
 
5796 
  def recv_getOrdersCollectionAtStore(self, ):
5797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5798 
    if mtype == TMessageType.EXCEPTION:
5799 
      x = TApplicationException()
5800 
      x.read(self._iprot)
5801 
      self._iprot.readMessageEnd()
5802 
      raise x
5803 
    result = getOrdersCollectionAtStore_result()
5804 
    result.read(self._iprot)
5805 
    self._iprot.readMessageEnd()
5806 
    if result.success is not None:
5807 
      return result.success
5808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5809 
 
5833 rajveer 5810 
  def getOrderAttributeValue(self, orderId, attributeName):
5811 
    """
5812 
    Parameters:
5813 
     - orderId
5814 
     - attributeName
5815 
    """
5816 
    self.send_getOrderAttributeValue(orderId, attributeName)
5817 
    return self.recv_getOrderAttributeValue()
5818 
 
5819 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5820 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5821 
    args = getOrderAttributeValue_args()
5822 
    args.orderId = orderId
5823 
    args.attributeName = attributeName
5824 
    args.write(self._oprot)
5825 
    self._oprot.writeMessageEnd()
5826 
    self._oprot.trans.flush()
5827 
 
5828 
  def recv_getOrderAttributeValue(self, ):
5829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5830 
    if mtype == TMessageType.EXCEPTION:
5831 
      x = TApplicationException()
5832 
      x.read(self._iprot)
5833 
      self._iprot.readMessageEnd()
5834 
      raise x
5835 
    result = getOrderAttributeValue_result()
5836 
    result.read(self._iprot)
5837 
    self._iprot.readMessageEnd()
5838 
    if result.success is not None:
5839 
      return result.success
5840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5841 
 
6019 rajveer 5842 
  def changeJacketNumber(self, orderId, jacketNumber):
5843 
    """
5844 
    Parameters:
5845 
     - orderId
5846 
     - jacketNumber
5847 
    """
5848 
    self.send_changeJacketNumber(orderId, jacketNumber)
5849 
    return self.recv_changeJacketNumber()
5850 
 
5851 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5852 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5853 
    args = changeJacketNumber_args()
5854 
    args.orderId = orderId
5855 
    args.jacketNumber = jacketNumber
5856 
    args.write(self._oprot)
5857 
    self._oprot.writeMessageEnd()
5858 
    self._oprot.trans.flush()
5859 
 
5860 
  def recv_changeJacketNumber(self, ):
5861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5862 
    if mtype == TMessageType.EXCEPTION:
5863 
      x = TApplicationException()
5864 
      x.read(self._iprot)
5865 
      self._iprot.readMessageEnd()
5866 
      raise x
5867 
    result = changeJacketNumber_result()
5868 
    result.read(self._iprot)
5869 
    self._iprot.readMessageEnd()
5870 
    if result.success is not None:
5871 
      return result.success
5872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5873 
 
5874 
  def markOrderAsRtoInTransit(self, orderId):
5875 
    """
5876 
    Parameters:
5877 
     - orderId
5878 
    """
5879 
    self.send_markOrderAsRtoInTransit(orderId)
5880 
    return self.recv_markOrderAsRtoInTransit()
5881 
 
5882 
  def send_markOrderAsRtoInTransit(self, orderId):
5883 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5884 
    args = markOrderAsRtoInTransit_args()
5885 
    args.orderId = orderId
5886 
    args.write(self._oprot)
5887 
    self._oprot.writeMessageEnd()
5888 
    self._oprot.trans.flush()
5889 
 
5890 
  def recv_markOrderAsRtoInTransit(self, ):
5891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5892 
    if mtype == TMessageType.EXCEPTION:
5893 
      x = TApplicationException()
5894 
      x.read(self._iprot)
5895 
      self._iprot.readMessageEnd()
5896 
      raise x
5897 
    result = markOrderAsRtoInTransit_result()
5898 
    result.read(self._iprot)
5899 
    self._iprot.readMessageEnd()
5900 
    if result.success is not None:
5901 
      return result.success
5902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5903 
 
5593 mandeep.dh 5904 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5905 
    """
5906 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5907 
    invoked while scanning IN of items.
5553 rajveer 5908 
 
5593 mandeep.dh 5909 
    Parameters:
5910 
     - itemId
5911 
     - quantity
5912 
     - fulfilmentWarehouseId
5913 
     - billingWarehouseId
5914 
    """
5915 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5916 
    self.recv_acceptOrderForItem()
5917 
 
5918 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5919 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5920 
    args = acceptOrderForItem_args()
5921 
    args.itemId = itemId
5922 
    args.quantity = quantity
5923 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5924 
    args.billingWarehouseId = billingWarehouseId
5925 
    args.write(self._oprot)
5926 
    self._oprot.writeMessageEnd()
5927 
    self._oprot.trans.flush()
5928 
 
5929 
  def recv_acceptOrderForItem(self, ):
5930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5931 
    if mtype == TMessageType.EXCEPTION:
5932 
      x = TApplicationException()
5933 
      x.read(self._iprot)
5934 
      self._iprot.readMessageEnd()
5935 
      raise x
5936 
    result = acceptOrderForItem_result()
5937 
    result.read(self._iprot)
5938 
    self._iprot.readMessageEnd()
5939 
    return
5940 
 
6000 mandeep.dh 5941 
  def createRechargeOrder(self, rechargeOrder):
5942 
    """
5943 
    Parameters:
5944 
     - rechargeOrder
5945 
    """
5946 
    self.send_createRechargeOrder(rechargeOrder)
5947 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5948 
 
6000 mandeep.dh 5949 
  def send_createRechargeOrder(self, rechargeOrder):
5950 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5951 
    args = createRechargeOrder_args()
5952 
    args.rechargeOrder = rechargeOrder
5953 
    args.write(self._oprot)
5954 
    self._oprot.writeMessageEnd()
5955 
    self._oprot.trans.flush()
5956 
 
5957 
  def recv_createRechargeOrder(self, ):
5958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5959 
    if mtype == TMessageType.EXCEPTION:
5960 
      x = TApplicationException()
5961 
      x.read(self._iprot)
5962 
      self._iprot.readMessageEnd()
5963 
      raise x
5964 
    result = createRechargeOrder_result()
5965 
    result.read(self._iprot)
5966 
    self._iprot.readMessageEnd()
5967 
    if result.success is not None:
5968 
      return result.success
5969 
    if result.ex is not None:
5970 
      raise result.ex
5971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5972 
 
6031 rajveer 5973 
  def getRechargeOrder(self, rechargeRrderId):
5974 
    """
5975 
    Parameters:
5976 
     - rechargeRrderId
5977 
    """
5978 
    self.send_getRechargeOrder(rechargeRrderId)
5979 
    return self.recv_getRechargeOrder()
5980 
 
5981 
  def send_getRechargeOrder(self, rechargeRrderId):
5982 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5983 
    args = getRechargeOrder_args()
5984 
    args.rechargeRrderId = rechargeRrderId
5985 
    args.write(self._oprot)
5986 
    self._oprot.writeMessageEnd()
5987 
    self._oprot.trans.flush()
5988 
 
5989 
  def recv_getRechargeOrder(self, ):
5990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5991 
    if mtype == TMessageType.EXCEPTION:
5992 
      x = TApplicationException()
5993 
      x.read(self._iprot)
5994 
      self._iprot.readMessageEnd()
5995 
      raise x
5996 
    result = getRechargeOrder_result()
5997 
    result.read(self._iprot)
5998 
    self._iprot.readMessageEnd()
5999 
    if result.success is not None:
6000 
      return result.success
6001 
    if result.ex is not None:
6002 
      raise result.ex
6003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6004 
 
6005 
  def getRechargeOrders(self, userId):
6006 
    """
6007 
    Parameters:
6008 
     - userId
6009 
    """
6010 
    self.send_getRechargeOrders(userId)
6011 
    return self.recv_getRechargeOrders()
6012 
 
6013 
  def send_getRechargeOrders(self, userId):
6014 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6015 
    args = getRechargeOrders_args()
6016 
    args.userId = userId
6017 
    args.write(self._oprot)
6018 
    self._oprot.writeMessageEnd()
6019 
    self._oprot.trans.flush()
6020 
 
6021 
  def recv_getRechargeOrders(self, ):
6022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6023 
    if mtype == TMessageType.EXCEPTION:
6024 
      x = TApplicationException()
6025 
      x.read(self._iprot)
6026 
      self._iprot.readMessageEnd()
6027 
      raise x
6028 
    result = getRechargeOrders_result()
6029 
    result.read(self._iprot)
6030 
    self._iprot.readMessageEnd()
6031 
    if result.success is not None:
6032 
      return result.success
6033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6034 
 
6000 mandeep.dh 6035 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6036 
    """
6037 
    Parameters:
6038 
     - rechargeOrderId
6039 
     - rechargeOrderStatus
6040 
    """
6041 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6042 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6043 
 
6044 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6045 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6046 
    args = updateRechargeOrderStatus_args()
6047 
    args.rechargeOrderId = rechargeOrderId
6048 
    args.rechargeOrderStatus = rechargeOrderStatus
6049 
    args.write(self._oprot)
6050 
    self._oprot.writeMessageEnd()
6051 
    self._oprot.trans.flush()
6052 
 
6053 
  def recv_updateRechargeOrderStatus(self, ):
6054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6055 
    if mtype == TMessageType.EXCEPTION:
6056 
      x = TApplicationException()
6057 
      x.read(self._iprot)
6058 
      self._iprot.readMessageEnd()
6059 
      raise x
6060 
    result = updateRechargeOrderStatus_result()
6061 
    result.read(self._iprot)
6062 
    self._iprot.readMessageEnd()
6031 rajveer 6063 
    if result.success is not None:
6064 
      return result.success
6000 mandeep.dh 6065 
    if result.ex is not None:
6066 
      raise result.ex
6031 rajveer 6067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6068 
 
6031 rajveer 6069 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6070 
    """
6071 
    Parameters:
6031 rajveer 6072 
     - rechargeOrderId
6000 mandeep.dh 6073 
    """
6031 rajveer 6074 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6075 
    return self.recv_activateRechargeTxn()
6076 
 
6031 rajveer 6077 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6078 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6079 
    args = activateRechargeTxn_args()
6031 rajveer 6080 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6081 
    args.write(self._oprot)
6082 
    self._oprot.writeMessageEnd()
6083 
    self._oprot.trans.flush()
6084 
 
6085 
  def recv_activateRechargeTxn(self, ):
6086 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6087 
    if mtype == TMessageType.EXCEPTION:
6088 
      x = TApplicationException()
6089 
      x.read(self._iprot)
6090 
      self._iprot.readMessageEnd()
6091 
      raise x
6092 
    result = activateRechargeTxn_result()
6093 
    result.read(self._iprot)
6094 
    self._iprot.readMessageEnd()
6095 
    if result.success is not None:
6096 
      return result.success
6097 
    if result.ex is not None:
6098 
      raise result.ex
6099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6100 
 
6031 rajveer 6101 
  def getUserWallet(self, userId):
6000 mandeep.dh 6102 
    """
6103 
    Parameters:
6031 rajveer 6104 
     - userId
6000 mandeep.dh 6105 
    """
6031 rajveer 6106 
    self.send_getUserWallet(userId)
6107 
    return self.recv_getUserWallet()
6000 mandeep.dh 6108 
 
6031 rajveer 6109 
  def send_getUserWallet(self, userId):
6110 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6111 
    args = getUserWallet_args()
6112 
    args.userId = userId
6000 mandeep.dh 6113 
    args.write(self._oprot)
6114 
    self._oprot.writeMessageEnd()
6115 
    self._oprot.trans.flush()
6116 
 
6031 rajveer 6117 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6119 
    if mtype == TMessageType.EXCEPTION:
6120 
      x = TApplicationException()
6121 
      x.read(self._iprot)
6122 
      self._iprot.readMessageEnd()
6123 
      raise x
6031 rajveer 6124 
    result = getUserWallet_result()
6000 mandeep.dh 6125 
    result.read(self._iprot)
6126 
    self._iprot.readMessageEnd()
6127 
    if result.success is not None:
6128 
      return result.success
6031 rajveer 6129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6130 
 
6031 rajveer 6131 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6132 
    """
6133 
    Parameters:
6031 rajveer 6134 
     - userId
6000 mandeep.dh 6135 
    """
6031 rajveer 6136 
    self.send_getUserWalletHistory(userId)
6137 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6138 
 
6031 rajveer 6139 
  def send_getUserWalletHistory(self, userId):
6140 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6141 
    args = getUserWalletHistory_args()
6142 
    args.userId = userId
6000 mandeep.dh 6143 
    args.write(self._oprot)
6144 
    self._oprot.writeMessageEnd()
6145 
    self._oprot.trans.flush()
6146 
 
6031 rajveer 6147 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6148 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6149 
    if mtype == TMessageType.EXCEPTION:
6150 
      x = TApplicationException()
6151 
      x.read(self._iprot)
6152 
      self._iprot.readMessageEnd()
6153 
      raise x
6031 rajveer 6154 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6155 
    result.read(self._iprot)
6156 
    self._iprot.readMessageEnd()
6157 
    if result.success is not None:
6158 
      return result.success
6031 rajveer 6159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6160 
 
6050 anupam.sin 6161 
  def getRechargeOrdersForTransaction(self, txnId):
6162 
    """
6163 
    Returns a recharge order for a given transactionId
6164 
 
6165 
    Parameters:
6166 
     - txnId
6167 
    """
6168 
    self.send_getRechargeOrdersForTransaction(txnId)
6169 
    return self.recv_getRechargeOrdersForTransaction()
6170 
 
6171 
  def send_getRechargeOrdersForTransaction(self, txnId):
6172 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6173 
    args = getRechargeOrdersForTransaction_args()
6174 
    args.txnId = txnId
6175 
    args.write(self._oprot)
6176 
    self._oprot.writeMessageEnd()
6177 
    self._oprot.trans.flush()
6178 
 
6179 
  def recv_getRechargeOrdersForTransaction(self, ):
6180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6181 
    if mtype == TMessageType.EXCEPTION:
6182 
      x = TApplicationException()
6183 
      x.read(self._iprot)
6184 
      self._iprot.readMessageEnd()
6185 
      raise x
6186 
    result = getRechargeOrdersForTransaction_result()
6187 
    result.read(self._iprot)
6188 
    self._iprot.readMessageEnd()
6189 
    if result.success is not None:
6190 
      return result.success
6191 
    if result.ex is not None:
6192 
      raise result.ex
6193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6194 
 
6206 rajveer 6195 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6196 
    """
6197 
    Parameters:
6198 
     - rechargeType
6206 rajveer 6199 
     - onlyActive
6048 rajveer 6200 
    """
6206 rajveer 6201 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6202 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6203 
 
6206 rajveer 6204 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6205 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6206 
    args = getServiceProviders_args()
6207 
    args.rechargeType = rechargeType
6206 rajveer 6208 
    args.onlyActive = onlyActive
6048 rajveer 6209 
    args.write(self._oprot)
6210 
    self._oprot.writeMessageEnd()
6211 
    self._oprot.trans.flush()
6212 
 
6213 
  def recv_getServiceProviders(self, ):
6214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6215 
    if mtype == TMessageType.EXCEPTION:
6216 
      x = TApplicationException()
6217 
      x.read(self._iprot)
6218 
      self._iprot.readMessageEnd()
6219 
      raise x
6220 
    result = getServiceProviders_result()
6221 
    result.read(self._iprot)
6222 
    self._iprot.readMessageEnd()
6223 
    if result.success is not None:
6224 
      return result.success
6225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6226 
 
6049 rajveer 6227 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6228 
    """
6229 
    Parameters:
6049 rajveer 6230 
     - rechargeType
6048 rajveer 6231 
     - deviceNumber
6232 
    """
6049 rajveer 6233 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6234 
    return self.recv_getServiceProviderForDevice()
6235 
 
6049 rajveer 6236 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6237 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6238 
    args = getServiceProviderForDevice_args()
6049 rajveer 6239 
    args.rechargeType = rechargeType
6048 rajveer 6240 
    args.deviceNumber = deviceNumber
6241 
    args.write(self._oprot)
6242 
    self._oprot.writeMessageEnd()
6243 
    self._oprot.trans.flush()
6244 
 
6245 
  def recv_getServiceProviderForDevice(self, ):
6246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6247 
    if mtype == TMessageType.EXCEPTION:
6248 
      x = TApplicationException()
6249 
      x.read(self._iprot)
6250 
      self._iprot.readMessageEnd()
6251 
      raise x
6252 
    result = getServiceProviderForDevice_result()
6253 
    result.read(self._iprot)
6254 
    self._iprot.readMessageEnd()
6255 
    if result.success is not None:
6256 
      return result.success
6257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6258 
 
6591 anupam.sin 6259 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6260 
    """
6261 
    Parameters:
6262 
     - rechargeType
6263 
     - deviceNumber
6307 anupam.sin 6264 
     - userSelectedProviderId
6591 anupam.sin 6265 
     - clientAddress
6269 rajveer 6266 
    """
6591 anupam.sin 6267 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6268 
    return self.recv_validateRecharge()
6269 
 
6591 anupam.sin 6270 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6271 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6272 
    args = validateRecharge_args()
6273 
    args.rechargeType = rechargeType
6274 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6275 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6276 
    args.clientAddress = clientAddress
6269 rajveer 6277 
    args.write(self._oprot)
6278 
    self._oprot.writeMessageEnd()
6279 
    self._oprot.trans.flush()
6280 
 
6281 
  def recv_validateRecharge(self, ):
6282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6283 
    if mtype == TMessageType.EXCEPTION:
6284 
      x = TApplicationException()
6285 
      x.read(self._iprot)
6286 
      self._iprot.readMessageEnd()
6287 
      raise x
6288 
    result = validateRecharge_result()
6289 
    result.read(self._iprot)
6290 
    self._iprot.readMessageEnd()
6291 
    if result.success is not None:
6292 
      return result.success
6293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6294 
 
6094 rajveer 6295 
  def getRechargeOrdersForDevice(self, deviceNumber):
6296 
    """
6297 
    Parameters:
6298 
     - deviceNumber
6299 
    """
6300 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6301 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6302 
 
6094 rajveer 6303 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6304 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6305 
    args = getRechargeOrdersForDevice_args()
6306 
    args.deviceNumber = deviceNumber
6307 
    args.write(self._oprot)
6308 
    self._oprot.writeMessageEnd()
6309 
    self._oprot.trans.flush()
6310 
 
6311 
  def recv_getRechargeOrdersForDevice(self, ):
6312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6313 
    if mtype == TMessageType.EXCEPTION:
6314 
      x = TApplicationException()
6315 
      x.read(self._iprot)
6316 
      self._iprot.readMessageEnd()
6317 
      raise x
6318 
    result = getRechargeOrdersForDevice_result()
6319 
    result.read(self._iprot)
6320 
    self._iprot.readMessageEnd()
6321 
    if result.success is not None:
6322 
      return result.success
6323 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6324 
 
6325 
  def addAmountToWallet(self, userId, orderId, amount):
6326 
    """
6327 
    Parameters:
6328 
     - userId
6329 
     - orderId
6330 
     - amount
6331 
    """
6332 
    self.send_addAmountToWallet(userId, orderId, amount)
6333 
    self.recv_addAmountToWallet()
6334 
 
6335 
  def send_addAmountToWallet(self, userId, orderId, amount):
6336 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6337 
    args = addAmountToWallet_args()
6338 
    args.userId = userId
6339 
    args.orderId = orderId
6340 
    args.amount = amount
6341 
    args.write(self._oprot)
6342 
    self._oprot.writeMessageEnd()
6343 
    self._oprot.trans.flush()
6344 
 
6345 
  def recv_addAmountToWallet(self, ):
6346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6347 
    if mtype == TMessageType.EXCEPTION:
6348 
      x = TApplicationException()
6349 
      x.read(self._iprot)
6350 
      self._iprot.readMessageEnd()
6351 
      raise x
6352 
    result = addAmountToWallet_result()
6353 
    result.read(self._iprot)
6354 
    self._iprot.readMessageEnd()
6355 
    return
6356 
 
6188 rajveer 6357 
  def getRechargeStatistics(self, ):
6358 
    self.send_getRechargeStatistics()
6359 
    return self.recv_getRechargeStatistics()
6360 
 
6361 
  def send_getRechargeStatistics(self, ):
6362 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6363 
    args = getRechargeStatistics_args()
6364 
    args.write(self._oprot)
6365 
    self._oprot.writeMessageEnd()
6366 
    self._oprot.trans.flush()
6367 
 
6368 
  def recv_getRechargeStatistics(self, ):
6369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6370 
    if mtype == TMessageType.EXCEPTION:
6371 
      x = TApplicationException()
6372 
      x.read(self._iprot)
6373 
      self._iprot.readMessageEnd()
6374 
      raise x
6375 
    result = getRechargeStatistics_result()
6376 
    result.read(self._iprot)
6377 
    self._iprot.readMessageEnd()
6378 
    if result.success is not None:
6379 
      return result.success
6380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6381 
 
6154 rajveer 6382 
  def getRechargeOrdersForStatus(self, status):
6383 
    """
6384 
    Parameters:
6385 
     - status
6386 
    """
6387 
    self.send_getRechargeOrdersForStatus(status)
6388 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6389 
 
6154 rajveer 6390 
  def send_getRechargeOrdersForStatus(self, status):
6391 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6392 
    args = getRechargeOrdersForStatus_args()
6393 
    args.status = status
6394 
    args.write(self._oprot)
6395 
    self._oprot.writeMessageEnd()
6396 
    self._oprot.trans.flush()
6397 
 
6398 
  def recv_getRechargeOrdersForStatus(self, ):
6399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6400 
    if mtype == TMessageType.EXCEPTION:
6401 
      x = TApplicationException()
6402 
      x.read(self._iprot)
6403 
      self._iprot.readMessageEnd()
6404 
      raise x
6405 
    result = getRechargeOrdersForStatus_result()
6406 
    result.read(self._iprot)
6407 
    self._iprot.readMessageEnd()
6408 
    if result.success is not None:
6409 
      return result.success
6410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6411 
 
6159 rajveer 6412 
  def getPlansForOperator(self, operatorId):
6413 
    """
6414 
    Parameters:
6415 
     - operatorId
6416 
    """
6417 
    self.send_getPlansForOperator(operatorId)
6418 
    return self.recv_getPlansForOperator()
6154 rajveer 6419 
 
6159 rajveer 6420 
  def send_getPlansForOperator(self, operatorId):
6421 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6422 
    args = getPlansForOperator_args()
6423 
    args.operatorId = operatorId
6424 
    args.write(self._oprot)
6425 
    self._oprot.writeMessageEnd()
6426 
    self._oprot.trans.flush()
6427 
 
6428 
  def recv_getPlansForOperator(self, ):
6429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6430 
    if mtype == TMessageType.EXCEPTION:
6431 
      x = TApplicationException()
6432 
      x.read(self._iprot)
6433 
      self._iprot.readMessageEnd()
6434 
      raise x
6435 
    result = getPlansForOperator_result()
6436 
    result.read(self._iprot)
6437 
    self._iprot.readMessageEnd()
6438 
    if result.success is not None:
6439 
      return result.success
6440 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6441 
 
6307 anupam.sin 6442 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6443 
    """
6444 
    Returns denominations for a given operator and circle
6159 rajveer 6445 
 
6289 anupam.sin 6446 
    Parameters:
6447 
     - operatorId
6307 anupam.sin 6448 
     - circleCode
6289 anupam.sin 6449 
     - denominationType
6450 
    """
6307 anupam.sin 6451 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6452 
    return self.recv_getRechargeDenominations()
6453 
 
6307 anupam.sin 6454 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6455 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6456 
    args = getRechargeDenominations_args()
6457 
    args.operatorId = operatorId
6307 anupam.sin 6458 
    args.circleCode = circleCode
6289 anupam.sin 6459 
    args.denominationType = denominationType
6460 
    args.write(self._oprot)
6461 
    self._oprot.writeMessageEnd()
6462 
    self._oprot.trans.flush()
6463 
 
6464 
  def recv_getRechargeDenominations(self, ):
6465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6466 
    if mtype == TMessageType.EXCEPTION:
6467 
      x = TApplicationException()
6468 
      x.read(self._iprot)
6469 
      self._iprot.readMessageEnd()
6470 
      raise x
6471 
    result = getRechargeDenominations_result()
6472 
    result.read(self._iprot)
6473 
    self._iprot.readMessageEnd()
6474 
    if result.success is not None:
6475 
      return result.success
6476 
    if result.ex is not None:
6477 
      raise result.ex
6478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6479 
 
6371 rajveer 6480 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6481 
    """
6482 
    Parameters:
6483 
     - operatorId
6484 
     - circleId
6485 
     - isAvailable
6486 
    """
6487 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6488 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6489 
 
6371 rajveer 6490 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6491 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6492 
    args = updateAvailabilityStatus_args()
6493 
    args.operatorId = operatorId
6494 
    args.circleId = circleId
6495 
    args.isAvailable = isAvailable
6496 
    args.write(self._oprot)
6497 
    self._oprot.writeMessageEnd()
6498 
    self._oprot.trans.flush()
6499 
 
6500 
  def recv_updateAvailabilityStatus(self, ):
6501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6502 
    if mtype == TMessageType.EXCEPTION:
6503 
      x = TApplicationException()
6504 
      x.read(self._iprot)
6505 
      self._iprot.readMessageEnd()
6506 
      raise x
6507 
    result = updateAvailabilityStatus_result()
6508 
    result.read(self._iprot)
6509 
    self._iprot.readMessageEnd()
6510 
    return
6511 
 
6389 rajveer 6512 
  def getAvailableEmiSchemes(self, ):
6513 
    self.send_getAvailableEmiSchemes()
6514 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6515 
 
6389 rajveer 6516 
  def send_getAvailableEmiSchemes(self, ):
6517 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6518 
    args = getAvailableEmiSchemes_args()
6519 
    args.write(self._oprot)
6520 
    self._oprot.writeMessageEnd()
6521 
    self._oprot.trans.flush()
6522 
 
6523 
  def recv_getAvailableEmiSchemes(self, ):
6524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6525 
    if mtype == TMessageType.EXCEPTION:
6526 
      x = TApplicationException()
6527 
      x.read(self._iprot)
6528 
      self._iprot.readMessageEnd()
6529 
      raise x
6530 
    result = getAvailableEmiSchemes_result()
6531 
    result.read(self._iprot)
6532 
    self._iprot.readMessageEnd()
6533 
    if result.success is not None:
6534 
      return result.success
6535 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6536 
 
6537 
  def getMiscCharges(self, transactionId):
6538 
    """
6539 
    Parameters:
6540 
     - transactionId
6541 
    """
6542 
    self.send_getMiscCharges(transactionId)
6543 
    return self.recv_getMiscCharges()
6544 
 
6545 
  def send_getMiscCharges(self, transactionId):
6546 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6547 
    args = getMiscCharges_args()
6548 
    args.transactionId = transactionId
6549 
    args.write(self._oprot)
6550 
    self._oprot.writeMessageEnd()
6551 
    self._oprot.trans.flush()
6552 
 
6553 
  def recv_getMiscCharges(self, ):
6554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6555 
    if mtype == TMessageType.EXCEPTION:
6556 
      x = TApplicationException()
6557 
      x.read(self._iprot)
6558 
      self._iprot.readMessageEnd()
6559 
      raise x
6560 
    result = getMiscCharges_result()
6561 
    result.read(self._iprot)
6562 
    self._iprot.readMessageEnd()
6563 
    if result.success is not None:
6564 
      return result.success
6565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6566 
 
6507 anupam.sin 6567 
  def refundRechargeOrder(self, rechargeOrderId):
6568 
    """
6569 
    Parameters:
6570 
     - rechargeOrderId
6571 
    """
6572 
    self.send_refundRechargeOrder(rechargeOrderId)
6573 
    return self.recv_refundRechargeOrder()
6389 rajveer 6574 
 
6507 anupam.sin 6575 
  def send_refundRechargeOrder(self, rechargeOrderId):
6576 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6577 
    args = refundRechargeOrder_args()
6578 
    args.rechargeOrderId = rechargeOrderId
6579 
    args.write(self._oprot)
6580 
    self._oprot.writeMessageEnd()
6581 
    self._oprot.trans.flush()
6582 
 
6583 
  def recv_refundRechargeOrder(self, ):
6584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6585 
    if mtype == TMessageType.EXCEPTION:
6586 
      x = TApplicationException()
6587 
      x.read(self._iprot)
6588 
      self._iprot.readMessageEnd()
6589 
      raise x
6590 
    result = refundRechargeOrder_result()
6591 
    result.read(self._iprot)
6592 
    self._iprot.readMessageEnd()
6593 
    if result.success is not None:
6594 
      return result.success
6595 
    if result.ex is not None:
6596 
      raise result.ex
6597 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6598 
 
6821 amar.kumar 6599 
  def getPhysicalOrders(self, fromDate, toDate):
6600 
    """
6601 
    Parameters:
6602 
     - fromDate
6603 
     - toDate
6604 
    """
6605 
    self.send_getPhysicalOrders(fromDate, toDate)
6606 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6607 
 
6821 amar.kumar 6608 
  def send_getPhysicalOrders(self, fromDate, toDate):
6609 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6610 
    args = getPhysicalOrders_args()
6611 
    args.fromDate = fromDate
6612 
    args.toDate = toDate
6613 
    args.write(self._oprot)
6614 
    self._oprot.writeMessageEnd()
6615 
    self._oprot.trans.flush()
6616 
 
6617 
  def recv_getPhysicalOrders(self, ):
6618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6619 
    if mtype == TMessageType.EXCEPTION:
6620 
      x = TApplicationException()
6621 
      x.read(self._iprot)
6622 
      self._iprot.readMessageEnd()
6623 
      raise x
6624 
    result = getPhysicalOrders_result()
6625 
    result.read(self._iprot)
6626 
    self._iprot.readMessageEnd()
6627 
    if result.success is not None:
6628 
      return result.success
6629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6630 
 
6906 rajveer 6631 
  def getDocument(self, docType, docSource):
6632 
    """
6633 
    Parameters:
6634 
     - docType
6635 
     - docSource
6636 
    """
6637 
    self.send_getDocument(docType, docSource)
6638 
    return self.recv_getDocument()
6821 amar.kumar 6639 
 
6906 rajveer 6640 
  def send_getDocument(self, docType, docSource):
6641 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6642 
    args = getDocument_args()
6643 
    args.docType = docType
6644 
    args.docSource = docSource
6645 
    args.write(self._oprot)
6646 
    self._oprot.writeMessageEnd()
6647 
    self._oprot.trans.flush()
6648 
 
6649 
  def recv_getDocument(self, ):
6650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6651 
    if mtype == TMessageType.EXCEPTION:
6652 
      x = TApplicationException()
6653 
      x.read(self._iprot)
6654 
      self._iprot.readMessageEnd()
6655 
      raise x
6656 
    result = getDocument_result()
6657 
    result.read(self._iprot)
6658 
    self._iprot.readMessageEnd()
6659 
    if result.success is not None:
6660 
      return result.success
6661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6662 
 
6985 anupam.sin 6663 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6664 
    """
6665 
    Parameters:
6666 
     - orderId
6667 
     - line1
6668 
     - line2
6669 
     - city
6670 
     - state
6671 
     - pin
6672 
    """
6673 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6674 
    return self.recv_changeShippingAddress()
6906 rajveer 6675 
 
6985 anupam.sin 6676 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6677 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6678 
    args = changeShippingAddress_args()
6679 
    args.orderId = orderId
6680 
    args.line1 = line1
6681 
    args.line2 = line2
6682 
    args.city = city
6683 
    args.state = state
6684 
    args.pin = pin
6685 
    args.write(self._oprot)
6686 
    self._oprot.writeMessageEnd()
6687 
    self._oprot.trans.flush()
6688 
 
6689 
  def recv_changeShippingAddress(self, ):
6690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6691 
    if mtype == TMessageType.EXCEPTION:
6692 
      x = TApplicationException()
6693 
      x.read(self._iprot)
6694 
      self._iprot.readMessageEnd()
6695 
      raise x
6696 
    result = changeShippingAddress_result()
6697 
    result.read(self._iprot)
6698 
    self._iprot.readMessageEnd()
6699 
    if result.success is not None:
6700 
      return result.success
6701 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6702 
 
7075 rajveer 6703 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6704 
    """
6705 
    Parameters:
6706 
     - orderId
7075 rajveer 6707 
     - userId
6988 rajveer 6708 
    """
7075 rajveer 6709 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6710 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6711 
 
7075 rajveer 6712 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6713 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6714 
    args = retrieveInvoice_args()
6715 
    args.orderId = orderId
7075 rajveer 6716 
    args.userId = userId
6988 rajveer 6717 
    args.write(self._oprot)
6718 
    self._oprot.writeMessageEnd()
6719 
    self._oprot.trans.flush()
6720 
 
6721 
  def recv_retrieveInvoice(self, ):
6722 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6723 
    if mtype == TMessageType.EXCEPTION:
6724 
      x = TApplicationException()
6725 
      x.read(self._iprot)
6726 
      self._iprot.readMessageEnd()
6727 
      raise x
6728 
    result = retrieveInvoice_result()
6729 
    result.read(self._iprot)
6730 
    self._iprot.readMessageEnd()
6731 
    if result.success is not None:
6732 
      return result.success
6733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6734 
 
7026 rajveer 6735 
  def receiveUpdatesForRedExpress(self, awbNumber):
6736 
    """
6737 
    Parameters:
6738 
     - awbNumber
6739 
    """
6740 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6741 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6742 
 
7026 rajveer 6743 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6744 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6745 
    args = receiveUpdatesForRedExpress_args()
6746 
    args.awbNumber = awbNumber
6747 
    args.write(self._oprot)
6748 
    self._oprot.writeMessageEnd()
6749 
    self._oprot.trans.flush()
6750 
 
6751 
  def recv_receiveUpdatesForRedExpress(self, ):
6752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6753 
    if mtype == TMessageType.EXCEPTION:
6754 
      x = TApplicationException()
6755 
      x.read(self._iprot)
6756 
      self._iprot.readMessageEnd()
6757 
      raise x
6758 
    result = receiveUpdatesForRedExpress_result()
6759 
    result.read(self._iprot)
6760 
    self._iprot.readMessageEnd()
6761 
    if result.success is not None:
6762 
      return result.success
6763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6764 
 
7073 anupam.sin 6765 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6766 
    """
6767 
    Parameters:
6768 
     - thriftRechargeTransaction
6769 
    """
6770 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6771 
    return self.recv_createRechargeTransaction()
7026 rajveer 6772 
 
7073 anupam.sin 6773 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6774 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6775 
    args = createRechargeTransaction_args()
6776 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6777 
    args.write(self._oprot)
6778 
    self._oprot.writeMessageEnd()
6779 
    self._oprot.trans.flush()
6780 
 
6781 
  def recv_createRechargeTransaction(self, ):
6782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6783 
    if mtype == TMessageType.EXCEPTION:
6784 
      x = TApplicationException()
6785 
      x.read(self._iprot)
6786 
      self._iprot.readMessageEnd()
6787 
      raise x
6788 
    result = createRechargeTransaction_result()
6789 
    result.read(self._iprot)
6790 
    self._iprot.readMessageEnd()
6791 
    if result.success is not None:
6792 
      return result.success
6793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6794 
 
6795 
 
3376 rajveer 6796 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6797 
  def __init__(self, handler):
3376 rajveer 6798 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6799 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6800 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6801 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6802 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6803 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6804 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6805 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6806 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6807 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6808 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6809 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6810 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6811 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6812 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6813 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6814 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6815 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6816 
    self._processMap["createOrder"] = Processor.process_createOrder
6817 
    self._processMap["getOrder"] = Processor.process_getOrder
6818 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6819 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6820 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6821 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6822 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6823 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6824 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6825 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6826 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6827 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6828 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6829 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6830 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6831 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6832 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6833 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6834 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6835 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6836 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6837 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6838 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6839 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6840 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6841 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6842 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6843 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6844 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6845 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6846 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6847 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6848 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6849 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6850 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6851 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6852 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6853 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6854 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6855 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6856 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6857 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6858 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6859 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6860 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6861 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6862 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6863 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6864 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6865 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6866 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6867 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6868 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6869 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6870 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6871 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6872 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6873 
    self._processMap["changeItem"] = Processor.process_changeItem
6874 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6875 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6876 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6877 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6878 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6879 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6880 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6881 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6882 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6883 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6884 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6885 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6886 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6887 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6888 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6889 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6890 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6891 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6892 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6893 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6894 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6895 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6896 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6897 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6898 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6899 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6900 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6901 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6902 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6903 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6904 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6905 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6906 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6907 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6908 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6909 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6910 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6911 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6912 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6913 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6914 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6915 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6916 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6917 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6918 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6919 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6920 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6921 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6922 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6923 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6924 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6925 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6926 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6927 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6928 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6929 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6930 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6931 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6932 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6933 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6934 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6935 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6936 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6937 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6938 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6939 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6940 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6941 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6942 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6943 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6944 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6945 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6946 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6947 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6948 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 6949 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 6950 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 6951 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 6952 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
94 ashish 6953 
 
6954 
  def process(self, iprot, oprot):
6955 
    (name, type, seqid) = iprot.readMessageBegin()
6956 
    if name not in self._processMap:
6957 
      iprot.skip(TType.STRUCT)
6958 
      iprot.readMessageEnd()
6959 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6960 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6961 
      x.write(oprot)
6962 
      oprot.writeMessageEnd()
6963 
      oprot.trans.flush()
6964 
      return
6965 
    else:
6966 
      self._processMap[name](self, seqid, iprot, oprot)
6967 
    return True
6968 
 
6969 
  def process_createTransaction(self, seqid, iprot, oprot):
6970 
    args = createTransaction_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = createTransaction_result()
6974 
    try:
132 ashish 6975 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
6978 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
6983 
  def process_getTransaction(self, seqid, iprot, oprot):
6984 
    args = getTransaction_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = getTransaction_result()
6988 
    try:
6989 
      result.success = self._handler.getTransaction(args.id)
6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
6992 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
6997 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6998 
    args = getTransactionsForCustomer_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = getTransactionsForCustomer_result()
7002 
    try:
7003 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7004 
    except TransactionServiceException, ex:
7005 
      result.ex = ex
7006 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7007 
    result.write(oprot)
7008 
    oprot.writeMessageEnd()
7009 
    oprot.trans.flush()
7010 
 
132 ashish 7011 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7012 
    args = getTransactionsForShoppingCartId_args()
7013 
    args.read(iprot)
7014 
    iprot.readMessageEnd()
7015 
    result = getTransactionsForShoppingCartId_result()
7016 
    try:
7017 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7018 
    except TransactionServiceException, ex:
7019 
      result.ex = ex
7020 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
7024 
 
94 ashish 7025 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7026 
    args = getTransactionStatus_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = getTransactionStatus_result()
7030 
    try:
7031 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7032 
    except TransactionServiceException, ex:
7033 
      result.ex = ex
7034 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
7039 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7040 
    args = changeTransactionStatus_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = changeTransactionStatus_result()
7044 
    try:
5527 anupam.sin 7045 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7046 
    except TransactionServiceException, ex:
7047 
      result.ex = ex
7048 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7049 
    result.write(oprot)
7050 
    oprot.writeMessageEnd()
7051 
    oprot.trans.flush()
7052 
 
1398 varun.gupt 7053 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7054 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7055 
    args.read(iprot)
7056 
    iprot.readMessageEnd()
1398 varun.gupt 7057 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7058 
    try:
1398 varun.gupt 7059 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7060 
    except TransactionServiceException, ex:
7061 
      result.ex = ex
1398 varun.gupt 7062 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7063 
    result.write(oprot)
7064 
    oprot.writeMessageEnd()
7065 
    oprot.trans.flush()
7066 
 
483 rajveer 7067 
  def process_getAllOrders(self, seqid, iprot, oprot):
7068 
    args = getAllOrders_args()
94 ashish 7069 
    args.read(iprot)
7070 
    iprot.readMessageEnd()
483 rajveer 7071 
    result = getAllOrders_result()
94 ashish 7072 
    try:
4801 anupam.sin 7073 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7074 
    except TransactionServiceException, ex:
7075 
      result.ex = ex
483 rajveer 7076 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7077 
    result.write(oprot)
7078 
    oprot.writeMessageEnd()
7079 
    oprot.trans.flush()
7080 
 
4133 chandransh 7081 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7082 
    args = getOrdersInBatch_args()
7083 
    args.read(iprot)
7084 
    iprot.readMessageEnd()
7085 
    result = getOrdersInBatch_result()
7086 
    try:
7087 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7088 
    except TransactionServiceException, ex:
7089 
      result.ex = ex
7090 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7091 
    result.write(oprot)
7092 
    oprot.writeMessageEnd()
7093 
    oprot.trans.flush()
7094 
 
7095 
  def process_getOrderCount(self, seqid, iprot, oprot):
7096 
    args = getOrderCount_args()
7097 
    args.read(iprot)
7098 
    iprot.readMessageEnd()
7099 
    result = getOrderCount_result()
7100 
    try:
7101 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7102 
    except TransactionServiceException, ex:
7103 
      result.ex = ex
7104 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7105 
    result.write(oprot)
7106 
    oprot.writeMessageEnd()
7107 
    oprot.trans.flush()
7108 
 
999 varun.gupt 7109 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7110 
    args = getOrdersByBillingDate_args()
7111 
    args.read(iprot)
7112 
    iprot.readMessageEnd()
7113 
    result = getOrdersByBillingDate_result()
7114 
    try:
7115 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7116 
    except TransactionServiceException, ex:
7117 
      result.ex = ex
7118 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7119 
    result.write(oprot)
7120 
    oprot.writeMessageEnd()
7121 
    oprot.trans.flush()
7122 
 
3427 chandransh 7123 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7124 
    args = getOrdersByShippingDate_args()
7125 
    args.read(iprot)
7126 
    iprot.readMessageEnd()
7127 
    result = getOrdersByShippingDate_result()
7128 
    try:
3451 chandransh 7129 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7130 
    except TransactionServiceException, ex:
7131 
      result.ex = ex
7132 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7133 
    result.write(oprot)
7134 
    oprot.writeMessageEnd()
7135 
    oprot.trans.flush()
7136 
 
1382 varun.gupt 7137 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7138 
    args = getReturnableOrdersForCustomer_args()
7139 
    args.read(iprot)
7140 
    iprot.readMessageEnd()
7141 
    result = getReturnableOrdersForCustomer_result()
7142 
    try:
7143 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7144 
    except TransactionServiceException, ex:
7145 
      result.ex = ex
7146 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7147 
    result.write(oprot)
7148 
    oprot.writeMessageEnd()
7149 
    oprot.trans.flush()
7150 
 
7151 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7152 
    args = getCancellableOrdersForCustomer_args()
7153 
    args.read(iprot)
7154 
    iprot.readMessageEnd()
7155 
    result = getCancellableOrdersForCustomer_result()
7156 
    try:
7157 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7158 
    except TransactionServiceException, ex:
7159 
      result.ex = ex
7160 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7161 
    result.write(oprot)
7162 
    oprot.writeMessageEnd()
7163 
    oprot.trans.flush()
7164 
 
483 rajveer 7165 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7166 
    args = changeOrderStatus_args()
94 ashish 7167 
    args.read(iprot)
7168 
    iprot.readMessageEnd()
483 rajveer 7169 
    result = changeOrderStatus_result()
94 ashish 7170 
    try:
483 rajveer 7171 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7172 
    except TransactionServiceException, ex:
7173 
      result.ex = ex
483 rajveer 7174 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7175 
    result.write(oprot)
7176 
    oprot.writeMessageEnd()
7177 
    oprot.trans.flush()
7178 
 
483 rajveer 7179 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7180 
    args = getOrdersForTransaction_args()
94 ashish 7181 
    args.read(iprot)
7182 
    iprot.readMessageEnd()
483 rajveer 7183 
    result = getOrdersForTransaction_result()
94 ashish 7184 
    try:
1528 ankur.sing 7185 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7186 
    except TransactionServiceException, ex:
7187 
      result.ex = ex
483 rajveer 7188 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7189 
    result.write(oprot)
7190 
    oprot.writeMessageEnd()
7191 
    oprot.trans.flush()
7192 
 
483 rajveer 7193 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7194 
    args = getOrdersForCustomer_args()
94 ashish 7195 
    args.read(iprot)
7196 
    iprot.readMessageEnd()
483 rajveer 7197 
    result = getOrdersForCustomer_result()
94 ashish 7198 
    try:
3014 chandransh 7199 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7200 
    except TransactionServiceException, ex:
7201 
      result.ex = ex
483 rajveer 7202 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7203 
    result.write(oprot)
7204 
    oprot.writeMessageEnd()
7205 
    oprot.trans.flush()
7206 
 
483 rajveer 7207 
  def process_createOrder(self, seqid, iprot, oprot):
7208 
    args = createOrder_args()
94 ashish 7209 
    args.read(iprot)
7210 
    iprot.readMessageEnd()
483 rajveer 7211 
    result = createOrder_result()
94 ashish 7212 
    try:
483 rajveer 7213 
      result.success = self._handler.createOrder(args.order)
94 ashish 7214 
    except TransactionServiceException, ex:
7215 
      result.ex = ex
483 rajveer 7216 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7217 
    result.write(oprot)
7218 
    oprot.writeMessageEnd()
7219 
    oprot.trans.flush()
7220 
 
483 rajveer 7221 
  def process_getOrder(self, seqid, iprot, oprot):
7222 
    args = getOrder_args()
94 ashish 7223 
    args.read(iprot)
7224 
    iprot.readMessageEnd()
483 rajveer 7225 
    result = getOrder_result()
94 ashish 7226 
    try:
483 rajveer 7227 
      result.success = self._handler.getOrder(args.id)
94 ashish 7228 
    except TransactionServiceException, ex:
7229 
      result.ex = ex
483 rajveer 7230 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7231 
    result.write(oprot)
7232 
    oprot.writeMessageEnd()
7233 
    oprot.trans.flush()
7234 
 
483 rajveer 7235 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7236 
    args = getLineItemsForOrder_args()
94 ashish 7237 
    args.read(iprot)
7238 
    iprot.readMessageEnd()
483 rajveer 7239 
    result = getLineItemsForOrder_result()
94 ashish 7240 
    try:
483 rajveer 7241 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7242 
    except TransactionServiceException, ex:
7243 
      result.ex = ex
483 rajveer 7244 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7245 
    result.write(oprot)
7246 
    oprot.writeMessageEnd()
7247 
    oprot.trans.flush()
7248 
 
4999 phani.kuma 7249 
  def process_getOrderList(self, seqid, iprot, oprot):
7250 
    args = getOrderList_args()
7251 
    args.read(iprot)
7252 
    iprot.readMessageEnd()
7253 
    result = getOrderList_result()
7254 
    result.success = self._handler.getOrderList(args.order_ids)
7255 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7256 
    result.write(oprot)
7257 
    oprot.writeMessageEnd()
7258 
    oprot.trans.flush()
7259 
 
5386 phani.kuma 7260 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7261 
    args = getOrderListForVendor_args()
7262 
    args.read(iprot)
7263 
    iprot.readMessageEnd()
7264 
    result = getOrderListForVendor_result()
7265 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7266 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7267 
    result.write(oprot)
7268 
    oprot.writeMessageEnd()
7269 
    oprot.trans.flush()
7270 
 
1528 ankur.sing 7271 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7272 
    args = getOrderForCustomer_args()
7273 
    args.read(iprot)
7274 
    iprot.readMessageEnd()
7275 
    result = getOrderForCustomer_result()
7276 
    try:
7277 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7278 
    except TransactionServiceException, ex:
7279 
      result.ex = ex
7280 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7281 
    result.write(oprot)
7282 
    oprot.writeMessageEnd()
7283 
    oprot.trans.flush()
7284 
 
3064 chandransh 7285 
  def process_getAlerts(self, seqid, iprot, oprot):
7286 
    args = getAlerts_args()
7287 
    args.read(iprot)
7288 
    iprot.readMessageEnd()
7289 
    result = getAlerts_result()
4444 rajveer 7290 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7291 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7292 
    result.write(oprot)
7293 
    oprot.writeMessageEnd()
7294 
    oprot.trans.flush()
7295 
 
4394 rajveer 7296 
  def process_addAlert(self, seqid, iprot, oprot):
7297 
    args = addAlert_args()
3064 chandransh 7298 
    args.read(iprot)
7299 
    iprot.readMessageEnd()
4394 rajveer 7300 
    result = addAlert_result()
4444 rajveer 7301 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7302 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7303 
    result.write(oprot)
7304 
    oprot.writeMessageEnd()
7305 
    oprot.trans.flush()
7306 
 
4444 rajveer 7307 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7308 
    args = markAlertsAsSeen_args()
7309 
    args.read(iprot)
7310 
    iprot.readMessageEnd()
7311 
    result = markAlertsAsSeen_result()
7312 
    self._handler.markAlertsAsSeen(args.warehouseId)
7313 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
7317 
 
3064 chandransh 7318 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7319 
    args = getValidOrderCount_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getValidOrderCount_result()
7323 
    result.success = self._handler.getValidOrderCount()
7324 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
7329 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7330 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7334 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7335 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
7340 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7341 
    args = getValidOrdersAmountRange_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = getValidOrdersAmountRange_result()
7345 
    result.success = self._handler.getValidOrdersAmountRange()
7346 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
7350 
 
7351 
  def process_getValidOrders(self, seqid, iprot, oprot):
7352 
    args = getValidOrders_args()
7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
7355 
    result = getValidOrders_result()
5874 rajveer 7356 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7357 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7358 
    result.write(oprot)
7359 
    oprot.writeMessageEnd()
7360 
    oprot.trans.flush()
7361 
 
1220 chandransh 7362 
  def process_batchOrders(self, seqid, iprot, oprot):
7363 
    args = batchOrders_args()
7364 
    args.read(iprot)
7365 
    iprot.readMessageEnd()
7366 
    result = batchOrders_result()
7367 
    try:
7368 
      result.success = self._handler.batchOrders(args.warehouseId)
7369 
    except TransactionServiceException, ex:
7370 
      result.ex = ex
7371 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7372 
    result.write(oprot)
7373 
    oprot.writeMessageEnd()
7374 
    oprot.trans.flush()
7375 
 
1208 chandransh 7376 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7377 
    args = markOrderAsOutOfStock_args()
7378 
    args.read(iprot)
7379 
    iprot.readMessageEnd()
7380 
    result = markOrderAsOutOfStock_result()
7381 
    try:
7382 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7383 
    except TransactionServiceException, ex:
7384 
      result.ex = ex
7385 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7386 
    result.write(oprot)
7387 
    oprot.writeMessageEnd()
7388 
    oprot.trans.flush()
7389 
 
3064 chandransh 7390 
  def process_verifyOrder(self, seqid, iprot, oprot):
7391 
    args = verifyOrder_args()
759 chandransh 7392 
    args.read(iprot)
7393 
    iprot.readMessageEnd()
3064 chandransh 7394 
    result = verifyOrder_result()
759 chandransh 7395 
    try:
3064 chandransh 7396 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7397 
    except TransactionServiceException, ex:
7398 
      result.ex = ex
3064 chandransh 7399 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7400 
    result.write(oprot)
7401 
    oprot.writeMessageEnd()
7402 
    oprot.trans.flush()
7403 
 
3064 chandransh 7404 
  def process_acceptOrder(self, seqid, iprot, oprot):
7405 
    args = acceptOrder_args()
1113 chandransh 7406 
    args.read(iprot)
7407 
    iprot.readMessageEnd()
3064 chandransh 7408 
    result = acceptOrder_result()
1113 chandransh 7409 
    try:
3064 chandransh 7410 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7411 
    except TransactionServiceException, ex:
7412 
      result.ex = ex
3064 chandransh 7413 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7414 
    result.write(oprot)
7415 
    oprot.writeMessageEnd()
7416 
    oprot.trans.flush()
7417 
 
3064 chandransh 7418 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7419 
    args = addBillingDetails_args()
1135 chandransh 7420 
    args.read(iprot)
7421 
    iprot.readMessageEnd()
3064 chandransh 7422 
    result = addBillingDetails_result()
1135 chandransh 7423 
    try:
5110 mandeep.dh 7424 
      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 7425 
    except TransactionServiceException, ex:
7426 
      result.ex = ex
3064 chandransh 7427 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7428 
    result.write(oprot)
7429 
    oprot.writeMessageEnd()
7430 
    oprot.trans.flush()
7431 
 
4579 rajveer 7432 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7433 
    args = addInvoiceNumber_args()
7434 
    args.read(iprot)
7435 
    iprot.readMessageEnd()
7436 
    result = addInvoiceNumber_result()
7437 
    try:
6756 amar.kumar 7438 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7439 
    except TransactionServiceException, ex:
7440 
      result.ex = ex
7441 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
4410 rajveer 7446 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7447 
    args = markOrdersAsShippedFromWarehouse_args()
7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
7450 
    result = markOrdersAsShippedFromWarehouse_result()
7451 
    try:
4789 rajveer 7452 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7453 
    except TransactionServiceException, ex:
7454 
      result.ex = ex
7455 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7456 
    result.write(oprot)
7457 
    oprot.writeMessageEnd()
7458 
    oprot.trans.flush()
7459 
 
5676 rajveer 7460 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7461 
    args = markOrdersAsReturnedFromStore_args()
7462 
    args.read(iprot)
7463 
    iprot.readMessageEnd()
7464 
    result = markOrdersAsReturnedFromStore_result()
7465 
    try:
5713 rajveer 7466 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7467 
    except TransactionServiceException, ex:
7468 
      result.ex = ex
7469 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7470 
    result.write(oprot)
7471 
    oprot.writeMessageEnd()
7472 
    oprot.trans.flush()
7473 
 
3064 chandransh 7474 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7475 
    args = markOrdersAsPickedUp_args()
304 ashish 7476 
    args.read(iprot)
7477 
    iprot.readMessageEnd()
3064 chandransh 7478 
    result = markOrdersAsPickedUp_result()
7479 
    try:
4910 phani.kuma 7480 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7481 
    except TransactionServiceException, ex:
7482 
      result.ex = ex
7483 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7484 
    result.write(oprot)
7485 
    oprot.writeMessageEnd()
7486 
    oprot.trans.flush()
94 ashish 7487 
 
4910 phani.kuma 7488 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7489 
    args = getOrdersNotPickedUp_args()
7490 
    args.read(iprot)
7491 
    iprot.readMessageEnd()
7492 
    result = getOrdersNotPickedUp_result()
7493 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7494 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7495 
    result.write(oprot)
7496 
    oprot.writeMessageEnd()
7497 
    oprot.trans.flush()
7498 
 
3064 chandransh 7499 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7500 
    args = markOrdersAsDelivered_args()
304 ashish 7501 
    args.read(iprot)
7502 
    iprot.readMessageEnd()
3064 chandransh 7503 
    result = markOrdersAsDelivered_result()
7504 
    try:
7505 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7506 
    except TransactionServiceException, ex:
7507 
      result.ex = ex
7508 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7509 
    result.write(oprot)
7510 
    oprot.writeMessageEnd()
7511 
    oprot.trans.flush()
7512 
 
4910 phani.kuma 7513 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7514 
    args = markAsRTOrders_args()
1596 ankur.sing 7515 
    args.read(iprot)
7516 
    iprot.readMessageEnd()
4910 phani.kuma 7517 
    result = markAsRTOrders_result()
3064 chandransh 7518 
    try:
4910 phani.kuma 7519 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7520 
    except TransactionServiceException, ex:
7521 
      result.ex = ex
4910 phani.kuma 7522 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7523 
    result.write(oprot)
7524 
    oprot.writeMessageEnd()
7525 
    oprot.trans.flush()
304 ashish 7526 
 
4910 phani.kuma 7527 
  def process_getRTOrders(self, seqid, iprot, oprot):
7528 
    args = getRTOrders_args()
7529 
    args.read(iprot)
7530 
    iprot.readMessageEnd()
7531 
    result = getRTOrders_result()
7532 
    result.success = self._handler.getRTOrders(args.providerId)
7533 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
7537 
 
3064 chandransh 7538 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7539 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
3064 chandransh 7542 
    result = updateNonDeliveryReason_result()
7543 
    try:
4910 phani.kuma 7544 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7545 
    except TransactionServiceException, ex:
7546 
      result.ex = ex
7547 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7548 
    result.write(oprot)
7549 
    oprot.writeMessageEnd()
7550 
    oprot.trans.flush()
1596 ankur.sing 7551 
 
4910 phani.kuma 7552 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7553 
    args = getNonDeliveredOrdersbyCourier_args()
7554 
    args.read(iprot)
7555 
    iprot.readMessageEnd()
7556 
    result = getNonDeliveredOrdersbyCourier_result()
7557 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7558 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
7563 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7564 
    args = markOrdersAsLocalConnected_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = markOrdersAsLocalConnected_result()
7568 
    try:
7569 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
7577 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7578 
    args = getOrdersNotLocalConnected_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = getOrdersNotLocalConnected_result()
7582 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7583 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
7587 
 
7588 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7589 
    args = markOrdersAsDestinationCityReached_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = markOrdersAsDestinationCityReached_result()
7593 
    try:
7594 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7595 
    except TransactionServiceException, ex:
7596 
      result.ex = ex
7597 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
7601 
 
7602 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7603 
    args = markOrdersAsFirstDeliveryAttempted_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = markOrdersAsFirstDeliveryAttempted_result()
7607 
    try:
7608 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7609 
    except TransactionServiceException, ex:
7610 
      result.ex = ex
7611 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7612 
    result.write(oprot)
7613 
    oprot.writeMessageEnd()
7614 
    oprot.trans.flush()
7615 
 
3064 chandransh 7616 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7617 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7618 
    args.read(iprot)
7619 
    iprot.readMessageEnd()
3064 chandransh 7620 
    result = getUndeliveredOrders_result()
7621 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7622 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7623 
    result.write(oprot)
7624 
    oprot.writeMessageEnd()
7625 
    oprot.trans.flush()
7626 
 
4783 phani.kuma 7627 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7628 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7629 
    args.read(iprot)
7630 
    iprot.readMessageEnd()
7631 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7632 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7633 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7634 
    result.write(oprot)
7635 
    oprot.writeMessageEnd()
7636 
    oprot.trans.flush()
7637 
 
2536 chandransh 7638 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7639 
    args = toggleDOAFlag_args()
7640 
    args.read(iprot)
7641 
    iprot.readMessageEnd()
7642 
    result = toggleDOAFlag_result()
7643 
    try:
7644 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7645 
    except TransactionServiceException, ex:
7646 
      result.ex = ex
7647 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7648 
    result.write(oprot)
7649 
    oprot.writeMessageEnd()
7650 
    oprot.trans.flush()
1886 ankur.sing 7651 
 
4712 rajveer 7652 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7653 
    args = markOrderAsDelivered_args()
7654 
    args.read(iprot)
7655 
    iprot.readMessageEnd()
7656 
    result = markOrderAsDelivered_result()
7657 
    try:
7658 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7659 
    except TransactionServiceException, ex:
7660 
      result.ex = ex
7661 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7662 
    result.write(oprot)
7663 
    oprot.writeMessageEnd()
7664 
    oprot.trans.flush()
7665 
 
5553 rajveer 7666 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7667 
    args = markOrderAsReceivedAtStore_args()
7668 
    args.read(iprot)
7669 
    iprot.readMessageEnd()
7670 
    result = markOrderAsReceivedAtStore_result()
7671 
    try:
7672 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7673 
    except TransactionServiceException, ex:
7674 
      result.ex = ex
7675 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7676 
    result.write(oprot)
7677 
    oprot.writeMessageEnd()
7678 
    oprot.trans.flush()
7679 
 
4454 rajveer 7680 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7681 
    args = markOrderDoaRequestReceived_args()
7682 
    args.read(iprot)
7683 
    iprot.readMessageEnd()
7684 
    result = markOrderDoaRequestReceived_result()
7685 
    try:
7686 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7687 
    except TransactionServiceException, ex:
7688 
      result.ex = ex
7689 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7690 
    result.write(oprot)
7691 
    oprot.writeMessageEnd()
7692 
    oprot.trans.flush()
7693 
 
7694 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7695 
    args = markOrderDoaRequestAuthorized_args()
7696 
    args.read(iprot)
7697 
    iprot.readMessageEnd()
7698 
    result = markOrderDoaRequestAuthorized_result()
7699 
    try:
7700 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7701 
    except TransactionServiceException, ex:
7702 
      result.ex = ex
7703 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7704 
    result.write(oprot)
7705 
    oprot.writeMessageEnd()
7706 
    oprot.trans.flush()
7707 
 
4488 rajveer 7708 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7709 
    args = markOrderReturnRequestReceived_args()
7710 
    args.read(iprot)
7711 
    iprot.readMessageEnd()
7712 
    result = markOrderReturnRequestReceived_result()
7713 
    try:
7714 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7715 
    except TransactionServiceException, ex:
7716 
      result.ex = ex
7717 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7718 
    result.write(oprot)
7719 
    oprot.writeMessageEnd()
7720 
    oprot.trans.flush()
7721 
 
7722 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7723 
    args = markOrderReturnRequestAuthorized_args()
7724 
    args.read(iprot)
7725 
    iprot.readMessageEnd()
7726 
    result = markOrderReturnRequestAuthorized_result()
7727 
    try:
7728 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7729 
    except TransactionServiceException, ex:
7730 
      result.ex = ex
7731 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7732 
    result.write(oprot)
7733 
    oprot.writeMessageEnd()
7734 
    oprot.trans.flush()
7735 
 
2536 chandransh 7736 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7737 
    args = requestPickupNumber_args()
7738 
    args.read(iprot)
7739 
    iprot.readMessageEnd()
7740 
    result = requestPickupNumber_result()
7741 
    try:
4579 rajveer 7742 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7743 
    except TransactionServiceException, ex:
7744 
      result.ex = ex
7745 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7746 
    result.write(oprot)
7747 
    oprot.writeMessageEnd()
7748 
    oprot.trans.flush()
7749 
 
7750 
  def process_authorizePickup(self, seqid, iprot, oprot):
7751 
    args = authorizePickup_args()
7752 
    args.read(iprot)
7753 
    iprot.readMessageEnd()
7754 
    result = authorizePickup_result()
7755 
    try:
4602 rajveer 7756 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7757 
    except TransactionServiceException, ex:
7758 
      result.ex = ex
7759 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7760 
    result.write(oprot)
7761 
    oprot.writeMessageEnd()
7762 
    oprot.trans.flush()
7763 
 
2764 chandransh 7764 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7765 
    args = markDoasAsPickedUp_args()
7766 
    args.read(iprot)
7767 
    iprot.readMessageEnd()
7768 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7769 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7770 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
7774 
 
4910 phani.kuma 7775 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7776 
    args = getDoasNotPickedUp_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = getDoasNotPickedUp_result()
7780 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7781 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
7785 
 
4741 phani.kuma 7786 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7787 
    args = markReturnOrdersAsPickedUp_args()
7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
7790 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7791 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7792 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
4910 phani.kuma 7797 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7798 
    args = getReturnOrdersNotPickedUp_args()
7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
7801 
    result = getReturnOrdersNotPickedUp_result()
7802 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7803 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7804 
    result.write(oprot)
7805 
    oprot.writeMessageEnd()
7806 
    oprot.trans.flush()
7807 
 
2616 chandransh 7808 
  def process_receiveReturn(self, seqid, iprot, oprot):
7809 
    args = receiveReturn_args()
2591 chandransh 7810 
    args.read(iprot)
7811 
    iprot.readMessageEnd()
2616 chandransh 7812 
    result = receiveReturn_result()
2591 chandransh 7813 
    try:
4479 rajveer 7814 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7815 
    except TransactionServiceException, ex:
7816 
      result.ex = ex
2616 chandransh 7817 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7818 
    result.write(oprot)
7819 
    oprot.writeMessageEnd()
7820 
    oprot.trans.flush()
2536 chandransh 7821 
 
2591 chandransh 7822 
  def process_validateDoa(self, seqid, iprot, oprot):
7823 
    args = validateDoa_args()
7824 
    args.read(iprot)
7825 
    iprot.readMessageEnd()
7826 
    result = validateDoa_result()
7827 
    try:
7828 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7829 
    except TransactionServiceException, ex:
7830 
      result.ex = ex
7831 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7832 
    result.write(oprot)
7833 
    oprot.writeMessageEnd()
7834 
    oprot.trans.flush()
7835 
 
4495 rajveer 7836 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7837 
    args = validateReturnProduct_args()
7838 
    args.read(iprot)
7839 
    iprot.readMessageEnd()
7840 
    result = validateReturnProduct_result()
7841 
    try:
7842 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7843 
    except TransactionServiceException, ex:
7844 
      result.ex = ex
7845 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7846 
    result.write(oprot)
7847 
    oprot.writeMessageEnd()
7848 
    oprot.trans.flush()
7849 
 
2616 chandransh 7850 
  def process_reshipOrder(self, seqid, iprot, oprot):
7851 
    args = reshipOrder_args()
7852 
    args.read(iprot)
7853 
    iprot.readMessageEnd()
7854 
    result = reshipOrder_result()
7855 
    try:
7856 
      result.success = self._handler.reshipOrder(args.orderId)
7857 
    except TransactionServiceException, ex:
7858 
      result.ex = ex
7859 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7860 
    result.write(oprot)
7861 
    oprot.writeMessageEnd()
7862 
    oprot.trans.flush()
2591 chandransh 7863 
 
2616 chandransh 7864 
  def process_refundOrder(self, seqid, iprot, oprot):
7865 
    args = refundOrder_args()
7866 
    args.read(iprot)
7867 
    iprot.readMessageEnd()
7868 
    result = refundOrder_result()
7869 
    try:
3226 chandransh 7870 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7871 
    except TransactionServiceException, ex:
7872 
      result.ex = ex
7873 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7874 
    result.write(oprot)
7875 
    oprot.writeMessageEnd()
7876 
    oprot.trans.flush()
7877 
 
2690 chandransh 7878 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7879 
    args = getReturnOrders_args()
7880 
    args.read(iprot)
7881 
    iprot.readMessageEnd()
7882 
    result = getReturnOrders_result()
7883 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7884 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7885 
    result.write(oprot)
7886 
    oprot.writeMessageEnd()
7887 
    oprot.trans.flush()
2616 chandransh 7888 
 
5481 phani.kuma 7889 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7890 
    args = getAllReturnOrders_args()
7891 
    args.read(iprot)
7892 
    iprot.readMessageEnd()
7893 
    result = getAllReturnOrders_result()
7894 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7895 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
2700 chandransh 7900 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7901 
    args = getReturnOrder_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = getReturnOrder_result()
7905 
    try:
7906 
      result.success = self._handler.getReturnOrder(args.id)
7907 
    except TransactionServiceException, ex:
7908 
      result.ex = ex
7909 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
7913 
 
2690 chandransh 7914 
  def process_processReturn(self, seqid, iprot, oprot):
7915 
    args = processReturn_args()
7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
7918 
    result = processReturn_result()
7919 
    try:
7920 
      self._handler.processReturn(args.returnOrderId)
7921 
    except TransactionServiceException, ex:
7922 
      result.ex = ex
7923 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
7927 
 
3451 chandransh 7928 
  def process_updateWeight(self, seqid, iprot, oprot):
7929 
    args = updateWeight_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = updateWeight_result()
7933 
    try:
7934 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7935 
    except TransactionServiceException, ex:
7936 
      result.ex = ex
7937 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7938 
    result.write(oprot)
7939 
    oprot.writeMessageEnd()
7940 
    oprot.trans.flush()
2819 chandransh 7941 
 
3469 chandransh 7942 
  def process_changeItem(self, seqid, iprot, oprot):
7943 
    args = changeItem_args()
7944 
    args.read(iprot)
7945 
    iprot.readMessageEnd()
7946 
    result = changeItem_result()
7947 
    try:
7948 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7949 
    except TransactionServiceException, ex:
7950 
      result.ex = ex
7951 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7952 
    result.write(oprot)
7953 
    oprot.writeMessageEnd()
7954 
    oprot.trans.flush()
3451 chandransh 7955 
 
3469 chandransh 7956 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7957 
    args = shiftToWarehouse_args()
7958 
    args.read(iprot)
7959 
    iprot.readMessageEnd()
7960 
    result = shiftToWarehouse_result()
7961 
    try:
7962 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7963 
    except TransactionServiceException, ex:
7964 
      result.ex = ex
7965 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7966 
    result.write(oprot)
7967 
    oprot.writeMessageEnd()
7968 
    oprot.trans.flush()
7969 
 
3553 chandransh 7970 
  def process_addDelayReason(self, seqid, iprot, oprot):
7971 
    args = addDelayReason_args()
7972 
    args.read(iprot)
7973 
    iprot.readMessageEnd()
7974 
    result = addDelayReason_result()
7975 
    try:
4647 rajveer 7976 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7977 
    except TransactionServiceException, ex:
7978 
      result.ex = ex
7979 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7980 
    result.write(oprot)
7981 
    oprot.writeMessageEnd()
7982 
    oprot.trans.flush()
3469 chandransh 7983 
 
3956 chandransh 7984 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7985 
    args = reconcileCodCollection_args()
7986 
    args.read(iprot)
7987 
    iprot.readMessageEnd()
7988 
    result = reconcileCodCollection_result()
7989 
    try:
7990 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7991 
    except TransactionServiceException, ex:
7992 
      result.ex = ex
7993 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7994 
    result.write(oprot)
7995 
    oprot.writeMessageEnd()
7996 
    oprot.trans.flush()
3553 chandransh 7997 
 
4008 mandeep.dh 7998 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7999 
    args = getTransactionsRequiringExtraProcessing_args()
8000 
    args.read(iprot)
8001 
    iprot.readMessageEnd()
8002 
    result = getTransactionsRequiringExtraProcessing_result()
8003 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8004 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8005 
    result.write(oprot)
8006 
    oprot.writeMessageEnd()
8007 
    oprot.trans.flush()
3956 chandransh 8008 
 
4008 mandeep.dh 8009 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8010 
    args = markTransactionAsProcessed_args()
8011 
    args.read(iprot)
8012 
    iprot.readMessageEnd()
8013 
    result = markTransactionAsProcessed_result()
8014 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8015 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8016 
    result.write(oprot)
8017 
    oprot.writeMessageEnd()
8018 
    oprot.trans.flush()
8019 
 
4018 chandransh 8020 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8021 
    args = getItemWiseRiskyOrdersCount_args()
8022 
    args.read(iprot)
8023 
    iprot.readMessageEnd()
8024 
    result = getItemWiseRiskyOrdersCount_result()
8025 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8026 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8027 
    result.write(oprot)
8028 
    oprot.writeMessageEnd()
8029 
    oprot.trans.flush()
4008 mandeep.dh 8030 
 
4295 varun.gupt 8031 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8032 
    args = getOrdersForItemIds_args()
8033 
    args.read(iprot)
8034 
    iprot.readMessageEnd()
8035 
    result = getOrdersForItemIds_result()
8036 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8037 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8038 
    result.write(oprot)
8039 
    oprot.writeMessageEnd()
8040 
    oprot.trans.flush()
8041 
 
4247 rajveer 8042 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8043 
    args = markOrderCancellationRequestReceived_args()
8044 
    args.read(iprot)
8045 
    iprot.readMessageEnd()
8046 
    result = markOrderCancellationRequestReceived_result()
8047 
    try:
8048 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8049 
    except TransactionServiceException, ex:
8050 
      result.ex = ex
8051 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8052 
    result.write(oprot)
8053 
    oprot.writeMessageEnd()
8054 
    oprot.trans.flush()
4018 chandransh 8055 
 
4247 rajveer 8056 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8057 
    args = markOrderCancellationRequestConfirmed_args()
8058 
    args.read(iprot)
8059 
    iprot.readMessageEnd()
8060 
    result = markOrderCancellationRequestConfirmed_result()
8061 
    try:
8062 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8063 
    except TransactionServiceException, ex:
8064 
      result.ex = ex
8065 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8066 
    result.write(oprot)
8067 
    oprot.writeMessageEnd()
8068 
    oprot.trans.flush()
8069 
 
8070 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8071 
    args = markOrderCancellationRequestDenied_args()
8072 
    args.read(iprot)
8073 
    iprot.readMessageEnd()
8074 
    result = markOrderCancellationRequestDenied_result()
8075 
    try:
8076 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8077 
    except TransactionServiceException, ex:
8078 
      result.ex = ex
8079 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8080 
    result.write(oprot)
8081 
    oprot.writeMessageEnd()
8082 
    oprot.trans.flush()
8083 
 
4258 rajveer 8084 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8085 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8086 
    args.read(iprot)
8087 
    iprot.readMessageEnd()
4258 rajveer 8088 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8089 
    try:
4258 rajveer 8090 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8091 
    except TransactionServiceException, ex:
8092 
      result.ex = ex
4258 rajveer 8093 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8094 
    result.write(oprot)
8095 
    oprot.writeMessageEnd()
8096 
    oprot.trans.flush()
8097 
 
4259 anupam.sin 8098 
  def process_refundTransaction(self, seqid, iprot, oprot):
8099 
    args = refundTransaction_args()
8100 
    args.read(iprot)
8101 
    iprot.readMessageEnd()
8102 
    result = refundTransaction_result()
8103 
    try:
8104 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8105 
    except TransactionServiceException, ex:
8106 
      result.ex = ex
8107 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8108 
    result.write(oprot)
8109 
    oprot.writeMessageEnd()
8110 
    oprot.trans.flush()
4247 rajveer 8111 
 
4324 mandeep.dh 8112 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8113 
    args = updateShipmentAddress_args()
8114 
    args.read(iprot)
8115 
    iprot.readMessageEnd()
8116 
    result = updateShipmentAddress_result()
8117 
    try:
8118 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8119 
    except TransactionServiceException, ex:
8120 
      result.ex = ex
8121 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8122 
    result.write(oprot)
8123 
    oprot.writeMessageEnd()
8124 
    oprot.trans.flush()
8125 
 
4285 rajveer 8126 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8127 
    args = acceptOrdersForItemId_args()
8128 
    args.read(iprot)
8129 
    iprot.readMessageEnd()
8130 
    result = acceptOrdersForItemId_result()
8131 
    try:
8132 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8133 
    except TransactionServiceException, ex:
8134 
      result.ex = ex
8135 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8136 
    result.write(oprot)
8137 
    oprot.writeMessageEnd()
8138 
    oprot.trans.flush()
4259 anupam.sin 8139 
 
4303 rajveer 8140 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8141 
    args = markOrdersAsPORaised_args()
8142 
    args.read(iprot)
8143 
    iprot.readMessageEnd()
8144 
    result = markOrdersAsPORaised_result()
8145 
    try:
4369 rajveer 8146 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8147 
    except TransactionServiceException, ex:
8148 
      result.ex = ex
8149 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8150 
    result.write(oprot)
8151 
    oprot.writeMessageEnd()
8152 
    oprot.trans.flush()
4285 rajveer 8153 
 
4303 rajveer 8154 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8155 
    args = markOrdersAsReversalInitiated_args()
8156 
    args.read(iprot)
8157 
    iprot.readMessageEnd()
8158 
    result = markOrdersAsReversalInitiated_result()
8159 
    try:
4369 rajveer 8160 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8161 
    except TransactionServiceException, ex:
8162 
      result.ex = ex
8163 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8164 
    result.write(oprot)
8165 
    oprot.writeMessageEnd()
8166 
    oprot.trans.flush()
8167 
 
8168 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8169 
    args = markOrdersAsNotAvailabke_args()
8170 
    args.read(iprot)
8171 
    iprot.readMessageEnd()
8172 
    result = markOrdersAsNotAvailabke_result()
8173 
    try:
4369 rajveer 8174 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8175 
    except TransactionServiceException, ex:
8176 
      result.ex = ex
8177 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8178 
    result.write(oprot)
8179 
    oprot.writeMessageEnd()
8180 
    oprot.trans.flush()
8181 
 
4369 rajveer 8182 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8183 
    args = markOrdersAsTimeout_args()
8184 
    args.read(iprot)
8185 
    iprot.readMessageEnd()
8186 
    result = markOrdersAsTimeout_result()
8187 
    try:
8188 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8189 
    except TransactionServiceException, ex:
8190 
      result.ex = ex
8191 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8192 
    result.write(oprot)
8193 
    oprot.writeMessageEnd()
8194 
    oprot.trans.flush()
4303 rajveer 8195 
 
4662 rajveer 8196 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8197 
    args = markOrderAsLostInTransit_args()
8198 
    args.read(iprot)
8199 
    iprot.readMessageEnd()
8200 
    result = markOrderAsLostInTransit_result()
8201 
    try:
8202 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8203 
    except TransactionServiceException, ex:
8204 
      result.ex = ex
8205 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8206 
    result.write(oprot)
8207 
    oprot.writeMessageEnd()
8208 
    oprot.trans.flush()
8209 
 
4386 anupam.sin 8210 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8211 
    args = getOrderForAwb_args()
8212 
    args.read(iprot)
8213 
    iprot.readMessageEnd()
8214 
    result = getOrderForAwb_result()
8215 
    try:
8216 
      result.success = self._handler.getOrderForAwb(args.awb)
8217 
    except TransactionServiceException, ex:
8218 
      result.ex = ex
8219 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8220 
    result.write(oprot)
8221 
    oprot.writeMessageEnd()
8222 
    oprot.trans.flush()
4369 rajveer 8223 
 
4506 phani.kuma 8224 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8225 
    args = getOrdersForProviderForStatus_args()
8226 
    args.read(iprot)
8227 
    iprot.readMessageEnd()
8228 
    result = getOrdersForProviderForStatus_result()
8229 
    try:
4910 phani.kuma 8230 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8231 
    except TransactionServiceException, ex:
8232 
      result.ex = ex
8233 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
4386 anupam.sin 8237 
 
4600 varun.gupt 8238 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8239 
    args = getBilledOrdersForVendor_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = getBilledOrdersForVendor_result()
8243 
    try:
8244 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8245 
    except TransactionServiceException, ex:
8246 
      result.ex = ex
8247 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8248 
    result.write(oprot)
8249 
    oprot.writeMessageEnd()
8250 
    oprot.trans.flush()
4506 phani.kuma 8251 
 
4607 rajveer 8252 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8253 
    args = getSlippedSippingDateOrders_args()
8254 
    args.read(iprot)
8255 
    iprot.readMessageEnd()
8256 
    result = getSlippedSippingDateOrders_result()
8257 
    try:
8258 
      result.success = self._handler.getSlippedSippingDateOrders()
8259 
    except TransactionServiceException, ex:
8260 
      result.ex = ex
8261 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
8265 
 
4709 rajveer 8266 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8267 
    args = getCancelledOrders_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = getCancelledOrders_result()
8271 
    try:
8272 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8273 
    except TransactionServiceException, ex:
8274 
      result.ex = ex
8275 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8276 
    result.write(oprot)
8277 
    oprot.writeMessageEnd()
8278 
    oprot.trans.flush()
8279 
 
4600 varun.gupt 8280 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8281 
    args = saveBluedartSettlements_args()
8282 
    args.read(iprot)
8283 
    iprot.readMessageEnd()
8284 
    result = saveBluedartSettlements_result()
8285 
    try:
8286 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8287 
    except TransactionServiceException, ex:
8288 
      result.ex = ex
8289 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8290 
    result.write(oprot)
8291 
    oprot.writeMessageEnd()
8292 
    oprot.trans.flush()
8293 
 
8294 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8295 
    args = savePaymentSettlements_args()
8296 
    args.read(iprot)
8297 
    iprot.readMessageEnd()
8298 
    result = savePaymentSettlements_result()
8299 
    try:
4905 varun.gupt 8300 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8301 
    except TransactionServiceException, ex:
8302 
      result.ex = ex
8303 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8304 
    result.write(oprot)
8305 
    oprot.writeMessageEnd()
8306 
    oprot.trans.flush()
8307 
 
8308 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8309 
    args = saveEBSSettlementSummary_args()
8310 
    args.read(iprot)
8311 
    iprot.readMessageEnd()
8312 
    result = saveEBSSettlementSummary_result()
8313 
    try:
8314 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8315 
    except TransactionServiceException, ex:
8316 
      result.ex = ex
8317 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8318 
    result.write(oprot)
8319 
    oprot.writeMessageEnd()
8320 
    oprot.trans.flush()
8321 
 
5386 phani.kuma 8322 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8323 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8324 
    args.read(iprot)
8325 
    iprot.readMessageEnd()
5386 phani.kuma 8326 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8327 
    try:
5386 phani.kuma 8328 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8329 
    except TransactionServiceException, ex:
8330 
      result.ex = ex
5386 phani.kuma 8331 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8332 
    result.write(oprot)
8333 
    oprot.writeMessageEnd()
8334 
    oprot.trans.flush()
8335 
 
5386 phani.kuma 8336 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8337 
    args = getSettlementForCod_args()
8338 
    args.read(iprot)
8339 
    iprot.readMessageEnd()
8340 
    result = getSettlementForCod_result()
8341 
    try:
8342 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8343 
    except TransactionServiceException, ex:
8344 
      result.ex = ex
8345 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8346 
    result.write(oprot)
8347 
    oprot.writeMessageEnd()
8348 
    oprot.trans.flush()
8349 
 
4600 varun.gupt 8350 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8351 
    args = getEBSSettlementSummaries_args()
8352 
    args.read(iprot)
8353 
    iprot.readMessageEnd()
8354 
    result = getEBSSettlementSummaries_result()
8355 
    try:
8356 
      result.success = self._handler.getEBSSettlementSummaries()
8357 
    except TransactionServiceException, ex:
8358 
      result.ex = ex
8359 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8360 
    result.write(oprot)
8361 
    oprot.writeMessageEnd()
8362 
    oprot.trans.flush()
8363 
 
8364 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8365 
    args = markEBSSettlementUploaded_args()
8366 
    args.read(iprot)
8367 
    iprot.readMessageEnd()
8368 
    result = markEBSSettlementUploaded_result()
8369 
    try:
8370 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8371 
    except TransactionServiceException, ex:
8372 
      result.ex = ex
8373 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8374 
    result.write(oprot)
8375 
    oprot.writeMessageEnd()
8376 
    oprot.trans.flush()
8377 
 
8378 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8379 
    args = getEBSSettlementDate_args()
8380 
    args.read(iprot)
8381 
    iprot.readMessageEnd()
8382 
    result = getEBSSettlementDate_result()
8383 
    try:
8384 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8385 
    except TransactionServiceException, ex:
8386 
      result.ex = ex
8387 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8388 
    result.write(oprot)
8389 
    oprot.writeMessageEnd()
8390 
    oprot.trans.flush()
8391 
 
4715 varun.gupt 8392 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8393 
    args = getSettlementsByDate_args()
8394 
    args.read(iprot)
8395 
    iprot.readMessageEnd()
8396 
    result = getSettlementsByDate_result()
8397 
    try:
8398 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8399 
    except TransactionServiceException, ex:
8400 
      result.ex = ex
8401 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
4600 varun.gupt 8405 
 
4715 varun.gupt 8406 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8407 
    args = getReshippedOrderIds_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = getReshippedOrderIds_result()
8411 
    try:
8412 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8413 
    except TransactionServiceException, ex:
8414 
      result.ex = ex
8415 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8416 
    result.write(oprot)
8417 
    oprot.writeMessageEnd()
8418 
    oprot.trans.flush()
8419 
 
5481 phani.kuma 8420 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8421 
    args = getBilledOrders_args()
4875 varun.gupt 8422 
    args.read(iprot)
8423 
    iprot.readMessageEnd()
5481 phani.kuma 8424 
    result = getBilledOrders_result()
4875 varun.gupt 8425 
    try:
5481 phani.kuma 8426 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8427 
    except TransactionServiceException, ex:
8428 
      result.ex = ex
5481 phani.kuma 8429 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8430 
    result.write(oprot)
8431 
    oprot.writeMessageEnd()
8432 
    oprot.trans.flush()
4757 mandeep.dh 8433 
 
5031 varun.gupt 8434 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8435 
    args = getStatusDistributionOfOrders_args()
8436 
    args.read(iprot)
8437 
    iprot.readMessageEnd()
8438 
    result = getStatusDistributionOfOrders_result()
8439 
    try:
8440 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8441 
    except TransactionServiceException, ex:
8442 
      result.ex = ex
8443 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8444 
    result.write(oprot)
8445 
    oprot.writeMessageEnd()
8446 
    oprot.trans.flush()
4875 varun.gupt 8447 
 
5067 varun.gupt 8448 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8449 
    args = getOrderIdsForStatus_args()
8450 
    args.read(iprot)
8451 
    iprot.readMessageEnd()
8452 
    result = getOrderIdsForStatus_result()
8453 
    try:
8454 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8455 
    except TransactionServiceException, ex:
8456 
      result.ex = ex
8457 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8458 
    result.write(oprot)
8459 
    oprot.writeMessageEnd()
8460 
    oprot.trans.flush()
5031 varun.gupt 8461 
 
5348 anupam.sin 8462 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8463 
    args = updateCODAgent_args()
8464 
    args.read(iprot)
8465 
    iprot.readMessageEnd()
8466 
    result = updateCODAgent_result()
8467 
    try:
8468 
      self._handler.updateCODAgent(args.agent, args.orderId)
8469 
    except TransactionServiceException, ex:
8470 
      result.ex = ex
8471 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8472 
    result.write(oprot)
8473 
    oprot.writeMessageEnd()
8474 
    oprot.trans.flush()
8475 
 
5099 varun.gupt 8476 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8477 
    args = updateOrderAsPaidToVendor_args()
8478 
    args.read(iprot)
8479 
    iprot.readMessageEnd()
8480 
    result = updateOrderAsPaidToVendor_result()
8481 
    try:
8482 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8483 
    except TransactionServiceException, ex:
8484 
      result.ex = ex
8485 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8486 
    result.write(oprot)
8487 
    oprot.writeMessageEnd()
8488 
    oprot.trans.flush()
5067 varun.gupt 8489 
 
5386 phani.kuma 8490 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8491 
    args = updateOrderOnlyAsPaidToVendor_args()
8492 
    args.read(iprot)
8493 
    iprot.readMessageEnd()
8494 
    result = updateOrderOnlyAsPaidToVendor_result()
8495 
    try:
8496 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8497 
    except TransactionServiceException, ex:
8498 
      result.ex = ex
8499 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8500 
    result.write(oprot)
8501 
    oprot.writeMessageEnd()
8502 
    oprot.trans.flush()
8503 
 
5208 varun.gupt 8504 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8505 
    args = getRefundedOrdersMarkedPaid_args()
8506 
    args.read(iprot)
8507 
    iprot.readMessageEnd()
8508 
    result = getRefundedOrdersMarkedPaid_result()
8509 
    try:
8510 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8511 
    except TransactionServiceException, ex:
8512 
      result.ex = ex
8513 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8514 
    result.write(oprot)
8515 
    oprot.writeMessageEnd()
8516 
    oprot.trans.flush()
5099 varun.gupt 8517 
 
5447 anupam.sin 8518 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8519 
    args = getAllVerificationAgents_args()
8520 
    args.read(iprot)
8521 
    iprot.readMessageEnd()
8522 
    result = getAllVerificationAgents_result()
8523 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8524 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8525 
    result.write(oprot)
8526 
    oprot.writeMessageEnd()
8527 
    oprot.trans.flush()
5208 varun.gupt 8528 
 
5527 anupam.sin 8529 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8530 
    args = getAllAttributesForOrderId_args()
8531 
    args.read(iprot)
8532 
    iprot.readMessageEnd()
8533 
    result = getAllAttributesForOrderId_result()
8534 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8535 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8536 
    result.write(oprot)
8537 
    oprot.writeMessageEnd()
8538 
    oprot.trans.flush()
5447 anupam.sin 8539 
 
5676 rajveer 8540 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8541 
    args = setOrderAttributes_args()
8542 
    args.read(iprot)
8543 
    iprot.readMessageEnd()
8544 
    result = setOrderAttributes_result()
8545 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8546 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8547 
    result.write(oprot)
8548 
    oprot.writeMessageEnd()
8549 
    oprot.trans.flush()
8550 
 
5527 anupam.sin 8551 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8552 
    args = setOrderAttributeForTransaction_args()
8553 
    args.read(iprot)
8554 
    iprot.readMessageEnd()
8555 
    result = setOrderAttributeForTransaction_result()
8556 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8557 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8558 
    result.write(oprot)
8559 
    oprot.writeMessageEnd()
8560 
    oprot.trans.flush()
8561 
 
5553 rajveer 8562 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8563 
    args = getReceivePendingOrders_args()
8564 
    args.read(iprot)
8565 
    iprot.readMessageEnd()
8566 
    result = getReceivePendingOrders_result()
8567 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8568 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8569 
    result.write(oprot)
8570 
    oprot.writeMessageEnd()
8571 
    oprot.trans.flush()
5527 anupam.sin 8572 
 
5553 rajveer 8573 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8574 
    args = getReceivedAtStoreOrders_args()
8575 
    args.read(iprot)
8576 
    iprot.readMessageEnd()
8577 
    result = getReceivedAtStoreOrders_result()
8578 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8579 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8580 
    result.write(oprot)
8581 
    oprot.writeMessageEnd()
8582 
    oprot.trans.flush()
8583 
 
5713 rajveer 8584 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8585 
    args = getOrdersCollectionAtStore_args()
8586 
    args.read(iprot)
8587 
    iprot.readMessageEnd()
8588 
    result = getOrdersCollectionAtStore_result()
8589 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8590 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8591 
    result.write(oprot)
8592 
    oprot.writeMessageEnd()
8593 
    oprot.trans.flush()
8594 
 
5833 rajveer 8595 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8596 
    args = getOrderAttributeValue_args()
8597 
    args.read(iprot)
8598 
    iprot.readMessageEnd()
8599 
    result = getOrderAttributeValue_result()
8600 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8601 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8602 
    result.write(oprot)
8603 
    oprot.writeMessageEnd()
8604 
    oprot.trans.flush()
8605 
 
6019 rajveer 8606 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8607 
    args = changeJacketNumber_args()
8608 
    args.read(iprot)
8609 
    iprot.readMessageEnd()
8610 
    result = changeJacketNumber_result()
8611 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8612 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8613 
    result.write(oprot)
8614 
    oprot.writeMessageEnd()
8615 
    oprot.trans.flush()
8616 
 
8617 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8618 
    args = markOrderAsRtoInTransit_args()
8619 
    args.read(iprot)
8620 
    iprot.readMessageEnd()
8621 
    result = markOrderAsRtoInTransit_result()
8622 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8623 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8624 
    result.write(oprot)
8625 
    oprot.writeMessageEnd()
8626 
    oprot.trans.flush()
8627 
 
5593 mandeep.dh 8628 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8629 
    args = acceptOrderForItem_args()
8630 
    args.read(iprot)
8631 
    iprot.readMessageEnd()
8632 
    result = acceptOrderForItem_result()
8633 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8634 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8635 
    result.write(oprot)
8636 
    oprot.writeMessageEnd()
8637 
    oprot.trans.flush()
5553 rajveer 8638 
 
6000 mandeep.dh 8639 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8640 
    args = createRechargeOrder_args()
8641 
    args.read(iprot)
8642 
    iprot.readMessageEnd()
8643 
    result = createRechargeOrder_result()
8644 
    try:
8645 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8646 
    except TransactionServiceException, ex:
8647 
      result.ex = ex
8648 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8649 
    result.write(oprot)
8650 
    oprot.writeMessageEnd()
8651 
    oprot.trans.flush()
5593 mandeep.dh 8652 
 
6031 rajveer 8653 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8654 
    args = getRechargeOrder_args()
8655 
    args.read(iprot)
8656 
    iprot.readMessageEnd()
8657 
    result = getRechargeOrder_result()
8658 
    try:
8659 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8660 
    except TransactionServiceException, ex:
8661 
      result.ex = ex
8662 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8663 
    result.write(oprot)
8664 
    oprot.writeMessageEnd()
8665 
    oprot.trans.flush()
8666 
 
8667 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8668 
    args = getRechargeOrders_args()
8669 
    args.read(iprot)
8670 
    iprot.readMessageEnd()
8671 
    result = getRechargeOrders_result()
8672 
    result.success = self._handler.getRechargeOrders(args.userId)
8673 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8674 
    result.write(oprot)
8675 
    oprot.writeMessageEnd()
8676 
    oprot.trans.flush()
8677 
 
6000 mandeep.dh 8678 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8679 
    args = updateRechargeOrderStatus_args()
8680 
    args.read(iprot)
8681 
    iprot.readMessageEnd()
8682 
    result = updateRechargeOrderStatus_result()
8683 
    try:
6031 rajveer 8684 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8685 
    except TransactionServiceException, ex:
8686 
      result.ex = ex
8687 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8688 
    result.write(oprot)
8689 
    oprot.writeMessageEnd()
8690 
    oprot.trans.flush()
8691 
 
8692 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8693 
    args = activateRechargeTxn_args()
8694 
    args.read(iprot)
8695 
    iprot.readMessageEnd()
8696 
    result = activateRechargeTxn_result()
8697 
    try:
6031 rajveer 8698 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8699 
    except TransactionServiceException, ex:
8700 
      result.ex = ex
8701 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8702 
    result.write(oprot)
8703 
    oprot.writeMessageEnd()
8704 
    oprot.trans.flush()
8705 
 
6031 rajveer 8706 
  def process_getUserWallet(self, seqid, iprot, oprot):
8707 
    args = getUserWallet_args()
6000 mandeep.dh 8708 
    args.read(iprot)
8709 
    iprot.readMessageEnd()
6031 rajveer 8710 
    result = getUserWallet_result()
8711 
    result.success = self._handler.getUserWallet(args.userId)
8712 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8713 
    result.write(oprot)
8714 
    oprot.writeMessageEnd()
8715 
    oprot.trans.flush()
8716 
 
6031 rajveer 8717 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8718 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8719 
    args.read(iprot)
8720 
    iprot.readMessageEnd()
6031 rajveer 8721 
    result = getUserWalletHistory_result()
8722 
    result.success = self._handler.getUserWalletHistory(args.userId)
8723 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8724 
    result.write(oprot)
8725 
    oprot.writeMessageEnd()
8726 
    oprot.trans.flush()
8727 
 
6050 anupam.sin 8728 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8729 
    args = getRechargeOrdersForTransaction_args()
8730 
    args.read(iprot)
8731 
    iprot.readMessageEnd()
8732 
    result = getRechargeOrdersForTransaction_result()
8733 
    try:
8734 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8735 
    except TransactionServiceException, ex:
8736 
      result.ex = ex
8737 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8738 
    result.write(oprot)
8739 
    oprot.writeMessageEnd()
8740 
    oprot.trans.flush()
8741 
 
6048 rajveer 8742 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8743 
    args = getServiceProviders_args()
8744 
    args.read(iprot)
8745 
    iprot.readMessageEnd()
8746 
    result = getServiceProviders_result()
6206 rajveer 8747 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8748 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8749 
    result.write(oprot)
8750 
    oprot.writeMessageEnd()
8751 
    oprot.trans.flush()
6000 mandeep.dh 8752 
 
6048 rajveer 8753 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8754 
    args = getServiceProviderForDevice_args()
8755 
    args.read(iprot)
8756 
    iprot.readMessageEnd()
8757 
    result = getServiceProviderForDevice_result()
6049 rajveer 8758 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8759 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8760 
    result.write(oprot)
8761 
    oprot.writeMessageEnd()
8762 
    oprot.trans.flush()
8763 
 
6269 rajveer 8764 
  def process_validateRecharge(self, seqid, iprot, oprot):
8765 
    args = validateRecharge_args()
8766 
    args.read(iprot)
8767 
    iprot.readMessageEnd()
8768 
    result = validateRecharge_result()
6591 anupam.sin 8769 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8770 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8771 
    result.write(oprot)
8772 
    oprot.writeMessageEnd()
8773 
    oprot.trans.flush()
8774 
 
6094 rajveer 8775 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8776 
    args = getRechargeOrdersForDevice_args()
8777 
    args.read(iprot)
8778 
    iprot.readMessageEnd()
8779 
    result = getRechargeOrdersForDevice_result()
8780 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8781 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8782 
    result.write(oprot)
8783 
    oprot.writeMessageEnd()
8784 
    oprot.trans.flush()
6048 rajveer 8785 
 
6094 rajveer 8786 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8787 
    args = addAmountToWallet_args()
8788 
    args.read(iprot)
8789 
    iprot.readMessageEnd()
8790 
    result = addAmountToWallet_result()
8791 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8792 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8793 
    result.write(oprot)
8794 
    oprot.writeMessageEnd()
8795 
    oprot.trans.flush()
8796 
 
6188 rajveer 8797 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8798 
    args = getRechargeStatistics_args()
8799 
    args.read(iprot)
8800 
    iprot.readMessageEnd()
8801 
    result = getRechargeStatistics_result()
8802 
    result.success = self._handler.getRechargeStatistics()
8803 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8804 
    result.write(oprot)
8805 
    oprot.writeMessageEnd()
8806 
    oprot.trans.flush()
8807 
 
6154 rajveer 8808 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8809 
    args = getRechargeOrdersForStatus_args()
8810 
    args.read(iprot)
8811 
    iprot.readMessageEnd()
8812 
    result = getRechargeOrdersForStatus_result()
8813 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8814 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8815 
    result.write(oprot)
8816 
    oprot.writeMessageEnd()
8817 
    oprot.trans.flush()
6094 rajveer 8818 
 
6159 rajveer 8819 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8820 
    args = getPlansForOperator_args()
8821 
    args.read(iprot)
8822 
    iprot.readMessageEnd()
8823 
    result = getPlansForOperator_result()
8824 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8825 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8826 
    result.write(oprot)
8827 
    oprot.writeMessageEnd()
8828 
    oprot.trans.flush()
6154 rajveer 8829 
 
6289 anupam.sin 8830 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8831 
    args = getRechargeDenominations_args()
8832 
    args.read(iprot)
8833 
    iprot.readMessageEnd()
8834 
    result = getRechargeDenominations_result()
8835 
    try:
6307 anupam.sin 8836 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8837 
    except TransactionServiceException, ex:
8838 
      result.ex = ex
8839 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8840 
    result.write(oprot)
8841 
    oprot.writeMessageEnd()
8842 
    oprot.trans.flush()
6159 rajveer 8843 
 
6371 rajveer 8844 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8845 
    args = updateAvailabilityStatus_args()
8846 
    args.read(iprot)
8847 
    iprot.readMessageEnd()
8848 
    result = updateAvailabilityStatus_result()
8849 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8850 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8851 
    result.write(oprot)
8852 
    oprot.writeMessageEnd()
8853 
    oprot.trans.flush()
6289 anupam.sin 8854 
 
6389 rajveer 8855 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8856 
    args = getAvailableEmiSchemes_args()
8857 
    args.read(iprot)
8858 
    iprot.readMessageEnd()
8859 
    result = getAvailableEmiSchemes_result()
8860 
    result.success = self._handler.getAvailableEmiSchemes()
8861 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8862 
    result.write(oprot)
8863 
    oprot.writeMessageEnd()
8864 
    oprot.trans.flush()
6371 rajveer 8865 
 
6389 rajveer 8866 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8867 
    args = getMiscCharges_args()
8868 
    args.read(iprot)
8869 
    iprot.readMessageEnd()
8870 
    result = getMiscCharges_result()
8871 
    result.success = self._handler.getMiscCharges(args.transactionId)
8872 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8873 
    result.write(oprot)
8874 
    oprot.writeMessageEnd()
8875 
    oprot.trans.flush()
8876 
 
6507 anupam.sin 8877 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8878 
    args = refundRechargeOrder_args()
8879 
    args.read(iprot)
8880 
    iprot.readMessageEnd()
8881 
    result = refundRechargeOrder_result()
8882 
    try:
8883 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8884 
    except TransactionServiceException, ex:
8885 
      result.ex = ex
8886 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8887 
    result.write(oprot)
8888 
    oprot.writeMessageEnd()
8889 
    oprot.trans.flush()
6389 rajveer 8890 
 
6821 amar.kumar 8891 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8892 
    args = getPhysicalOrders_args()
8893 
    args.read(iprot)
8894 
    iprot.readMessageEnd()
8895 
    result = getPhysicalOrders_result()
8896 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8897 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8898 
    result.write(oprot)
8899 
    oprot.writeMessageEnd()
8900 
    oprot.trans.flush()
6507 anupam.sin 8901 
 
6906 rajveer 8902 
  def process_getDocument(self, seqid, iprot, oprot):
8903 
    args = getDocument_args()
8904 
    args.read(iprot)
8905 
    iprot.readMessageEnd()
8906 
    result = getDocument_result()
8907 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8908 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8909 
    result.write(oprot)
8910 
    oprot.writeMessageEnd()
8911 
    oprot.trans.flush()
6821 amar.kumar 8912 
 
6985 anupam.sin 8913 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8914 
    args = changeShippingAddress_args()
8915 
    args.read(iprot)
8916 
    iprot.readMessageEnd()
8917 
    result = changeShippingAddress_result()
8918 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8919 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8920 
    result.write(oprot)
8921 
    oprot.writeMessageEnd()
8922 
    oprot.trans.flush()
6906 rajveer 8923 
 
6988 rajveer 8924 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
8925 
    args = retrieveInvoice_args()
8926 
    args.read(iprot)
8927 
    iprot.readMessageEnd()
8928 
    result = retrieveInvoice_result()
7075 rajveer 8929 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 8930 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
8931 
    result.write(oprot)
8932 
    oprot.writeMessageEnd()
8933 
    oprot.trans.flush()
6985 anupam.sin 8934 
 
7026 rajveer 8935 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
8936 
    args = receiveUpdatesForRedExpress_args()
8937 
    args.read(iprot)
8938 
    iprot.readMessageEnd()
8939 
    result = receiveUpdatesForRedExpress_result()
8940 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
8941 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
8942 
    result.write(oprot)
8943 
    oprot.writeMessageEnd()
8944 
    oprot.trans.flush()
6988 rajveer 8945 
 
7073 anupam.sin 8946 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
8947 
    args = createRechargeTransaction_args()
8948 
    args.read(iprot)
8949 
    iprot.readMessageEnd()
8950 
    result = createRechargeTransaction_result()
8951 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
8952 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
8953 
    result.write(oprot)
8954 
    oprot.writeMessageEnd()
8955 
    oprot.trans.flush()
7026 rajveer 8956 
 
7073 anupam.sin 8957 
 
94 ashish 8958 
# HELPER FUNCTIONS AND STRUCTURES
8959 
 
8960 
class createTransaction_args:
8961 
  """
8962 
  Attributes:
8963 
   - transaction
8964 
  """
8965 
 
8966 
  thrift_spec = (
8967 
    None, # 0
8968 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8969 
  )
8970 
 
8971 
  def __init__(self, transaction=None,):
8972 
    self.transaction = transaction
8973 
 
8974 
  def read(self, iprot):
8975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8977 
      return
8978 
    iprot.readStructBegin()
8979 
    while True:
8980 
      (fname, ftype, fid) = iprot.readFieldBegin()
8981 
      if ftype == TType.STOP:
8982 
        break
8983 
      if fid == 1:
8984 
        if ftype == TType.STRUCT:
8985 
          self.transaction = Transaction()
8986 
          self.transaction.read(iprot)
8987 
        else:
8988 
          iprot.skip(ftype)
8989 
      else:
8990 
        iprot.skip(ftype)
8991 
      iprot.readFieldEnd()
8992 
    iprot.readStructEnd()
8993 
 
8994 
  def write(self, oprot):
8995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8997 
      return
8998 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8999 
    if self.transaction is not None:
94 ashish 9000 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9001 
      self.transaction.write(oprot)
9002 
      oprot.writeFieldEnd()
9003 
    oprot.writeFieldStop()
9004 
    oprot.writeStructEnd()
9005 
 
3431 rajveer 9006 
  def validate(self):
9007 
    return
9008 
 
9009 
 
94 ashish 9010 
  def __repr__(self):
9011 
    L = ['%s=%r' % (key, value)
9012 
      for key, value in self.__dict__.iteritems()]
9013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9014 
 
9015 
  def __eq__(self, other):
9016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9017 
 
9018 
  def __ne__(self, other):
9019 
    return not (self == other)
9020 
 
9021 
class createTransaction_result:
9022 
  """
9023 
  Attributes:
132 ashish 9024 
   - success
94 ashish 9025 
   - ex
9026 
  """
9027 
 
9028 
  thrift_spec = (
132 ashish 9029 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9031 
  )
9032 
 
132 ashish 9033 
  def __init__(self, success=None, ex=None,):
9034 
    self.success = success
94 ashish 9035 
    self.ex = ex
9036 
 
9037 
  def read(self, iprot):
9038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9040 
      return
9041 
    iprot.readStructBegin()
9042 
    while True:
9043 
      (fname, ftype, fid) = iprot.readFieldBegin()
9044 
      if ftype == TType.STOP:
9045 
        break
132 ashish 9046 
      if fid == 0:
9047 
        if ftype == TType.I64:
9048 
          self.success = iprot.readI64();
9049 
        else:
9050 
          iprot.skip(ftype)
9051 
      elif fid == 1:
94 ashish 9052 
        if ftype == TType.STRUCT:
9053 
          self.ex = TransactionServiceException()
9054 
          self.ex.read(iprot)
9055 
        else:
9056 
          iprot.skip(ftype)
9057 
      else:
9058 
        iprot.skip(ftype)
9059 
      iprot.readFieldEnd()
9060 
    iprot.readStructEnd()
9061 
 
9062 
  def write(self, oprot):
9063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9065 
      return
9066 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9067 
    if self.success is not None:
132 ashish 9068 
      oprot.writeFieldBegin('success', TType.I64, 0)
9069 
      oprot.writeI64(self.success)
9070 
      oprot.writeFieldEnd()
3431 rajveer 9071 
    if self.ex is not None:
94 ashish 9072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9073 
      self.ex.write(oprot)
9074 
      oprot.writeFieldEnd()
9075 
    oprot.writeFieldStop()
9076 
    oprot.writeStructEnd()
9077 
 
3431 rajveer 9078 
  def validate(self):
9079 
    return
9080 
 
9081 
 
94 ashish 9082 
  def __repr__(self):
9083 
    L = ['%s=%r' % (key, value)
9084 
      for key, value in self.__dict__.iteritems()]
9085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9086 
 
9087 
  def __eq__(self, other):
9088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9089 
 
9090 
  def __ne__(self, other):
9091 
    return not (self == other)
9092 
 
9093 
class getTransaction_args:
9094 
  """
9095 
  Attributes:
9096 
   - id
9097 
  """
9098 
 
9099 
  thrift_spec = (
9100 
    None, # 0
9101 
    (1, TType.I64, 'id', None, None, ), # 1
9102 
  )
9103 
 
9104 
  def __init__(self, id=None,):
9105 
    self.id = id
9106 
 
9107 
  def read(self, iprot):
9108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9110 
      return
9111 
    iprot.readStructBegin()
9112 
    while True:
9113 
      (fname, ftype, fid) = iprot.readFieldBegin()
9114 
      if ftype == TType.STOP:
9115 
        break
9116 
      if fid == 1:
9117 
        if ftype == TType.I64:
9118 
          self.id = iprot.readI64();
9119 
        else:
9120 
          iprot.skip(ftype)
9121 
      else:
9122 
        iprot.skip(ftype)
9123 
      iprot.readFieldEnd()
9124 
    iprot.readStructEnd()
9125 
 
9126 
  def write(self, oprot):
9127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9129 
      return
9130 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9131 
    if self.id is not None:
94 ashish 9132 
      oprot.writeFieldBegin('id', TType.I64, 1)
9133 
      oprot.writeI64(self.id)
9134 
      oprot.writeFieldEnd()
9135 
    oprot.writeFieldStop()
9136 
    oprot.writeStructEnd()
9137 
 
3431 rajveer 9138 
  def validate(self):
9139 
    return
9140 
 
9141 
 
94 ashish 9142 
  def __repr__(self):
9143 
    L = ['%s=%r' % (key, value)
9144 
      for key, value in self.__dict__.iteritems()]
9145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9146 
 
9147 
  def __eq__(self, other):
9148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9149 
 
9150 
  def __ne__(self, other):
9151 
    return not (self == other)
9152 
 
9153 
class getTransaction_result:
9154 
  """
9155 
  Attributes:
9156 
   - success
9157 
   - ex
9158 
  """
9159 
 
9160 
  thrift_spec = (
9161 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9163 
  )
9164 
 
9165 
  def __init__(self, success=None, ex=None,):
9166 
    self.success = success
9167 
    self.ex = ex
9168 
 
9169 
  def read(self, iprot):
9170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9172 
      return
9173 
    iprot.readStructBegin()
9174 
    while True:
9175 
      (fname, ftype, fid) = iprot.readFieldBegin()
9176 
      if ftype == TType.STOP:
9177 
        break
9178 
      if fid == 0:
9179 
        if ftype == TType.STRUCT:
9180 
          self.success = Transaction()
9181 
          self.success.read(iprot)
9182 
        else:
9183 
          iprot.skip(ftype)
9184 
      elif fid == 1:
9185 
        if ftype == TType.STRUCT:
9186 
          self.ex = TransactionServiceException()
9187 
          self.ex.read(iprot)
9188 
        else:
9189 
          iprot.skip(ftype)
9190 
      else:
9191 
        iprot.skip(ftype)
9192 
      iprot.readFieldEnd()
9193 
    iprot.readStructEnd()
9194 
 
9195 
  def write(self, oprot):
9196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9198 
      return
9199 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9200 
    if self.success is not None:
94 ashish 9201 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9202 
      self.success.write(oprot)
9203 
      oprot.writeFieldEnd()
3431 rajveer 9204 
    if self.ex is not None:
94 ashish 9205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9206 
      self.ex.write(oprot)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
3431 rajveer 9211 
  def validate(self):
9212 
    return
9213 
 
9214 
 
94 ashish 9215 
  def __repr__(self):
9216 
    L = ['%s=%r' % (key, value)
9217 
      for key, value in self.__dict__.iteritems()]
9218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9219 
 
9220 
  def __eq__(self, other):
9221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9222 
 
9223 
  def __ne__(self, other):
9224 
    return not (self == other)
9225 
 
9226 
class getTransactionsForCustomer_args:
9227 
  """
9228 
  Attributes:
9229 
   - customerId
9230 
   - from_date
9231 
   - to_date
9232 
   - status
9233 
  """
9234 
 
9235 
  thrift_spec = (
9236 
    None, # 0
9237 
    (1, TType.I64, 'customerId', None, None, ), # 1
9238 
    (2, TType.I64, 'from_date', None, None, ), # 2
9239 
    (3, TType.I64, 'to_date', None, None, ), # 3
9240 
    (4, TType.I32, 'status', None, None, ), # 4
9241 
  )
9242 
 
9243 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9244 
    self.customerId = customerId
9245 
    self.from_date = from_date
9246 
    self.to_date = to_date
9247 
    self.status = status
9248 
 
9249 
  def read(self, iprot):
9250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9252 
      return
9253 
    iprot.readStructBegin()
9254 
    while True:
9255 
      (fname, ftype, fid) = iprot.readFieldBegin()
9256 
      if ftype == TType.STOP:
9257 
        break
9258 
      if fid == 1:
9259 
        if ftype == TType.I64:
9260 
          self.customerId = iprot.readI64();
9261 
        else:
9262 
          iprot.skip(ftype)
9263 
      elif fid == 2:
9264 
        if ftype == TType.I64:
9265 
          self.from_date = iprot.readI64();
9266 
        else:
9267 
          iprot.skip(ftype)
9268 
      elif fid == 3:
9269 
        if ftype == TType.I64:
9270 
          self.to_date = iprot.readI64();
9271 
        else:
9272 
          iprot.skip(ftype)
9273 
      elif fid == 4:
9274 
        if ftype == TType.I32:
9275 
          self.status = iprot.readI32();
9276 
        else:
9277 
          iprot.skip(ftype)
9278 
      else:
9279 
        iprot.skip(ftype)
9280 
      iprot.readFieldEnd()
9281 
    iprot.readStructEnd()
9282 
 
9283 
  def write(self, oprot):
9284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9286 
      return
9287 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9288 
    if self.customerId is not None:
94 ashish 9289 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9290 
      oprot.writeI64(self.customerId)
9291 
      oprot.writeFieldEnd()
3431 rajveer 9292 
    if self.from_date is not None:
94 ashish 9293 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9294 
      oprot.writeI64(self.from_date)
9295 
      oprot.writeFieldEnd()
3431 rajveer 9296 
    if self.to_date is not None:
94 ashish 9297 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9298 
      oprot.writeI64(self.to_date)
9299 
      oprot.writeFieldEnd()
3431 rajveer 9300 
    if self.status is not None:
94 ashish 9301 
      oprot.writeFieldBegin('status', TType.I32, 4)
9302 
      oprot.writeI32(self.status)
9303 
      oprot.writeFieldEnd()
9304 
    oprot.writeFieldStop()
9305 
    oprot.writeStructEnd()
9306 
 
3431 rajveer 9307 
  def validate(self):
9308 
    return
9309 
 
9310 
 
94 ashish 9311 
  def __repr__(self):
9312 
    L = ['%s=%r' % (key, value)
9313 
      for key, value in self.__dict__.iteritems()]
9314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9315 
 
9316 
  def __eq__(self, other):
9317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9318 
 
9319 
  def __ne__(self, other):
9320 
    return not (self == other)
9321 
 
9322 
class getTransactionsForCustomer_result:
9323 
  """
9324 
  Attributes:
9325 
   - success
9326 
   - ex
9327 
  """
9328 
 
9329 
  thrift_spec = (
9330 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9331 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9332 
  )
9333 
 
9334 
  def __init__(self, success=None, ex=None,):
9335 
    self.success = success
9336 
    self.ex = ex
9337 
 
9338 
  def read(self, iprot):
9339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9341 
      return
9342 
    iprot.readStructBegin()
9343 
    while True:
9344 
      (fname, ftype, fid) = iprot.readFieldBegin()
9345 
      if ftype == TType.STOP:
9346 
        break
9347 
      if fid == 0:
9348 
        if ftype == TType.LIST:
9349 
          self.success = []
6188 rajveer 9350 
          (_etype109, _size106) = iprot.readListBegin()
9351 
          for _i110 in xrange(_size106):
9352 
            _elem111 = Transaction()
9353 
            _elem111.read(iprot)
9354 
            self.success.append(_elem111)
94 ashish 9355 
          iprot.readListEnd()
9356 
        else:
9357 
          iprot.skip(ftype)
9358 
      elif fid == 1:
9359 
        if ftype == TType.STRUCT:
9360 
          self.ex = TransactionServiceException()
9361 
          self.ex.read(iprot)
9362 
        else:
9363 
          iprot.skip(ftype)
9364 
      else:
9365 
        iprot.skip(ftype)
9366 
      iprot.readFieldEnd()
9367 
    iprot.readStructEnd()
9368 
 
9369 
  def write(self, oprot):
9370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9372 
      return
9373 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9374 
    if self.success is not None:
94 ashish 9375 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9376 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9377 
      for iter112 in self.success:
9378 
        iter112.write(oprot)
94 ashish 9379 
      oprot.writeListEnd()
9380 
      oprot.writeFieldEnd()
3431 rajveer 9381 
    if self.ex is not None:
94 ashish 9382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9383 
      self.ex.write(oprot)
9384 
      oprot.writeFieldEnd()
9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
94 ashish 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
132 ashish 9403 
class getTransactionsForShoppingCartId_args:
9404 
  """
9405 
  Attributes:
9406 
   - shoppingCartId
9407 
  """
9408 
 
9409 
  thrift_spec = (
9410 
    None, # 0
9411 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9412 
  )
9413 
 
9414 
  def __init__(self, shoppingCartId=None,):
9415 
    self.shoppingCartId = shoppingCartId
9416 
 
9417 
  def read(self, iprot):
9418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9420 
      return
9421 
    iprot.readStructBegin()
9422 
    while True:
9423 
      (fname, ftype, fid) = iprot.readFieldBegin()
9424 
      if ftype == TType.STOP:
9425 
        break
9426 
      if fid == 1:
9427 
        if ftype == TType.I64:
9428 
          self.shoppingCartId = iprot.readI64();
9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      else:
9432 
        iprot.skip(ftype)
9433 
      iprot.readFieldEnd()
9434 
    iprot.readStructEnd()
9435 
 
9436 
  def write(self, oprot):
9437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9439 
      return
9440 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9441 
    if self.shoppingCartId is not None:
132 ashish 9442 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9443 
      oprot.writeI64(self.shoppingCartId)
9444 
      oprot.writeFieldEnd()
9445 
    oprot.writeFieldStop()
9446 
    oprot.writeStructEnd()
9447 
 
3431 rajveer 9448 
  def validate(self):
9449 
    return
9450 
 
9451 
 
132 ashish 9452 
  def __repr__(self):
9453 
    L = ['%s=%r' % (key, value)
9454 
      for key, value in self.__dict__.iteritems()]
9455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9456 
 
9457 
  def __eq__(self, other):
9458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9459 
 
9460 
  def __ne__(self, other):
9461 
    return not (self == other)
9462 
 
9463 
class getTransactionsForShoppingCartId_result:
9464 
  """
9465 
  Attributes:
9466 
   - success
9467 
   - ex
9468 
  """
9469 
 
9470 
  thrift_spec = (
9471 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9473 
  )
9474 
 
9475 
  def __init__(self, success=None, ex=None,):
9476 
    self.success = success
9477 
    self.ex = ex
9478 
 
9479 
  def read(self, iprot):
9480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9482 
      return
9483 
    iprot.readStructBegin()
9484 
    while True:
9485 
      (fname, ftype, fid) = iprot.readFieldBegin()
9486 
      if ftype == TType.STOP:
9487 
        break
9488 
      if fid == 0:
9489 
        if ftype == TType.LIST:
9490 
          self.success = []
6188 rajveer 9491 
          (_etype116, _size113) = iprot.readListBegin()
9492 
          for _i117 in xrange(_size113):
9493 
            _elem118 = Transaction()
9494 
            _elem118.read(iprot)
9495 
            self.success.append(_elem118)
132 ashish 9496 
          iprot.readListEnd()
9497 
        else:
9498 
          iprot.skip(ftype)
9499 
      elif fid == 1:
9500 
        if ftype == TType.STRUCT:
9501 
          self.ex = TransactionServiceException()
9502 
          self.ex.read(iprot)
9503 
        else:
9504 
          iprot.skip(ftype)
9505 
      else:
9506 
        iprot.skip(ftype)
9507 
      iprot.readFieldEnd()
9508 
    iprot.readStructEnd()
9509 
 
9510 
  def write(self, oprot):
9511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9513 
      return
9514 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9515 
    if self.success is not None:
132 ashish 9516 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9517 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9518 
      for iter119 in self.success:
9519 
        iter119.write(oprot)
132 ashish 9520 
      oprot.writeListEnd()
9521 
      oprot.writeFieldEnd()
3431 rajveer 9522 
    if self.ex is not None:
132 ashish 9523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9524 
      self.ex.write(oprot)
9525 
      oprot.writeFieldEnd()
9526 
    oprot.writeFieldStop()
9527 
    oprot.writeStructEnd()
9528 
 
3431 rajveer 9529 
  def validate(self):
9530 
    return
9531 
 
9532 
 
132 ashish 9533 
  def __repr__(self):
9534 
    L = ['%s=%r' % (key, value)
9535 
      for key, value in self.__dict__.iteritems()]
9536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9537 
 
9538 
  def __eq__(self, other):
9539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9540 
 
9541 
  def __ne__(self, other):
9542 
    return not (self == other)
9543 
 
94 ashish 9544 
class getTransactionStatus_args:
9545 
  """
9546 
  Attributes:
9547 
   - transactionId
9548 
  """
9549 
 
9550 
  thrift_spec = (
9551 
    None, # 0
9552 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9553 
  )
9554 
 
9555 
  def __init__(self, transactionId=None,):
9556 
    self.transactionId = transactionId
9557 
 
9558 
  def read(self, iprot):
9559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9561 
      return
9562 
    iprot.readStructBegin()
9563 
    while True:
9564 
      (fname, ftype, fid) = iprot.readFieldBegin()
9565 
      if ftype == TType.STOP:
9566 
        break
9567 
      if fid == 1:
9568 
        if ftype == TType.I64:
9569 
          self.transactionId = iprot.readI64();
9570 
        else:
9571 
          iprot.skip(ftype)
9572 
      else:
9573 
        iprot.skip(ftype)
9574 
      iprot.readFieldEnd()
9575 
    iprot.readStructEnd()
9576 
 
9577 
  def write(self, oprot):
9578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9580 
      return
9581 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9582 
    if self.transactionId is not None:
94 ashish 9583 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9584 
      oprot.writeI64(self.transactionId)
9585 
      oprot.writeFieldEnd()
9586 
    oprot.writeFieldStop()
9587 
    oprot.writeStructEnd()
9588 
 
3431 rajveer 9589 
  def validate(self):
9590 
    return
9591 
 
9592 
 
94 ashish 9593 
  def __repr__(self):
9594 
    L = ['%s=%r' % (key, value)
9595 
      for key, value in self.__dict__.iteritems()]
9596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9597 
 
9598 
  def __eq__(self, other):
9599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9600 
 
9601 
  def __ne__(self, other):
9602 
    return not (self == other)
9603 
 
9604 
class getTransactionStatus_result:
9605 
  """
9606 
  Attributes:
9607 
   - success
9608 
   - ex
9609 
  """
9610 
 
9611 
  thrift_spec = (
9612 
    (0, TType.I32, 'success', None, None, ), # 0
9613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9614 
  )
9615 
 
9616 
  def __init__(self, success=None, ex=None,):
9617 
    self.success = success
9618 
    self.ex = ex
9619 
 
9620 
  def read(self, iprot):
9621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9623 
      return
9624 
    iprot.readStructBegin()
9625 
    while True:
9626 
      (fname, ftype, fid) = iprot.readFieldBegin()
9627 
      if ftype == TType.STOP:
9628 
        break
9629 
      if fid == 0:
9630 
        if ftype == TType.I32:
9631 
          self.success = iprot.readI32();
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      elif fid == 1:
9635 
        if ftype == TType.STRUCT:
9636 
          self.ex = TransactionServiceException()
9637 
          self.ex.read(iprot)
9638 
        else:
9639 
          iprot.skip(ftype)
9640 
      else:
9641 
        iprot.skip(ftype)
9642 
      iprot.readFieldEnd()
9643 
    iprot.readStructEnd()
9644 
 
9645 
  def write(self, oprot):
9646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9648 
      return
9649 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9650 
    if self.success is not None:
94 ashish 9651 
      oprot.writeFieldBegin('success', TType.I32, 0)
9652 
      oprot.writeI32(self.success)
9653 
      oprot.writeFieldEnd()
3431 rajveer 9654 
    if self.ex is not None:
94 ashish 9655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9656 
      self.ex.write(oprot)
9657 
      oprot.writeFieldEnd()
9658 
    oprot.writeFieldStop()
9659 
    oprot.writeStructEnd()
9660 
 
3431 rajveer 9661 
  def validate(self):
9662 
    return
9663 
 
9664 
 
94 ashish 9665 
  def __repr__(self):
9666 
    L = ['%s=%r' % (key, value)
9667 
      for key, value in self.__dict__.iteritems()]
9668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9669 
 
9670 
  def __eq__(self, other):
9671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9672 
 
9673 
  def __ne__(self, other):
9674 
    return not (self == other)
9675 
 
9676 
class changeTransactionStatus_args:
9677 
  """
9678 
  Attributes:
9679 
   - transactionId
9680 
   - status
9681 
   - description
5527 anupam.sin 9682 
   - pickUp
9683 
   - orderType
94 ashish 9684 
  """
9685 
 
9686 
  thrift_spec = (
9687 
    None, # 0
9688 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9689 
    (2, TType.I32, 'status', None, None, ), # 2
9690 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9691 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9692 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9693 
  )
9694 
 
5527 anupam.sin 9695 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9696 
    self.transactionId = transactionId
9697 
    self.status = status
9698 
    self.description = description
5527 anupam.sin 9699 
    self.pickUp = pickUp
9700 
    self.orderType = orderType
94 ashish 9701 
 
9702 
  def read(self, iprot):
9703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9705 
      return
9706 
    iprot.readStructBegin()
9707 
    while True:
9708 
      (fname, ftype, fid) = iprot.readFieldBegin()
9709 
      if ftype == TType.STOP:
9710 
        break
9711 
      if fid == 1:
9712 
        if ftype == TType.I64:
9713 
          self.transactionId = iprot.readI64();
9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      elif fid == 2:
9717 
        if ftype == TType.I32:
9718 
          self.status = iprot.readI32();
9719 
        else:
9720 
          iprot.skip(ftype)
9721 
      elif fid == 3:
9722 
        if ftype == TType.STRING:
9723 
          self.description = iprot.readString();
9724 
        else:
9725 
          iprot.skip(ftype)
5387 rajveer 9726 
      elif fid == 4:
5527 anupam.sin 9727 
        if ftype == TType.I64:
9728 
          self.pickUp = iprot.readI64();
5387 rajveer 9729 
        else:
9730 
          iprot.skip(ftype)
5527 anupam.sin 9731 
      elif fid == 5:
9732 
        if ftype == TType.I32:
9733 
          self.orderType = iprot.readI32();
9734 
        else:
9735 
          iprot.skip(ftype)
94 ashish 9736 
      else:
9737 
        iprot.skip(ftype)
9738 
      iprot.readFieldEnd()
9739 
    iprot.readStructEnd()
9740 
 
9741 
  def write(self, oprot):
9742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9744 
      return
9745 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9746 
    if self.transactionId is not None:
94 ashish 9747 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9748 
      oprot.writeI64(self.transactionId)
9749 
      oprot.writeFieldEnd()
3431 rajveer 9750 
    if self.status is not None:
94 ashish 9751 
      oprot.writeFieldBegin('status', TType.I32, 2)
9752 
      oprot.writeI32(self.status)
9753 
      oprot.writeFieldEnd()
3431 rajveer 9754 
    if self.description is not None:
94 ashish 9755 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9756 
      oprot.writeString(self.description)
9757 
      oprot.writeFieldEnd()
5527 anupam.sin 9758 
    if self.pickUp is not None:
9759 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9760 
      oprot.writeI64(self.pickUp)
5387 rajveer 9761 
      oprot.writeFieldEnd()
5527 anupam.sin 9762 
    if self.orderType is not None:
9763 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9764 
      oprot.writeI32(self.orderType)
9765 
      oprot.writeFieldEnd()
94 ashish 9766 
    oprot.writeFieldStop()
9767 
    oprot.writeStructEnd()
9768 
 
3431 rajveer 9769 
  def validate(self):
9770 
    return
9771 
 
9772 
 
94 ashish 9773 
  def __repr__(self):
9774 
    L = ['%s=%r' % (key, value)
9775 
      for key, value in self.__dict__.iteritems()]
9776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9777 
 
9778 
  def __eq__(self, other):
9779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9780 
 
9781 
  def __ne__(self, other):
9782 
    return not (self == other)
9783 
 
9784 
class changeTransactionStatus_result:
9785 
  """
9786 
  Attributes:
9787 
   - success
9788 
   - ex
9789 
  """
9790 
 
9791 
  thrift_spec = (
9792 
    (0, TType.BOOL, 'success', None, None, ), # 0
9793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9794 
  )
9795 
 
9796 
  def __init__(self, success=None, ex=None,):
9797 
    self.success = success
9798 
    self.ex = ex
9799 
 
9800 
  def read(self, iprot):
9801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9803 
      return
9804 
    iprot.readStructBegin()
9805 
    while True:
9806 
      (fname, ftype, fid) = iprot.readFieldBegin()
9807 
      if ftype == TType.STOP:
9808 
        break
9809 
      if fid == 0:
9810 
        if ftype == TType.BOOL:
9811 
          self.success = iprot.readBool();
9812 
        else:
9813 
          iprot.skip(ftype)
9814 
      elif fid == 1:
9815 
        if ftype == TType.STRUCT:
9816 
          self.ex = TransactionServiceException()
9817 
          self.ex.read(iprot)
9818 
        else:
9819 
          iprot.skip(ftype)
9820 
      else:
9821 
        iprot.skip(ftype)
9822 
      iprot.readFieldEnd()
9823 
    iprot.readStructEnd()
9824 
 
9825 
  def write(self, oprot):
9826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9828 
      return
9829 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9830 
    if self.success is not None:
94 ashish 9831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9832 
      oprot.writeBool(self.success)
9833 
      oprot.writeFieldEnd()
3431 rajveer 9834 
    if self.ex is not None:
94 ashish 9835 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9836 
      self.ex.write(oprot)
9837 
      oprot.writeFieldEnd()
9838 
    oprot.writeFieldStop()
9839 
    oprot.writeStructEnd()
9840 
 
3431 rajveer 9841 
  def validate(self):
9842 
    return
9843 
 
9844 
 
94 ashish 9845 
  def __repr__(self):
9846 
    L = ['%s=%r' % (key, value)
9847 
      for key, value in self.__dict__.iteritems()]
9848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9849 
 
9850 
  def __eq__(self, other):
9851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9852 
 
9853 
  def __ne__(self, other):
9854 
    return not (self == other)
9855 
 
1398 varun.gupt 9856 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9857 
  """
9858 
  Attributes:
9859 
   - transactionId
9860 
  """
9861 
 
9862 
  thrift_spec = (
9863 
    None, # 0
9864 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9865 
  )
9866 
 
9867 
  def __init__(self, transactionId=None,):
9868 
    self.transactionId = transactionId
9869 
 
9870 
  def read(self, iprot):
9871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9873 
      return
9874 
    iprot.readStructBegin()
9875 
    while True:
9876 
      (fname, ftype, fid) = iprot.readFieldBegin()
9877 
      if ftype == TType.STOP:
9878 
        break
9879 
      if fid == 1:
9880 
        if ftype == TType.I64:
9881 
          self.transactionId = iprot.readI64();
9882 
        else:
9883 
          iprot.skip(ftype)
9884 
      else:
9885 
        iprot.skip(ftype)
9886 
      iprot.readFieldEnd()
9887 
    iprot.readStructEnd()
9888 
 
9889 
  def write(self, oprot):
9890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9892 
      return
1398 varun.gupt 9893 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9894 
    if self.transactionId is not None:
1382 varun.gupt 9895 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9896 
      oprot.writeI64(self.transactionId)
9897 
      oprot.writeFieldEnd()
9898 
    oprot.writeFieldStop()
9899 
    oprot.writeStructEnd()
9900 
 
3431 rajveer 9901 
  def validate(self):
9902 
    return
9903 
 
9904 
 
1382 varun.gupt 9905 
  def __repr__(self):
9906 
    L = ['%s=%r' % (key, value)
9907 
      for key, value in self.__dict__.iteritems()]
9908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9909 
 
9910 
  def __eq__(self, other):
9911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9912 
 
9913 
  def __ne__(self, other):
9914 
    return not (self == other)
9915 
 
1398 varun.gupt 9916 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9917 
  """
9918 
  Attributes:
9919 
   - success
9920 
   - ex
9921 
  """
9922 
 
9923 
  thrift_spec = (
9924 
    (0, TType.BOOL, 'success', None, None, ), # 0
9925 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9926 
  )
9927 
 
9928 
  def __init__(self, success=None, ex=None,):
9929 
    self.success = success
9930 
    self.ex = ex
9931 
 
9932 
  def read(self, iprot):
9933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9935 
      return
9936 
    iprot.readStructBegin()
9937 
    while True:
9938 
      (fname, ftype, fid) = iprot.readFieldBegin()
9939 
      if ftype == TType.STOP:
9940 
        break
9941 
      if fid == 0:
9942 
        if ftype == TType.BOOL:
9943 
          self.success = iprot.readBool();
9944 
        else:
9945 
          iprot.skip(ftype)
9946 
      elif fid == 1:
9947 
        if ftype == TType.STRUCT:
9948 
          self.ex = TransactionServiceException()
9949 
          self.ex.read(iprot)
9950 
        else:
9951 
          iprot.skip(ftype)
9952 
      else:
9953 
        iprot.skip(ftype)
9954 
      iprot.readFieldEnd()
9955 
    iprot.readStructEnd()
9956 
 
9957 
  def write(self, oprot):
9958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9960 
      return
1398 varun.gupt 9961 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9962 
    if self.success is not None:
1382 varun.gupt 9963 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9964 
      oprot.writeBool(self.success)
9965 
      oprot.writeFieldEnd()
3431 rajveer 9966 
    if self.ex is not None:
1382 varun.gupt 9967 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9968 
      self.ex.write(oprot)
9969 
      oprot.writeFieldEnd()
9970 
    oprot.writeFieldStop()
9971 
    oprot.writeStructEnd()
9972 
 
3431 rajveer 9973 
  def validate(self):
9974 
    return
9975 
 
9976 
 
1382 varun.gupt 9977 
  def __repr__(self):
9978 
    L = ['%s=%r' % (key, value)
9979 
      for key, value in self.__dict__.iteritems()]
9980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9981 
 
9982 
  def __eq__(self, other):
9983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9984 
 
9985 
  def __ne__(self, other):
9986 
    return not (self == other)
9987 
 
483 rajveer 9988 
class getAllOrders_args:
94 ashish 9989 
  """
9990 
  Attributes:
4801 anupam.sin 9991 
   - statuses
483 rajveer 9992 
   - from_date
9993 
   - to_date
9994 
   - warehouse_id
94 ashish 9995 
  """
9996 
 
9997 
  thrift_spec = (
9998 
    None, # 0
4801 anupam.sin 9999 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10000 
    (2, TType.I64, 'from_date', None, None, ), # 2
10001 
    (3, TType.I64, 'to_date', None, None, ), # 3
10002 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10003 
  )
10004 
 
4801 anupam.sin 10005 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10006 
    self.statuses = statuses
483 rajveer 10007 
    self.from_date = from_date
10008 
    self.to_date = to_date
10009 
    self.warehouse_id = warehouse_id
94 ashish 10010 
 
10011 
  def read(self, iprot):
10012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10014 
      return
10015 
    iprot.readStructBegin()
10016 
    while True:
10017 
      (fname, ftype, fid) = iprot.readFieldBegin()
10018 
      if ftype == TType.STOP:
10019 
        break
10020 
      if fid == 1:
4801 anupam.sin 10021 
        if ftype == TType.LIST:
10022 
          self.statuses = []
6188 rajveer 10023 
          (_etype123, _size120) = iprot.readListBegin()
10024 
          for _i124 in xrange(_size120):
10025 
            _elem125 = iprot.readI32();
10026 
            self.statuses.append(_elem125)
4801 anupam.sin 10027 
          iprot.readListEnd()
94 ashish 10028 
        else:
10029 
          iprot.skip(ftype)
483 rajveer 10030 
      elif fid == 2:
10031 
        if ftype == TType.I64:
10032 
          self.from_date = iprot.readI64();
94 ashish 10033 
        else:
10034 
          iprot.skip(ftype)
483 rajveer 10035 
      elif fid == 3:
10036 
        if ftype == TType.I64:
10037 
          self.to_date = iprot.readI64();
94 ashish 10038 
        else:
10039 
          iprot.skip(ftype)
483 rajveer 10040 
      elif fid == 4:
94 ashish 10041 
        if ftype == TType.I64:
483 rajveer 10042 
          self.warehouse_id = iprot.readI64();
94 ashish 10043 
        else:
10044 
          iprot.skip(ftype)
10045 
      else:
10046 
        iprot.skip(ftype)
10047 
      iprot.readFieldEnd()
10048 
    iprot.readStructEnd()
10049 
 
10050 
  def write(self, oprot):
10051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10053 
      return
483 rajveer 10054 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10055 
    if self.statuses is not None:
10056 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10057 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10058 
      for iter126 in self.statuses:
10059 
        oprot.writeI32(iter126)
4801 anupam.sin 10060 
      oprot.writeListEnd()
94 ashish 10061 
      oprot.writeFieldEnd()
3431 rajveer 10062 
    if self.from_date is not None:
483 rajveer 10063 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10064 
      oprot.writeI64(self.from_date)
94 ashish 10065 
      oprot.writeFieldEnd()
3431 rajveer 10066 
    if self.to_date is not None:
483 rajveer 10067 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10068 
      oprot.writeI64(self.to_date)
94 ashish 10069 
      oprot.writeFieldEnd()
3431 rajveer 10070 
    if self.warehouse_id is not None:
483 rajveer 10071 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10072 
      oprot.writeI64(self.warehouse_id)
94 ashish 10073 
      oprot.writeFieldEnd()
10074 
    oprot.writeFieldStop()
10075 
    oprot.writeStructEnd()
10076 
 
3431 rajveer 10077 
  def validate(self):
10078 
    return
10079 
 
10080 
 
94 ashish 10081 
  def __repr__(self):
10082 
    L = ['%s=%r' % (key, value)
10083 
      for key, value in self.__dict__.iteritems()]
10084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10085 
 
10086 
  def __eq__(self, other):
10087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10088 
 
10089 
  def __ne__(self, other):
10090 
    return not (self == other)
10091 
 
483 rajveer 10092 
class getAllOrders_result:
94 ashish 10093 
  """
10094 
  Attributes:
10095 
   - success
10096 
   - ex
10097 
  """
10098 
 
10099 
  thrift_spec = (
483 rajveer 10100 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10101 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10102 
  )
10103 
 
10104 
  def __init__(self, success=None, ex=None,):
10105 
    self.success = success
10106 
    self.ex = ex
10107 
 
10108 
  def read(self, iprot):
10109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10111 
      return
10112 
    iprot.readStructBegin()
10113 
    while True:
10114 
      (fname, ftype, fid) = iprot.readFieldBegin()
10115 
      if ftype == TType.STOP:
10116 
        break
10117 
      if fid == 0:
483 rajveer 10118 
        if ftype == TType.LIST:
10119 
          self.success = []
6188 rajveer 10120 
          (_etype130, _size127) = iprot.readListBegin()
10121 
          for _i131 in xrange(_size127):
10122 
            _elem132 = Order()
10123 
            _elem132.read(iprot)
10124 
            self.success.append(_elem132)
483 rajveer 10125 
          iprot.readListEnd()
94 ashish 10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      elif fid == 1:
10129 
        if ftype == TType.STRUCT:
10130 
          self.ex = TransactionServiceException()
10131 
          self.ex.read(iprot)
10132 
        else:
10133 
          iprot.skip(ftype)
10134 
      else:
10135 
        iprot.skip(ftype)
10136 
      iprot.readFieldEnd()
10137 
    iprot.readStructEnd()
10138 
 
10139 
  def write(self, oprot):
10140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10142 
      return
483 rajveer 10143 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10144 
    if self.success is not None:
483 rajveer 10145 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10146 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10147 
      for iter133 in self.success:
10148 
        iter133.write(oprot)
483 rajveer 10149 
      oprot.writeListEnd()
94 ashish 10150 
      oprot.writeFieldEnd()
3431 rajveer 10151 
    if self.ex is not None:
94 ashish 10152 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10153 
      self.ex.write(oprot)
10154 
      oprot.writeFieldEnd()
10155 
    oprot.writeFieldStop()
10156 
    oprot.writeStructEnd()
10157 
 
3431 rajveer 10158 
  def validate(self):
10159 
    return
10160 
 
10161 
 
94 ashish 10162 
  def __repr__(self):
10163 
    L = ['%s=%r' % (key, value)
10164 
      for key, value in self.__dict__.iteritems()]
10165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10166 
 
10167 
  def __eq__(self, other):
10168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10169 
 
10170 
  def __ne__(self, other):
10171 
    return not (self == other)
10172 
 
4133 chandransh 10173 
class getOrdersInBatch_args:
10174 
  """
10175 
  Attributes:
10176 
   - statuses
10177 
   - offset
10178 
   - limit
10179 
   - warehouse_id
10180 
  """
10181 
 
10182 
  thrift_spec = (
10183 
    None, # 0
10184 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10185 
    (2, TType.I64, 'offset', None, None, ), # 2
10186 
    (3, TType.I64, 'limit', None, None, ), # 3
10187 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10188 
  )
10189 
 
10190 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10191 
    self.statuses = statuses
10192 
    self.offset = offset
10193 
    self.limit = limit
10194 
    self.warehouse_id = warehouse_id
10195 
 
10196 
  def read(self, iprot):
10197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10199 
      return
10200 
    iprot.readStructBegin()
10201 
    while True:
10202 
      (fname, ftype, fid) = iprot.readFieldBegin()
10203 
      if ftype == TType.STOP:
10204 
        break
10205 
      if fid == 1:
10206 
        if ftype == TType.LIST:
10207 
          self.statuses = []
6188 rajveer 10208 
          (_etype137, _size134) = iprot.readListBegin()
10209 
          for _i138 in xrange(_size134):
10210 
            _elem139 = iprot.readI32();
10211 
            self.statuses.append(_elem139)
4133 chandransh 10212 
          iprot.readListEnd()
10213 
        else:
10214 
          iprot.skip(ftype)
10215 
      elif fid == 2:
10216 
        if ftype == TType.I64:
10217 
          self.offset = iprot.readI64();
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      elif fid == 3:
10221 
        if ftype == TType.I64:
10222 
          self.limit = iprot.readI64();
10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      elif fid == 4:
10226 
        if ftype == TType.I64:
10227 
          self.warehouse_id = iprot.readI64();
10228 
        else:
10229 
          iprot.skip(ftype)
10230 
      else:
10231 
        iprot.skip(ftype)
10232 
      iprot.readFieldEnd()
10233 
    iprot.readStructEnd()
10234 
 
10235 
  def write(self, oprot):
10236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10238 
      return
10239 
    oprot.writeStructBegin('getOrdersInBatch_args')
10240 
    if self.statuses is not None:
10241 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10242 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10243 
      for iter140 in self.statuses:
10244 
        oprot.writeI32(iter140)
4133 chandransh 10245 
      oprot.writeListEnd()
10246 
      oprot.writeFieldEnd()
10247 
    if self.offset is not None:
10248 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10249 
      oprot.writeI64(self.offset)
10250 
      oprot.writeFieldEnd()
10251 
    if self.limit is not None:
10252 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10253 
      oprot.writeI64(self.limit)
10254 
      oprot.writeFieldEnd()
10255 
    if self.warehouse_id is not None:
10256 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10257 
      oprot.writeI64(self.warehouse_id)
10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
10262 
  def validate(self):
10263 
    return
10264 
 
10265 
 
10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
10277 
class getOrdersInBatch_result:
10278 
  """
10279 
  Attributes:
10280 
   - success
10281 
   - ex
10282 
  """
10283 
 
10284 
  thrift_spec = (
10285 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10287 
  )
10288 
 
10289 
  def __init__(self, success=None, ex=None,):
10290 
    self.success = success
10291 
    self.ex = ex
10292 
 
10293 
  def read(self, iprot):
10294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10296 
      return
10297 
    iprot.readStructBegin()
10298 
    while True:
10299 
      (fname, ftype, fid) = iprot.readFieldBegin()
10300 
      if ftype == TType.STOP:
10301 
        break
10302 
      if fid == 0:
10303 
        if ftype == TType.LIST:
10304 
          self.success = []
6188 rajveer 10305 
          (_etype144, _size141) = iprot.readListBegin()
10306 
          for _i145 in xrange(_size141):
10307 
            _elem146 = Order()
10308 
            _elem146.read(iprot)
10309 
            self.success.append(_elem146)
4133 chandransh 10310 
          iprot.readListEnd()
10311 
        else:
10312 
          iprot.skip(ftype)
10313 
      elif fid == 1:
10314 
        if ftype == TType.STRUCT:
10315 
          self.ex = TransactionServiceException()
10316 
          self.ex.read(iprot)
10317 
        else:
10318 
          iprot.skip(ftype)
10319 
      else:
10320 
        iprot.skip(ftype)
10321 
      iprot.readFieldEnd()
10322 
    iprot.readStructEnd()
10323 
 
10324 
  def write(self, oprot):
10325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10327 
      return
10328 
    oprot.writeStructBegin('getOrdersInBatch_result')
10329 
    if self.success is not None:
10330 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10331 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10332 
      for iter147 in self.success:
10333 
        iter147.write(oprot)
4133 chandransh 10334 
      oprot.writeListEnd()
10335 
      oprot.writeFieldEnd()
10336 
    if self.ex is not None:
10337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10338 
      self.ex.write(oprot)
10339 
      oprot.writeFieldEnd()
10340 
    oprot.writeFieldStop()
10341 
    oprot.writeStructEnd()
10342 
 
10343 
  def validate(self):
10344 
    return
10345 
 
10346 
 
10347 
  def __repr__(self):
10348 
    L = ['%s=%r' % (key, value)
10349 
      for key, value in self.__dict__.iteritems()]
10350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10351 
 
10352 
  def __eq__(self, other):
10353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10354 
 
10355 
  def __ne__(self, other):
10356 
    return not (self == other)
10357 
 
10358 
class getOrderCount_args:
10359 
  """
10360 
  Attributes:
10361 
   - statuses
10362 
   - warehouseId
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    None, # 0
10367 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10368 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10369 
  )
10370 
 
10371 
  def __init__(self, statuses=None, warehouseId=None,):
10372 
    self.statuses = statuses
10373 
    self.warehouseId = warehouseId
10374 
 
10375 
  def read(self, iprot):
10376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10378 
      return
10379 
    iprot.readStructBegin()
10380 
    while True:
10381 
      (fname, ftype, fid) = iprot.readFieldBegin()
10382 
      if ftype == TType.STOP:
10383 
        break
10384 
      if fid == 1:
10385 
        if ftype == TType.LIST:
10386 
          self.statuses = []
6188 rajveer 10387 
          (_etype151, _size148) = iprot.readListBegin()
10388 
          for _i152 in xrange(_size148):
10389 
            _elem153 = iprot.readI32();
10390 
            self.statuses.append(_elem153)
4133 chandransh 10391 
          iprot.readListEnd()
10392 
        else:
10393 
          iprot.skip(ftype)
10394 
      elif fid == 2:
10395 
        if ftype == TType.I64:
10396 
          self.warehouseId = iprot.readI64();
10397 
        else:
10398 
          iprot.skip(ftype)
10399 
      else:
10400 
        iprot.skip(ftype)
10401 
      iprot.readFieldEnd()
10402 
    iprot.readStructEnd()
10403 
 
10404 
  def write(self, oprot):
10405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10407 
      return
10408 
    oprot.writeStructBegin('getOrderCount_args')
10409 
    if self.statuses is not None:
10410 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10411 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10412 
      for iter154 in self.statuses:
10413 
        oprot.writeI32(iter154)
4133 chandransh 10414 
      oprot.writeListEnd()
10415 
      oprot.writeFieldEnd()
10416 
    if self.warehouseId is not None:
10417 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10418 
      oprot.writeI64(self.warehouseId)
10419 
      oprot.writeFieldEnd()
10420 
    oprot.writeFieldStop()
10421 
    oprot.writeStructEnd()
10422 
 
10423 
  def validate(self):
10424 
    return
10425 
 
10426 
 
10427 
  def __repr__(self):
10428 
    L = ['%s=%r' % (key, value)
10429 
      for key, value in self.__dict__.iteritems()]
10430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10431 
 
10432 
  def __eq__(self, other):
10433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10434 
 
10435 
  def __ne__(self, other):
10436 
    return not (self == other)
10437 
 
10438 
class getOrderCount_result:
10439 
  """
10440 
  Attributes:
10441 
   - success
10442 
   - ex
10443 
  """
10444 
 
10445 
  thrift_spec = (
10446 
    (0, TType.I32, 'success', None, None, ), # 0
10447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10448 
  )
10449 
 
10450 
  def __init__(self, success=None, ex=None,):
10451 
    self.success = success
10452 
    self.ex = ex
10453 
 
10454 
  def read(self, iprot):
10455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10457 
      return
10458 
    iprot.readStructBegin()
10459 
    while True:
10460 
      (fname, ftype, fid) = iprot.readFieldBegin()
10461 
      if ftype == TType.STOP:
10462 
        break
10463 
      if fid == 0:
10464 
        if ftype == TType.I32:
10465 
          self.success = iprot.readI32();
10466 
        else:
10467 
          iprot.skip(ftype)
10468 
      elif fid == 1:
10469 
        if ftype == TType.STRUCT:
10470 
          self.ex = TransactionServiceException()
10471 
          self.ex.read(iprot)
10472 
        else:
10473 
          iprot.skip(ftype)
10474 
      else:
10475 
        iprot.skip(ftype)
10476 
      iprot.readFieldEnd()
10477 
    iprot.readStructEnd()
10478 
 
10479 
  def write(self, oprot):
10480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10482 
      return
10483 
    oprot.writeStructBegin('getOrderCount_result')
10484 
    if self.success is not None:
10485 
      oprot.writeFieldBegin('success', TType.I32, 0)
10486 
      oprot.writeI32(self.success)
10487 
      oprot.writeFieldEnd()
10488 
    if self.ex is not None:
10489 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10490 
      self.ex.write(oprot)
10491 
      oprot.writeFieldEnd()
10492 
    oprot.writeFieldStop()
10493 
    oprot.writeStructEnd()
10494 
 
10495 
  def validate(self):
10496 
    return
10497 
 
10498 
 
10499 
  def __repr__(self):
10500 
    L = ['%s=%r' % (key, value)
10501 
      for key, value in self.__dict__.iteritems()]
10502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10503 
 
10504 
  def __eq__(self, other):
10505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10506 
 
10507 
  def __ne__(self, other):
10508 
    return not (self == other)
10509 
 
999 varun.gupt 10510 
class getOrdersByBillingDate_args:
10511 
  """
10512 
  Attributes:
10513 
   - status
10514 
   - start_billing_date
10515 
   - end_billing_date
10516 
   - warehouse_id
10517 
  """
10518 
 
10519 
  thrift_spec = (
10520 
    None, # 0
10521 
    (1, TType.I32, 'status', None, None, ), # 1
10522 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10523 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10524 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10525 
  )
10526 
 
10527 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10528 
    self.status = status
10529 
    self.start_billing_date = start_billing_date
10530 
    self.end_billing_date = end_billing_date
10531 
    self.warehouse_id = warehouse_id
10532 
 
10533 
  def read(self, iprot):
10534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10536 
      return
10537 
    iprot.readStructBegin()
10538 
    while True:
10539 
      (fname, ftype, fid) = iprot.readFieldBegin()
10540 
      if ftype == TType.STOP:
10541 
        break
10542 
      if fid == 1:
10543 
        if ftype == TType.I32:
10544 
          self.status = iprot.readI32();
10545 
        else:
10546 
          iprot.skip(ftype)
10547 
      elif fid == 2:
10548 
        if ftype == TType.I64:
10549 
          self.start_billing_date = iprot.readI64();
10550 
        else:
10551 
          iprot.skip(ftype)
10552 
      elif fid == 3:
10553 
        if ftype == TType.I64:
10554 
          self.end_billing_date = iprot.readI64();
10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      elif fid == 4:
10558 
        if ftype == TType.I64:
10559 
          self.warehouse_id = iprot.readI64();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      else:
10563 
        iprot.skip(ftype)
10564 
      iprot.readFieldEnd()
10565 
    iprot.readStructEnd()
10566 
 
10567 
  def write(self, oprot):
10568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10570 
      return
10571 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10572 
    if self.status is not None:
999 varun.gupt 10573 
      oprot.writeFieldBegin('status', TType.I32, 1)
10574 
      oprot.writeI32(self.status)
10575 
      oprot.writeFieldEnd()
3431 rajveer 10576 
    if self.start_billing_date is not None:
999 varun.gupt 10577 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10578 
      oprot.writeI64(self.start_billing_date)
10579 
      oprot.writeFieldEnd()
3431 rajveer 10580 
    if self.end_billing_date is not None:
999 varun.gupt 10581 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10582 
      oprot.writeI64(self.end_billing_date)
10583 
      oprot.writeFieldEnd()
3431 rajveer 10584 
    if self.warehouse_id is not None:
999 varun.gupt 10585 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10586 
      oprot.writeI64(self.warehouse_id)
10587 
      oprot.writeFieldEnd()
10588 
    oprot.writeFieldStop()
10589 
    oprot.writeStructEnd()
10590 
 
3431 rajveer 10591 
  def validate(self):
10592 
    return
10593 
 
10594 
 
999 varun.gupt 10595 
  def __repr__(self):
10596 
    L = ['%s=%r' % (key, value)
10597 
      for key, value in self.__dict__.iteritems()]
10598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10599 
 
10600 
  def __eq__(self, other):
10601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10602 
 
10603 
  def __ne__(self, other):
10604 
    return not (self == other)
10605 
 
10606 
class getOrdersByBillingDate_result:
10607 
  """
10608 
  Attributes:
10609 
   - success
10610 
   - ex
10611 
  """
10612 
 
10613 
  thrift_spec = (
10614 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10616 
  )
10617 
 
10618 
  def __init__(self, success=None, ex=None,):
10619 
    self.success = success
10620 
    self.ex = ex
10621 
 
10622 
  def read(self, iprot):
10623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10625 
      return
10626 
    iprot.readStructBegin()
10627 
    while True:
10628 
      (fname, ftype, fid) = iprot.readFieldBegin()
10629 
      if ftype == TType.STOP:
10630 
        break
10631 
      if fid == 0:
10632 
        if ftype == TType.LIST:
10633 
          self.success = []
6188 rajveer 10634 
          (_etype158, _size155) = iprot.readListBegin()
10635 
          for _i159 in xrange(_size155):
10636 
            _elem160 = Order()
10637 
            _elem160.read(iprot)
10638 
            self.success.append(_elem160)
999 varun.gupt 10639 
          iprot.readListEnd()
10640 
        else:
10641 
          iprot.skip(ftype)
10642 
      elif fid == 1:
10643 
        if ftype == TType.STRUCT:
10644 
          self.ex = TransactionServiceException()
10645 
          self.ex.read(iprot)
10646 
        else:
10647 
          iprot.skip(ftype)
10648 
      else:
10649 
        iprot.skip(ftype)
10650 
      iprot.readFieldEnd()
10651 
    iprot.readStructEnd()
10652 
 
10653 
  def write(self, oprot):
10654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10656 
      return
10657 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10658 
    if self.success is not None:
999 varun.gupt 10659 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10660 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10661 
      for iter161 in self.success:
10662 
        iter161.write(oprot)
999 varun.gupt 10663 
      oprot.writeListEnd()
10664 
      oprot.writeFieldEnd()
3431 rajveer 10665 
    if self.ex is not None:
999 varun.gupt 10666 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10667 
      self.ex.write(oprot)
10668 
      oprot.writeFieldEnd()
10669 
    oprot.writeFieldStop()
10670 
    oprot.writeStructEnd()
10671 
 
3431 rajveer 10672 
  def validate(self):
10673 
    return
10674 
 
10675 
 
999 varun.gupt 10676 
  def __repr__(self):
10677 
    L = ['%s=%r' % (key, value)
10678 
      for key, value in self.__dict__.iteritems()]
10679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10680 
 
10681 
  def __eq__(self, other):
10682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10683 
 
10684 
  def __ne__(self, other):
10685 
    return not (self == other)
10686 
 
3427 chandransh 10687 
class getOrdersByShippingDate_args:
10688 
  """
10689 
  Attributes:
10690 
   - fromShippingDate
10691 
   - toShippingDate
10692 
   - providerId
10693 
   - warehouseId
3451 chandransh 10694 
   - cod
3427 chandransh 10695 
  """
10696 
 
10697 
  thrift_spec = (
10698 
    None, # 0
10699 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10700 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10701 
    (3, TType.I64, 'providerId', None, None, ), # 3
10702 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10703 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10704 
  )
10705 
 
3451 chandransh 10706 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10707 
    self.fromShippingDate = fromShippingDate
10708 
    self.toShippingDate = toShippingDate
10709 
    self.providerId = providerId
10710 
    self.warehouseId = warehouseId
3451 chandransh 10711 
    self.cod = cod
3427 chandransh 10712 
 
10713 
  def read(self, iprot):
10714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10716 
      return
10717 
    iprot.readStructBegin()
10718 
    while True:
10719 
      (fname, ftype, fid) = iprot.readFieldBegin()
10720 
      if ftype == TType.STOP:
10721 
        break
10722 
      if fid == 1:
10723 
        if ftype == TType.I64:
10724 
          self.fromShippingDate = iprot.readI64();
10725 
        else:
10726 
          iprot.skip(ftype)
10727 
      elif fid == 2:
10728 
        if ftype == TType.I64:
10729 
          self.toShippingDate = iprot.readI64();
10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      elif fid == 3:
10733 
        if ftype == TType.I64:
10734 
          self.providerId = iprot.readI64();
10735 
        else:
10736 
          iprot.skip(ftype)
10737 
      elif fid == 4:
10738 
        if ftype == TType.I64:
10739 
          self.warehouseId = iprot.readI64();
10740 
        else:
10741 
          iprot.skip(ftype)
3451 chandransh 10742 
      elif fid == 5:
10743 
        if ftype == TType.BOOL:
10744 
          self.cod = iprot.readBool();
10745 
        else:
10746 
          iprot.skip(ftype)
3427 chandransh 10747 
      else:
10748 
        iprot.skip(ftype)
10749 
      iprot.readFieldEnd()
10750 
    iprot.readStructEnd()
10751 
 
10752 
  def write(self, oprot):
10753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10755 
      return
10756 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10757 
    if self.fromShippingDate is not None:
3427 chandransh 10758 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10759 
      oprot.writeI64(self.fromShippingDate)
10760 
      oprot.writeFieldEnd()
3431 rajveer 10761 
    if self.toShippingDate is not None:
3427 chandransh 10762 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10763 
      oprot.writeI64(self.toShippingDate)
10764 
      oprot.writeFieldEnd()
3431 rajveer 10765 
    if self.providerId is not None:
3427 chandransh 10766 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10767 
      oprot.writeI64(self.providerId)
10768 
      oprot.writeFieldEnd()
3431 rajveer 10769 
    if self.warehouseId is not None:
3427 chandransh 10770 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10771 
      oprot.writeI64(self.warehouseId)
10772 
      oprot.writeFieldEnd()
3451 chandransh 10773 
    if self.cod is not None:
10774 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10775 
      oprot.writeBool(self.cod)
10776 
      oprot.writeFieldEnd()
3427 chandransh 10777 
    oprot.writeFieldStop()
10778 
    oprot.writeStructEnd()
10779 
 
3431 rajveer 10780 
  def validate(self):
10781 
    return
10782 
 
10783 
 
3427 chandransh 10784 
  def __repr__(self):
10785 
    L = ['%s=%r' % (key, value)
10786 
      for key, value in self.__dict__.iteritems()]
10787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10788 
 
10789 
  def __eq__(self, other):
10790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10791 
 
10792 
  def __ne__(self, other):
10793 
    return not (self == other)
10794 
 
10795 
class getOrdersByShippingDate_result:
10796 
  """
10797 
  Attributes:
10798 
   - success
10799 
   - ex
10800 
  """
10801 
 
10802 
  thrift_spec = (
10803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10805 
  )
10806 
 
10807 
  def __init__(self, success=None, ex=None,):
10808 
    self.success = success
10809 
    self.ex = ex
10810 
 
10811 
  def read(self, iprot):
10812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10814 
      return
10815 
    iprot.readStructBegin()
10816 
    while True:
10817 
      (fname, ftype, fid) = iprot.readFieldBegin()
10818 
      if ftype == TType.STOP:
10819 
        break
10820 
      if fid == 0:
10821 
        if ftype == TType.LIST:
10822 
          self.success = []
6188 rajveer 10823 
          (_etype165, _size162) = iprot.readListBegin()
10824 
          for _i166 in xrange(_size162):
10825 
            _elem167 = Order()
10826 
            _elem167.read(iprot)
10827 
            self.success.append(_elem167)
3427 chandransh 10828 
          iprot.readListEnd()
10829 
        else:
10830 
          iprot.skip(ftype)
10831 
      elif fid == 1:
10832 
        if ftype == TType.STRUCT:
10833 
          self.ex = TransactionServiceException()
10834 
          self.ex.read(iprot)
10835 
        else:
10836 
          iprot.skip(ftype)
10837 
      else:
10838 
        iprot.skip(ftype)
10839 
      iprot.readFieldEnd()
10840 
    iprot.readStructEnd()
10841 
 
10842 
  def write(self, oprot):
10843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10845 
      return
10846 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10847 
    if self.success is not None:
3427 chandransh 10848 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10849 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10850 
      for iter168 in self.success:
10851 
        iter168.write(oprot)
3427 chandransh 10852 
      oprot.writeListEnd()
10853 
      oprot.writeFieldEnd()
3431 rajveer 10854 
    if self.ex is not None:
3427 chandransh 10855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10856 
      self.ex.write(oprot)
10857 
      oprot.writeFieldEnd()
10858 
    oprot.writeFieldStop()
10859 
    oprot.writeStructEnd()
10860 
 
3431 rajveer 10861 
  def validate(self):
10862 
    return
10863 
 
10864 
 
3427 chandransh 10865 
  def __repr__(self):
10866 
    L = ['%s=%r' % (key, value)
10867 
      for key, value in self.__dict__.iteritems()]
10868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10869 
 
10870 
  def __eq__(self, other):
10871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10872 
 
10873 
  def __ne__(self, other):
10874 
    return not (self == other)
10875 
 
1382 varun.gupt 10876 
class getReturnableOrdersForCustomer_args:
10877 
  """
10878 
  Attributes:
10879 
   - customer_id
10880 
   - limit
10881 
  """
10882 
 
10883 
  thrift_spec = (
10884 
    None, # 0
10885 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10886 
    (2, TType.I64, 'limit', None, None, ), # 2
10887 
  )
10888 
 
10889 
  def __init__(self, customer_id=None, limit=None,):
10890 
    self.customer_id = customer_id
10891 
    self.limit = limit
10892 
 
10893 
  def read(self, iprot):
10894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10896 
      return
10897 
    iprot.readStructBegin()
10898 
    while True:
10899 
      (fname, ftype, fid) = iprot.readFieldBegin()
10900 
      if ftype == TType.STOP:
10901 
        break
10902 
      if fid == 1:
10903 
        if ftype == TType.I64:
10904 
          self.customer_id = iprot.readI64();
10905 
        else:
10906 
          iprot.skip(ftype)
10907 
      elif fid == 2:
10908 
        if ftype == TType.I64:
10909 
          self.limit = iprot.readI64();
10910 
        else:
10911 
          iprot.skip(ftype)
10912 
      else:
10913 
        iprot.skip(ftype)
10914 
      iprot.readFieldEnd()
10915 
    iprot.readStructEnd()
10916 
 
10917 
  def write(self, oprot):
10918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10920 
      return
10921 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10922 
    if self.customer_id is not None:
1382 varun.gupt 10923 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10924 
      oprot.writeI64(self.customer_id)
10925 
      oprot.writeFieldEnd()
3431 rajveer 10926 
    if self.limit is not None:
1382 varun.gupt 10927 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10928 
      oprot.writeI64(self.limit)
10929 
      oprot.writeFieldEnd()
10930 
    oprot.writeFieldStop()
10931 
    oprot.writeStructEnd()
10932 
 
3431 rajveer 10933 
  def validate(self):
10934 
    return
10935 
 
10936 
 
1382 varun.gupt 10937 
  def __repr__(self):
10938 
    L = ['%s=%r' % (key, value)
10939 
      for key, value in self.__dict__.iteritems()]
10940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10941 
 
10942 
  def __eq__(self, other):
10943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10944 
 
10945 
  def __ne__(self, other):
10946 
    return not (self == other)
10947 
 
10948 
class getReturnableOrdersForCustomer_result:
10949 
  """
10950 
  Attributes:
10951 
   - success
10952 
   - ex
10953 
  """
10954 
 
10955 
  thrift_spec = (
10956 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10958 
  )
10959 
 
10960 
  def __init__(self, success=None, ex=None,):
10961 
    self.success = success
10962 
    self.ex = ex
10963 
 
10964 
  def read(self, iprot):
10965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10967 
      return
10968 
    iprot.readStructBegin()
10969 
    while True:
10970 
      (fname, ftype, fid) = iprot.readFieldBegin()
10971 
      if ftype == TType.STOP:
10972 
        break
10973 
      if fid == 0:
10974 
        if ftype == TType.LIST:
10975 
          self.success = []
6188 rajveer 10976 
          (_etype172, _size169) = iprot.readListBegin()
10977 
          for _i173 in xrange(_size169):
10978 
            _elem174 = iprot.readI64();
10979 
            self.success.append(_elem174)
1382 varun.gupt 10980 
          iprot.readListEnd()
10981 
        else:
10982 
          iprot.skip(ftype)
10983 
      elif fid == 1:
10984 
        if ftype == TType.STRUCT:
10985 
          self.ex = TransactionServiceException()
10986 
          self.ex.read(iprot)
10987 
        else:
10988 
          iprot.skip(ftype)
10989 
      else:
10990 
        iprot.skip(ftype)
10991 
      iprot.readFieldEnd()
10992 
    iprot.readStructEnd()
10993 
 
10994 
  def write(self, oprot):
10995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10997 
      return
10998 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10999 
    if self.success is not None:
1382 varun.gupt 11000 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11001 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11002 
      for iter175 in self.success:
11003 
        oprot.writeI64(iter175)
1382 varun.gupt 11004 
      oprot.writeListEnd()
11005 
      oprot.writeFieldEnd()
3431 rajveer 11006 
    if self.ex is not None:
1382 varun.gupt 11007 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11008 
      self.ex.write(oprot)
11009 
      oprot.writeFieldEnd()
11010 
    oprot.writeFieldStop()
11011 
    oprot.writeStructEnd()
11012 
 
3431 rajveer 11013 
  def validate(self):
11014 
    return
11015 
 
11016 
 
1382 varun.gupt 11017 
  def __repr__(self):
11018 
    L = ['%s=%r' % (key, value)
11019 
      for key, value in self.__dict__.iteritems()]
11020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11021 
 
11022 
  def __eq__(self, other):
11023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11024 
 
11025 
  def __ne__(self, other):
11026 
    return not (self == other)
11027 
 
11028 
class getCancellableOrdersForCustomer_args:
11029 
  """
11030 
  Attributes:
11031 
   - customer_id
11032 
   - limit
11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    None, # 0
11037 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11038 
    (2, TType.I64, 'limit', None, None, ), # 2
11039 
  )
11040 
 
11041 
  def __init__(self, customer_id=None, limit=None,):
11042 
    self.customer_id = customer_id
11043 
    self.limit = limit
11044 
 
11045 
  def read(self, iprot):
11046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11048 
      return
11049 
    iprot.readStructBegin()
11050 
    while True:
11051 
      (fname, ftype, fid) = iprot.readFieldBegin()
11052 
      if ftype == TType.STOP:
11053 
        break
11054 
      if fid == 1:
11055 
        if ftype == TType.I64:
11056 
          self.customer_id = iprot.readI64();
11057 
        else:
11058 
          iprot.skip(ftype)
11059 
      elif fid == 2:
11060 
        if ftype == TType.I64:
11061 
          self.limit = iprot.readI64();
11062 
        else:
11063 
          iprot.skip(ftype)
11064 
      else:
11065 
        iprot.skip(ftype)
11066 
      iprot.readFieldEnd()
11067 
    iprot.readStructEnd()
11068 
 
11069 
  def write(self, oprot):
11070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11072 
      return
11073 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11074 
    if self.customer_id is not None:
1382 varun.gupt 11075 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11076 
      oprot.writeI64(self.customer_id)
11077 
      oprot.writeFieldEnd()
3431 rajveer 11078 
    if self.limit is not None:
1382 varun.gupt 11079 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11080 
      oprot.writeI64(self.limit)
11081 
      oprot.writeFieldEnd()
11082 
    oprot.writeFieldStop()
11083 
    oprot.writeStructEnd()
11084 
 
3431 rajveer 11085 
  def validate(self):
11086 
    return
11087 
 
11088 
 
1382 varun.gupt 11089 
  def __repr__(self):
11090 
    L = ['%s=%r' % (key, value)
11091 
      for key, value in self.__dict__.iteritems()]
11092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11093 
 
11094 
  def __eq__(self, other):
11095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11096 
 
11097 
  def __ne__(self, other):
11098 
    return not (self == other)
11099 
 
11100 
class getCancellableOrdersForCustomer_result:
11101 
  """
11102 
  Attributes:
11103 
   - success
11104 
   - ex
11105 
  """
11106 
 
11107 
  thrift_spec = (
11108 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11110 
  )
11111 
 
11112 
  def __init__(self, success=None, ex=None,):
11113 
    self.success = success
11114 
    self.ex = ex
11115 
 
11116 
  def read(self, iprot):
11117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11119 
      return
11120 
    iprot.readStructBegin()
11121 
    while True:
11122 
      (fname, ftype, fid) = iprot.readFieldBegin()
11123 
      if ftype == TType.STOP:
11124 
        break
11125 
      if fid == 0:
11126 
        if ftype == TType.LIST:
11127 
          self.success = []
6188 rajveer 11128 
          (_etype179, _size176) = iprot.readListBegin()
11129 
          for _i180 in xrange(_size176):
11130 
            _elem181 = iprot.readI64();
11131 
            self.success.append(_elem181)
1382 varun.gupt 11132 
          iprot.readListEnd()
11133 
        else:
11134 
          iprot.skip(ftype)
11135 
      elif fid == 1:
11136 
        if ftype == TType.STRUCT:
11137 
          self.ex = TransactionServiceException()
11138 
          self.ex.read(iprot)
11139 
        else:
11140 
          iprot.skip(ftype)
11141 
      else:
11142 
        iprot.skip(ftype)
11143 
      iprot.readFieldEnd()
11144 
    iprot.readStructEnd()
11145 
 
11146 
  def write(self, oprot):
11147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11149 
      return
11150 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11151 
    if self.success is not None:
1382 varun.gupt 11152 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11153 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11154 
      for iter182 in self.success:
11155 
        oprot.writeI64(iter182)
1382 varun.gupt 11156 
      oprot.writeListEnd()
11157 
      oprot.writeFieldEnd()
3431 rajveer 11158 
    if self.ex is not None:
1382 varun.gupt 11159 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11160 
      self.ex.write(oprot)
11161 
      oprot.writeFieldEnd()
11162 
    oprot.writeFieldStop()
11163 
    oprot.writeStructEnd()
11164 
 
3431 rajveer 11165 
  def validate(self):
11166 
    return
11167 
 
11168 
 
1382 varun.gupt 11169 
  def __repr__(self):
11170 
    L = ['%s=%r' % (key, value)
11171 
      for key, value in self.__dict__.iteritems()]
11172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11173 
 
11174 
  def __eq__(self, other):
11175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11176 
 
11177 
  def __ne__(self, other):
11178 
    return not (self == other)
11179 
 
483 rajveer 11180 
class changeOrderStatus_args:
94 ashish 11181 
  """
11182 
  Attributes:
483 rajveer 11183 
   - orderId
11184 
   - status
11185 
   - description
94 ashish 11186 
  """
11187 
 
11188 
  thrift_spec = (
11189 
    None, # 0
483 rajveer 11190 
    (1, TType.I64, 'orderId', None, None, ), # 1
11191 
    (2, TType.I32, 'status', None, None, ), # 2
11192 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11193 
  )
11194 
 
483 rajveer 11195 
  def __init__(self, orderId=None, status=None, description=None,):
11196 
    self.orderId = orderId
11197 
    self.status = status
11198 
    self.description = description
94 ashish 11199 
 
11200 
  def read(self, iprot):
11201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11203 
      return
11204 
    iprot.readStructBegin()
11205 
    while True:
11206 
      (fname, ftype, fid) = iprot.readFieldBegin()
11207 
      if ftype == TType.STOP:
11208 
        break
11209 
      if fid == 1:
11210 
        if ftype == TType.I64:
483 rajveer 11211 
          self.orderId = iprot.readI64();
94 ashish 11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      elif fid == 2:
483 rajveer 11215 
        if ftype == TType.I32:
11216 
          self.status = iprot.readI32();
94 ashish 11217 
        else:
11218 
          iprot.skip(ftype)
483 rajveer 11219 
      elif fid == 3:
11220 
        if ftype == TType.STRING:
11221 
          self.description = iprot.readString();
11222 
        else:
11223 
          iprot.skip(ftype)
94 ashish 11224 
      else:
11225 
        iprot.skip(ftype)
11226 
      iprot.readFieldEnd()
11227 
    iprot.readStructEnd()
11228 
 
11229 
  def write(self, oprot):
11230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11232 
      return
483 rajveer 11233 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11234 
    if self.orderId is not None:
483 rajveer 11235 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11236 
      oprot.writeI64(self.orderId)
94 ashish 11237 
      oprot.writeFieldEnd()
3431 rajveer 11238 
    if self.status is not None:
483 rajveer 11239 
      oprot.writeFieldBegin('status', TType.I32, 2)
11240 
      oprot.writeI32(self.status)
94 ashish 11241 
      oprot.writeFieldEnd()
3431 rajveer 11242 
    if self.description is not None:
483 rajveer 11243 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11244 
      oprot.writeString(self.description)
11245 
      oprot.writeFieldEnd()
94 ashish 11246 
    oprot.writeFieldStop()
11247 
    oprot.writeStructEnd()
11248 
 
3431 rajveer 11249 
  def validate(self):
11250 
    return
11251 
 
11252 
 
94 ashish 11253 
  def __repr__(self):
11254 
    L = ['%s=%r' % (key, value)
11255 
      for key, value in self.__dict__.iteritems()]
11256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11257 
 
11258 
  def __eq__(self, other):
11259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11260 
 
11261 
  def __ne__(self, other):
11262 
    return not (self == other)
11263 
 
483 rajveer 11264 
class changeOrderStatus_result:
94 ashish 11265 
  """
11266 
  Attributes:
11267 
   - success
11268 
   - ex
11269 
  """
11270 
 
11271 
  thrift_spec = (
11272 
    (0, TType.BOOL, 'success', None, None, ), # 0
11273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11274 
  )
11275 
 
11276 
  def __init__(self, success=None, ex=None,):
11277 
    self.success = success
11278 
    self.ex = ex
11279 
 
11280 
  def read(self, iprot):
11281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11283 
      return
11284 
    iprot.readStructBegin()
11285 
    while True:
11286 
      (fname, ftype, fid) = iprot.readFieldBegin()
11287 
      if ftype == TType.STOP:
11288 
        break
11289 
      if fid == 0:
11290 
        if ftype == TType.BOOL:
11291 
          self.success = iprot.readBool();
11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      elif fid == 1:
11295 
        if ftype == TType.STRUCT:
11296 
          self.ex = TransactionServiceException()
11297 
          self.ex.read(iprot)
11298 
        else:
11299 
          iprot.skip(ftype)
11300 
      else:
11301 
        iprot.skip(ftype)
11302 
      iprot.readFieldEnd()
11303 
    iprot.readStructEnd()
11304 
 
11305 
  def write(self, oprot):
11306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11308 
      return
483 rajveer 11309 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11310 
    if self.success is not None:
94 ashish 11311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11312 
      oprot.writeBool(self.success)
11313 
      oprot.writeFieldEnd()
3431 rajveer 11314 
    if self.ex is not None:
94 ashish 11315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11316 
      self.ex.write(oprot)
11317 
      oprot.writeFieldEnd()
11318 
    oprot.writeFieldStop()
11319 
    oprot.writeStructEnd()
11320 
 
3431 rajveer 11321 
  def validate(self):
11322 
    return
11323 
 
11324 
 
94 ashish 11325 
  def __repr__(self):
11326 
    L = ['%s=%r' % (key, value)
11327 
      for key, value in self.__dict__.iteritems()]
11328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11329 
 
11330 
  def __eq__(self, other):
11331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11332 
 
11333 
  def __ne__(self, other):
11334 
    return not (self == other)
11335 
 
3064 chandransh 11336 
class getOrdersForTransaction_args:
494 rajveer 11337 
  """
11338 
  Attributes:
3064 chandransh 11339 
   - transactionId
11340 
   - customerId
494 rajveer 11341 
  """
11342 
 
11343 
  thrift_spec = (
11344 
    None, # 0
3064 chandransh 11345 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11346 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11347 
  )
11348 
 
3064 chandransh 11349 
  def __init__(self, transactionId=None, customerId=None,):
11350 
    self.transactionId = transactionId
11351 
    self.customerId = customerId
494 rajveer 11352 
 
11353 
  def read(self, iprot):
11354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11356 
      return
11357 
    iprot.readStructBegin()
11358 
    while True:
11359 
      (fname, ftype, fid) = iprot.readFieldBegin()
11360 
      if ftype == TType.STOP:
11361 
        break
11362 
      if fid == 1:
11363 
        if ftype == TType.I64:
3064 chandransh 11364 
          self.transactionId = iprot.readI64();
494 rajveer 11365 
        else:
11366 
          iprot.skip(ftype)
11367 
      elif fid == 2:
3064 chandransh 11368 
        if ftype == TType.I64:
11369 
          self.customerId = iprot.readI64();
494 rajveer 11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      else:
11373 
        iprot.skip(ftype)
11374 
      iprot.readFieldEnd()
11375 
    iprot.readStructEnd()
11376 
 
11377 
  def write(self, oprot):
11378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11380 
      return
3064 chandransh 11381 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11382 
    if self.transactionId is not None:
3064 chandransh 11383 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11384 
      oprot.writeI64(self.transactionId)
494 rajveer 11385 
      oprot.writeFieldEnd()
3431 rajveer 11386 
    if self.customerId is not None:
3064 chandransh 11387 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11388 
      oprot.writeI64(self.customerId)
494 rajveer 11389 
      oprot.writeFieldEnd()
11390 
    oprot.writeFieldStop()
11391 
    oprot.writeStructEnd()
11392 
 
3431 rajveer 11393 
  def validate(self):
11394 
    return
11395 
 
11396 
 
494 rajveer 11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
3064 chandransh 11408 
class getOrdersForTransaction_result:
494 rajveer 11409 
  """
11410 
  Attributes:
11411 
   - success
11412 
   - ex
11413 
  """
11414 
 
11415 
  thrift_spec = (
3064 chandransh 11416 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11418 
  )
11419 
 
11420 
  def __init__(self, success=None, ex=None,):
11421 
    self.success = success
11422 
    self.ex = ex
11423 
 
11424 
  def read(self, iprot):
11425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11427 
      return
11428 
    iprot.readStructBegin()
11429 
    while True:
11430 
      (fname, ftype, fid) = iprot.readFieldBegin()
11431 
      if ftype == TType.STOP:
11432 
        break
11433 
      if fid == 0:
3064 chandransh 11434 
        if ftype == TType.LIST:
11435 
          self.success = []
6188 rajveer 11436 
          (_etype186, _size183) = iprot.readListBegin()
11437 
          for _i187 in xrange(_size183):
11438 
            _elem188 = Order()
11439 
            _elem188.read(iprot)
11440 
            self.success.append(_elem188)
3064 chandransh 11441 
          iprot.readListEnd()
494 rajveer 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
3064 chandransh 11459 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11460 
    if self.success is not None:
3064 chandransh 11461 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11462 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11463 
      for iter189 in self.success:
11464 
        iter189.write(oprot)
3064 chandransh 11465 
      oprot.writeListEnd()
494 rajveer 11466 
      oprot.writeFieldEnd()
3431 rajveer 11467 
    if self.ex is not None:
494 rajveer 11468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11469 
      self.ex.write(oprot)
11470 
      oprot.writeFieldEnd()
11471 
    oprot.writeFieldStop()
11472 
    oprot.writeStructEnd()
11473 
 
3431 rajveer 11474 
  def validate(self):
11475 
    return
11476 
 
11477 
 
494 rajveer 11478 
  def __repr__(self):
11479 
    L = ['%s=%r' % (key, value)
11480 
      for key, value in self.__dict__.iteritems()]
11481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11482 
 
11483 
  def __eq__(self, other):
11484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11485 
 
11486 
  def __ne__(self, other):
11487 
    return not (self == other)
11488 
 
3064 chandransh 11489 
class getOrdersForCustomer_args:
1149 chandransh 11490 
  """
11491 
  Attributes:
3064 chandransh 11492 
   - customerId
11493 
   - from_date
11494 
   - to_date
11495 
   - statuses
1149 chandransh 11496 
  """
11497 
 
11498 
  thrift_spec = (
11499 
    None, # 0
3064 chandransh 11500 
    (1, TType.I64, 'customerId', None, None, ), # 1
11501 
    (2, TType.I64, 'from_date', None, None, ), # 2
11502 
    (3, TType.I64, 'to_date', None, None, ), # 3
11503 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11504 
  )
11505 
 
3064 chandransh 11506 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11507 
    self.customerId = customerId
11508 
    self.from_date = from_date
11509 
    self.to_date = to_date
11510 
    self.statuses = statuses
1149 chandransh 11511 
 
11512 
  def read(self, iprot):
11513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11515 
      return
11516 
    iprot.readStructBegin()
11517 
    while True:
11518 
      (fname, ftype, fid) = iprot.readFieldBegin()
11519 
      if ftype == TType.STOP:
11520 
        break
11521 
      if fid == 1:
11522 
        if ftype == TType.I64:
3064 chandransh 11523 
          self.customerId = iprot.readI64();
1149 chandransh 11524 
        else:
11525 
          iprot.skip(ftype)
11526 
      elif fid == 2:
11527 
        if ftype == TType.I64:
3064 chandransh 11528 
          self.from_date = iprot.readI64();
1149 chandransh 11529 
        else:
11530 
          iprot.skip(ftype)
2783 chandransh 11531 
      elif fid == 3:
11532 
        if ftype == TType.I64:
3064 chandransh 11533 
          self.to_date = iprot.readI64();
2783 chandransh 11534 
        else:
11535 
          iprot.skip(ftype)
11536 
      elif fid == 4:
3064 chandransh 11537 
        if ftype == TType.LIST:
11538 
          self.statuses = []
6188 rajveer 11539 
          (_etype193, _size190) = iprot.readListBegin()
11540 
          for _i194 in xrange(_size190):
11541 
            _elem195 = iprot.readI32();
11542 
            self.statuses.append(_elem195)
3064 chandransh 11543 
          iprot.readListEnd()
2783 chandransh 11544 
        else:
11545 
          iprot.skip(ftype)
1149 chandransh 11546 
      else:
11547 
        iprot.skip(ftype)
11548 
      iprot.readFieldEnd()
11549 
    iprot.readStructEnd()
11550 
 
11551 
  def write(self, oprot):
11552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11554 
      return
3064 chandransh 11555 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11556 
    if self.customerId is not None:
3064 chandransh 11557 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11558 
      oprot.writeI64(self.customerId)
1149 chandransh 11559 
      oprot.writeFieldEnd()
3431 rajveer 11560 
    if self.from_date is not None:
3064 chandransh 11561 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11562 
      oprot.writeI64(self.from_date)
1149 chandransh 11563 
      oprot.writeFieldEnd()
3431 rajveer 11564 
    if self.to_date is not None:
3064 chandransh 11565 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11566 
      oprot.writeI64(self.to_date)
2783 chandransh 11567 
      oprot.writeFieldEnd()
3431 rajveer 11568 
    if self.statuses is not None:
3064 chandransh 11569 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11570 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11571 
      for iter196 in self.statuses:
11572 
        oprot.writeI32(iter196)
3064 chandransh 11573 
      oprot.writeListEnd()
2783 chandransh 11574 
      oprot.writeFieldEnd()
1149 chandransh 11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
3431 rajveer 11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
1149 chandransh 11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
3064 chandransh 11593 
class getOrdersForCustomer_result:
1149 chandransh 11594 
  """
11595 
  Attributes:
11596 
   - success
11597 
   - ex
11598 
  """
11599 
 
11600 
  thrift_spec = (
3064 chandransh 11601 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11603 
  )
11604 
 
11605 
  def __init__(self, success=None, ex=None,):
11606 
    self.success = success
11607 
    self.ex = ex
11608 
 
11609 
  def read(self, iprot):
11610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11612 
      return
11613 
    iprot.readStructBegin()
11614 
    while True:
11615 
      (fname, ftype, fid) = iprot.readFieldBegin()
11616 
      if ftype == TType.STOP:
11617 
        break
11618 
      if fid == 0:
3064 chandransh 11619 
        if ftype == TType.LIST:
11620 
          self.success = []
6188 rajveer 11621 
          (_etype200, _size197) = iprot.readListBegin()
11622 
          for _i201 in xrange(_size197):
11623 
            _elem202 = Order()
11624 
            _elem202.read(iprot)
11625 
            self.success.append(_elem202)
3064 chandransh 11626 
          iprot.readListEnd()
1149 chandransh 11627 
        else:
11628 
          iprot.skip(ftype)
11629 
      elif fid == 1:
11630 
        if ftype == TType.STRUCT:
11631 
          self.ex = TransactionServiceException()
11632 
          self.ex.read(iprot)
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      else:
11636 
        iprot.skip(ftype)
11637 
      iprot.readFieldEnd()
11638 
    iprot.readStructEnd()
11639 
 
11640 
  def write(self, oprot):
11641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11643 
      return
3064 chandransh 11644 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11645 
    if self.success is not None:
3064 chandransh 11646 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11647 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11648 
      for iter203 in self.success:
11649 
        iter203.write(oprot)
3064 chandransh 11650 
      oprot.writeListEnd()
1149 chandransh 11651 
      oprot.writeFieldEnd()
3431 rajveer 11652 
    if self.ex is not None:
1149 chandransh 11653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11654 
      self.ex.write(oprot)
11655 
      oprot.writeFieldEnd()
11656 
    oprot.writeFieldStop()
11657 
    oprot.writeStructEnd()
11658 
 
3431 rajveer 11659 
  def validate(self):
11660 
    return
11661 
 
11662 
 
1149 chandransh 11663 
  def __repr__(self):
11664 
    L = ['%s=%r' % (key, value)
11665 
      for key, value in self.__dict__.iteritems()]
11666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11667 
 
11668 
  def __eq__(self, other):
11669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11670 
 
11671 
  def __ne__(self, other):
11672 
    return not (self == other)
11673 
 
3064 chandransh 11674 
class createOrder_args:
921 rajveer 11675 
  """
11676 
  Attributes:
3064 chandransh 11677 
   - order
921 rajveer 11678 
  """
11679 
 
11680 
  thrift_spec = (
11681 
    None, # 0
3064 chandransh 11682 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11683 
  )
11684 
 
3064 chandransh 11685 
  def __init__(self, order=None,):
11686 
    self.order = order
921 rajveer 11687 
 
11688 
  def read(self, iprot):
11689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11691 
      return
11692 
    iprot.readStructBegin()
11693 
    while True:
11694 
      (fname, ftype, fid) = iprot.readFieldBegin()
11695 
      if ftype == TType.STOP:
11696 
        break
11697 
      if fid == 1:
3064 chandransh 11698 
        if ftype == TType.STRUCT:
11699 
          self.order = Order()
11700 
          self.order.read(iprot)
921 rajveer 11701 
        else:
11702 
          iprot.skip(ftype)
11703 
      else:
11704 
        iprot.skip(ftype)
11705 
      iprot.readFieldEnd()
11706 
    iprot.readStructEnd()
11707 
 
11708 
  def write(self, oprot):
11709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11711 
      return
3064 chandransh 11712 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11713 
    if self.order is not None:
3064 chandransh 11714 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11715 
      self.order.write(oprot)
921 rajveer 11716 
      oprot.writeFieldEnd()
11717 
    oprot.writeFieldStop()
11718 
    oprot.writeStructEnd()
11719 
 
3431 rajveer 11720 
  def validate(self):
11721 
    return
11722 
 
11723 
 
921 rajveer 11724 
  def __repr__(self):
11725 
    L = ['%s=%r' % (key, value)
11726 
      for key, value in self.__dict__.iteritems()]
11727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11728 
 
11729 
  def __eq__(self, other):
11730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11731 
 
11732 
  def __ne__(self, other):
11733 
    return not (self == other)
11734 
 
3064 chandransh 11735 
class createOrder_result:
921 rajveer 11736 
  """
11737 
  Attributes:
11738 
   - success
11739 
   - ex
11740 
  """
11741 
 
11742 
  thrift_spec = (
3064 chandransh 11743 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11745 
  )
11746 
 
11747 
  def __init__(self, success=None, ex=None,):
11748 
    self.success = success
11749 
    self.ex = ex
11750 
 
11751 
  def read(self, iprot):
11752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11754 
      return
11755 
    iprot.readStructBegin()
11756 
    while True:
11757 
      (fname, ftype, fid) = iprot.readFieldBegin()
11758 
      if ftype == TType.STOP:
11759 
        break
11760 
      if fid == 0:
3064 chandransh 11761 
        if ftype == TType.I64:
11762 
          self.success = iprot.readI64();
921 rajveer 11763 
        else:
11764 
          iprot.skip(ftype)
11765 
      elif fid == 1:
11766 
        if ftype == TType.STRUCT:
11767 
          self.ex = TransactionServiceException()
11768 
          self.ex.read(iprot)
11769 
        else:
11770 
          iprot.skip(ftype)
11771 
      else:
11772 
        iprot.skip(ftype)
11773 
      iprot.readFieldEnd()
11774 
    iprot.readStructEnd()
11775 
 
11776 
  def write(self, oprot):
11777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11779 
      return
3064 chandransh 11780 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11781 
    if self.success is not None:
3064 chandransh 11782 
      oprot.writeFieldBegin('success', TType.I64, 0)
11783 
      oprot.writeI64(self.success)
921 rajveer 11784 
      oprot.writeFieldEnd()
3431 rajveer 11785 
    if self.ex is not None:
921 rajveer 11786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11787 
      self.ex.write(oprot)
11788 
      oprot.writeFieldEnd()
11789 
    oprot.writeFieldStop()
11790 
    oprot.writeStructEnd()
11791 
 
3431 rajveer 11792 
  def validate(self):
11793 
    return
11794 
 
11795 
 
921 rajveer 11796 
  def __repr__(self):
11797 
    L = ['%s=%r' % (key, value)
11798 
      for key, value in self.__dict__.iteritems()]
11799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11800 
 
11801 
  def __eq__(self, other):
11802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11803 
 
11804 
  def __ne__(self, other):
11805 
    return not (self == other)
11806 
 
3064 chandransh 11807 
class getOrder_args:
921 rajveer 11808 
  """
11809 
  Attributes:
3064 chandransh 11810 
   - id
921 rajveer 11811 
  """
11812 
 
11813 
  thrift_spec = (
11814 
    None, # 0
3064 chandransh 11815 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11816 
  )
11817 
 
3064 chandransh 11818 
  def __init__(self, id=None,):
11819 
    self.id = id
921 rajveer 11820 
 
11821 
  def read(self, iprot):
11822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11824 
      return
11825 
    iprot.readStructBegin()
11826 
    while True:
11827 
      (fname, ftype, fid) = iprot.readFieldBegin()
11828 
      if ftype == TType.STOP:
11829 
        break
11830 
      if fid == 1:
11831 
        if ftype == TType.I64:
3064 chandransh 11832 
          self.id = iprot.readI64();
921 rajveer 11833 
        else:
11834 
          iprot.skip(ftype)
11835 
      else:
11836 
        iprot.skip(ftype)
11837 
      iprot.readFieldEnd()
11838 
    iprot.readStructEnd()
11839 
 
11840 
  def write(self, oprot):
11841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11843 
      return
3064 chandransh 11844 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11845 
    if self.id is not None:
3064 chandransh 11846 
      oprot.writeFieldBegin('id', TType.I64, 1)
11847 
      oprot.writeI64(self.id)
921 rajveer 11848 
      oprot.writeFieldEnd()
11849 
    oprot.writeFieldStop()
11850 
    oprot.writeStructEnd()
11851 
 
3431 rajveer 11852 
  def validate(self):
11853 
    return
11854 
 
11855 
 
921 rajveer 11856 
  def __repr__(self):
11857 
    L = ['%s=%r' % (key, value)
11858 
      for key, value in self.__dict__.iteritems()]
11859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11860 
 
11861 
  def __eq__(self, other):
11862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11863 
 
11864 
  def __ne__(self, other):
11865 
    return not (self == other)
11866 
 
3064 chandransh 11867 
class getOrder_result:
921 rajveer 11868 
  """
11869 
  Attributes:
11870 
   - success
11871 
   - ex
11872 
  """
11873 
 
11874 
  thrift_spec = (
3064 chandransh 11875 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11877 
  )
11878 
 
11879 
  def __init__(self, success=None, ex=None,):
11880 
    self.success = success
11881 
    self.ex = ex
11882 
 
11883 
  def read(self, iprot):
11884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11886 
      return
11887 
    iprot.readStructBegin()
11888 
    while True:
11889 
      (fname, ftype, fid) = iprot.readFieldBegin()
11890 
      if ftype == TType.STOP:
11891 
        break
11892 
      if fid == 0:
3064 chandransh 11893 
        if ftype == TType.STRUCT:
11894 
          self.success = Order()
11895 
          self.success.read(iprot)
921 rajveer 11896 
        else:
11897 
          iprot.skip(ftype)
11898 
      elif fid == 1:
11899 
        if ftype == TType.STRUCT:
11900 
          self.ex = TransactionServiceException()
11901 
          self.ex.read(iprot)
11902 
        else:
11903 
          iprot.skip(ftype)
11904 
      else:
11905 
        iprot.skip(ftype)
11906 
      iprot.readFieldEnd()
11907 
    iprot.readStructEnd()
11908 
 
11909 
  def write(self, oprot):
11910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11912 
      return
3064 chandransh 11913 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11914 
    if self.success is not None:
3064 chandransh 11915 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11916 
      self.success.write(oprot)
921 rajveer 11917 
      oprot.writeFieldEnd()
3431 rajveer 11918 
    if self.ex is not None:
921 rajveer 11919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11920 
      self.ex.write(oprot)
11921 
      oprot.writeFieldEnd()
11922 
    oprot.writeFieldStop()
11923 
    oprot.writeStructEnd()
11924 
 
3431 rajveer 11925 
  def validate(self):
11926 
    return
11927 
 
11928 
 
921 rajveer 11929 
  def __repr__(self):
11930 
    L = ['%s=%r' % (key, value)
11931 
      for key, value in self.__dict__.iteritems()]
11932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11933 
 
11934 
  def __eq__(self, other):
11935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11936 
 
11937 
  def __ne__(self, other):
11938 
    return not (self == other)
11939 
 
3064 chandransh 11940 
class getLineItemsForOrder_args:
94 ashish 11941 
  """
11942 
  Attributes:
3064 chandransh 11943 
   - orderId
94 ashish 11944 
  """
11945 
 
11946 
  thrift_spec = (
11947 
    None, # 0
3064 chandransh 11948 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11949 
  )
11950 
 
3064 chandransh 11951 
  def __init__(self, orderId=None,):
11952 
    self.orderId = orderId
94 ashish 11953 
 
11954 
  def read(self, iprot):
11955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11957 
      return
11958 
    iprot.readStructBegin()
11959 
    while True:
11960 
      (fname, ftype, fid) = iprot.readFieldBegin()
11961 
      if ftype == TType.STOP:
11962 
        break
11963 
      if fid == 1:
11964 
        if ftype == TType.I64:
3064 chandransh 11965 
          self.orderId = iprot.readI64();
94 ashish 11966 
        else:
11967 
          iprot.skip(ftype)
11968 
      else:
11969 
        iprot.skip(ftype)
11970 
      iprot.readFieldEnd()
11971 
    iprot.readStructEnd()
11972 
 
11973 
  def write(self, oprot):
11974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11976 
      return
3064 chandransh 11977 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11978 
    if self.orderId is not None:
3064 chandransh 11979 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11980 
      oprot.writeI64(self.orderId)
94 ashish 11981 
      oprot.writeFieldEnd()
11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
3431 rajveer 11985 
  def validate(self):
11986 
    return
11987 
 
11988 
 
94 ashish 11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
3064 chandransh 12000 
class getLineItemsForOrder_result:
94 ashish 12001 
  """
12002 
  Attributes:
12003 
   - success
12004 
   - ex
12005 
  """
12006 
 
12007 
  thrift_spec = (
3064 chandransh 12008 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12010 
  )
12011 
 
12012 
  def __init__(self, success=None, ex=None,):
12013 
    self.success = success
12014 
    self.ex = ex
12015 
 
12016 
  def read(self, iprot):
12017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12019 
      return
12020 
    iprot.readStructBegin()
12021 
    while True:
12022 
      (fname, ftype, fid) = iprot.readFieldBegin()
12023 
      if ftype == TType.STOP:
12024 
        break
12025 
      if fid == 0:
483 rajveer 12026 
        if ftype == TType.LIST:
12027 
          self.success = []
6188 rajveer 12028 
          (_etype207, _size204) = iprot.readListBegin()
12029 
          for _i208 in xrange(_size204):
12030 
            _elem209 = LineItem()
12031 
            _elem209.read(iprot)
12032 
            self.success.append(_elem209)
483 rajveer 12033 
          iprot.readListEnd()
94 ashish 12034 
        else:
12035 
          iprot.skip(ftype)
12036 
      elif fid == 1:
12037 
        if ftype == TType.STRUCT:
12038 
          self.ex = TransactionServiceException()
12039 
          self.ex.read(iprot)
12040 
        else:
12041 
          iprot.skip(ftype)
12042 
      else:
12043 
        iprot.skip(ftype)
12044 
      iprot.readFieldEnd()
12045 
    iprot.readStructEnd()
12046 
 
12047 
  def write(self, oprot):
12048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12050 
      return
3064 chandransh 12051 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12052 
    if self.success is not None:
483 rajveer 12053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12055 
      for iter210 in self.success:
12056 
        iter210.write(oprot)
483 rajveer 12057 
      oprot.writeListEnd()
94 ashish 12058 
      oprot.writeFieldEnd()
3431 rajveer 12059 
    if self.ex is not None:
94 ashish 12060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12061 
      self.ex.write(oprot)
12062 
      oprot.writeFieldEnd()
12063 
    oprot.writeFieldStop()
12064 
    oprot.writeStructEnd()
12065 
 
3431 rajveer 12066 
  def validate(self):
12067 
    return
12068 
 
12069 
 
94 ashish 12070 
  def __repr__(self):
12071 
    L = ['%s=%r' % (key, value)
12072 
      for key, value in self.__dict__.iteritems()]
12073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12074 
 
12075 
  def __eq__(self, other):
12076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12077 
 
12078 
  def __ne__(self, other):
12079 
    return not (self == other)
12080 
 
4999 phani.kuma 12081 
class getOrderList_args:
12082 
  """
12083 
  Attributes:
12084 
   - order_ids
12085 
  """
12086 
 
12087 
  thrift_spec = (
12088 
    None, # 0
12089 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12090 
  )
12091 
 
12092 
  def __init__(self, order_ids=None,):
12093 
    self.order_ids = order_ids
12094 
 
12095 
  def read(self, iprot):
12096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12098 
      return
12099 
    iprot.readStructBegin()
12100 
    while True:
12101 
      (fname, ftype, fid) = iprot.readFieldBegin()
12102 
      if ftype == TType.STOP:
12103 
        break
12104 
      if fid == 1:
12105 
        if ftype == TType.LIST:
12106 
          self.order_ids = []
6188 rajveer 12107 
          (_etype214, _size211) = iprot.readListBegin()
12108 
          for _i215 in xrange(_size211):
12109 
            _elem216 = iprot.readI64();
12110 
            self.order_ids.append(_elem216)
4999 phani.kuma 12111 
          iprot.readListEnd()
12112 
        else:
12113 
          iprot.skip(ftype)
12114 
      else:
12115 
        iprot.skip(ftype)
12116 
      iprot.readFieldEnd()
12117 
    iprot.readStructEnd()
12118 
 
12119 
  def write(self, oprot):
12120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12122 
      return
12123 
    oprot.writeStructBegin('getOrderList_args')
12124 
    if self.order_ids is not None:
12125 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12126 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12127 
      for iter217 in self.order_ids:
12128 
        oprot.writeI64(iter217)
4999 phani.kuma 12129 
      oprot.writeListEnd()
12130 
      oprot.writeFieldEnd()
12131 
    oprot.writeFieldStop()
12132 
    oprot.writeStructEnd()
12133 
 
12134 
  def validate(self):
12135 
    return
12136 
 
12137 
 
12138 
  def __repr__(self):
12139 
    L = ['%s=%r' % (key, value)
12140 
      for key, value in self.__dict__.iteritems()]
12141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12142 
 
12143 
  def __eq__(self, other):
12144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12145 
 
12146 
  def __ne__(self, other):
12147 
    return not (self == other)
12148 
 
12149 
class getOrderList_result:
12150 
  """
12151 
  Attributes:
12152 
   - success
12153 
  """
12154 
 
12155 
  thrift_spec = (
12156 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12157 
  )
12158 
 
12159 
  def __init__(self, success=None,):
12160 
    self.success = success
12161 
 
12162 
  def read(self, iprot):
12163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12165 
      return
12166 
    iprot.readStructBegin()
12167 
    while True:
12168 
      (fname, ftype, fid) = iprot.readFieldBegin()
12169 
      if ftype == TType.STOP:
12170 
        break
12171 
      if fid == 0:
12172 
        if ftype == TType.LIST:
12173 
          self.success = []
6188 rajveer 12174 
          (_etype221, _size218) = iprot.readListBegin()
12175 
          for _i222 in xrange(_size218):
12176 
            _elem223 = Order()
12177 
            _elem223.read(iprot)
12178 
            self.success.append(_elem223)
4999 phani.kuma 12179 
          iprot.readListEnd()
12180 
        else:
12181 
          iprot.skip(ftype)
12182 
      else:
12183 
        iprot.skip(ftype)
12184 
      iprot.readFieldEnd()
12185 
    iprot.readStructEnd()
12186 
 
12187 
  def write(self, oprot):
12188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12190 
      return
12191 
    oprot.writeStructBegin('getOrderList_result')
12192 
    if self.success is not None:
12193 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12194 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12195 
      for iter224 in self.success:
12196 
        iter224.write(oprot)
4999 phani.kuma 12197 
      oprot.writeListEnd()
12198 
      oprot.writeFieldEnd()
12199 
    oprot.writeFieldStop()
12200 
    oprot.writeStructEnd()
12201 
 
12202 
  def validate(self):
12203 
    return
12204 
 
12205 
 
12206 
  def __repr__(self):
12207 
    L = ['%s=%r' % (key, value)
12208 
      for key, value in self.__dict__.iteritems()]
12209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12210 
 
12211 
  def __eq__(self, other):
12212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12213 
 
12214 
  def __ne__(self, other):
12215 
    return not (self == other)
12216 
 
5386 phani.kuma 12217 
class getOrderListForVendor_args:
12218 
  """
12219 
  Attributes:
12220 
   - order_ids
12221 
   - vendorId
12222 
  """
12223 
 
12224 
  thrift_spec = (
12225 
    None, # 0
12226 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12227 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12228 
  )
12229 
 
12230 
  def __init__(self, order_ids=None, vendorId=None,):
12231 
    self.order_ids = order_ids
12232 
    self.vendorId = vendorId
12233 
 
12234 
  def read(self, iprot):
12235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12237 
      return
12238 
    iprot.readStructBegin()
12239 
    while True:
12240 
      (fname, ftype, fid) = iprot.readFieldBegin()
12241 
      if ftype == TType.STOP:
12242 
        break
12243 
      if fid == 1:
12244 
        if ftype == TType.LIST:
12245 
          self.order_ids = []
6188 rajveer 12246 
          (_etype228, _size225) = iprot.readListBegin()
12247 
          for _i229 in xrange(_size225):
12248 
            _elem230 = iprot.readI64();
12249 
            self.order_ids.append(_elem230)
5386 phani.kuma 12250 
          iprot.readListEnd()
12251 
        else:
12252 
          iprot.skip(ftype)
12253 
      elif fid == 2:
12254 
        if ftype == TType.I64:
12255 
          self.vendorId = iprot.readI64();
12256 
        else:
12257 
          iprot.skip(ftype)
12258 
      else:
12259 
        iprot.skip(ftype)
12260 
      iprot.readFieldEnd()
12261 
    iprot.readStructEnd()
12262 
 
12263 
  def write(self, oprot):
12264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12266 
      return
12267 
    oprot.writeStructBegin('getOrderListForVendor_args')
12268 
    if self.order_ids is not None:
12269 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12270 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12271 
      for iter231 in self.order_ids:
12272 
        oprot.writeI64(iter231)
5386 phani.kuma 12273 
      oprot.writeListEnd()
12274 
      oprot.writeFieldEnd()
12275 
    if self.vendorId is not None:
12276 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12277 
      oprot.writeI64(self.vendorId)
12278 
      oprot.writeFieldEnd()
12279 
    oprot.writeFieldStop()
12280 
    oprot.writeStructEnd()
12281 
 
12282 
  def validate(self):
12283 
    return
12284 
 
12285 
 
12286 
  def __repr__(self):
12287 
    L = ['%s=%r' % (key, value)
12288 
      for key, value in self.__dict__.iteritems()]
12289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12290 
 
12291 
  def __eq__(self, other):
12292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12293 
 
12294 
  def __ne__(self, other):
12295 
    return not (self == other)
12296 
 
12297 
class getOrderListForVendor_result:
12298 
  """
12299 
  Attributes:
12300 
   - success
12301 
  """
12302 
 
12303 
  thrift_spec = (
12304 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12305 
  )
12306 
 
12307 
  def __init__(self, success=None,):
12308 
    self.success = success
12309 
 
12310 
  def read(self, iprot):
12311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12313 
      return
12314 
    iprot.readStructBegin()
12315 
    while True:
12316 
      (fname, ftype, fid) = iprot.readFieldBegin()
12317 
      if ftype == TType.STOP:
12318 
        break
12319 
      if fid == 0:
12320 
        if ftype == TType.LIST:
12321 
          self.success = []
6188 rajveer 12322 
          (_etype235, _size232) = iprot.readListBegin()
12323 
          for _i236 in xrange(_size232):
12324 
            _elem237 = Order()
12325 
            _elem237.read(iprot)
12326 
            self.success.append(_elem237)
5386 phani.kuma 12327 
          iprot.readListEnd()
12328 
        else:
12329 
          iprot.skip(ftype)
12330 
      else:
12331 
        iprot.skip(ftype)
12332 
      iprot.readFieldEnd()
12333 
    iprot.readStructEnd()
12334 
 
12335 
  def write(self, oprot):
12336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12338 
      return
12339 
    oprot.writeStructBegin('getOrderListForVendor_result')
12340 
    if self.success is not None:
12341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12342 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12343 
      for iter238 in self.success:
12344 
        iter238.write(oprot)
5386 phani.kuma 12345 
      oprot.writeListEnd()
12346 
      oprot.writeFieldEnd()
12347 
    oprot.writeFieldStop()
12348 
    oprot.writeStructEnd()
12349 
 
12350 
  def validate(self):
12351 
    return
12352 
 
12353 
 
12354 
  def __repr__(self):
12355 
    L = ['%s=%r' % (key, value)
12356 
      for key, value in self.__dict__.iteritems()]
12357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12358 
 
12359 
  def __eq__(self, other):
12360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12361 
 
12362 
  def __ne__(self, other):
12363 
    return not (self == other)
12364 
 
3064 chandransh 12365 
class getOrderForCustomer_args:
94 ashish 12366 
  """
12367 
  Attributes:
3064 chandransh 12368 
   - orderId
483 rajveer 12369 
   - customerId
94 ashish 12370 
  """
12371 
 
12372 
  thrift_spec = (
12373 
    None, # 0
3064 chandransh 12374 
    (1, TType.I64, 'orderId', None, None, ), # 1
12375 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12376 
  )
12377 
 
3064 chandransh 12378 
  def __init__(self, orderId=None, customerId=None,):
12379 
    self.orderId = orderId
483 rajveer 12380 
    self.customerId = customerId
94 ashish 12381 
 
12382 
  def read(self, iprot):
12383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12385 
      return
12386 
    iprot.readStructBegin()
12387 
    while True:
12388 
      (fname, ftype, fid) = iprot.readFieldBegin()
12389 
      if ftype == TType.STOP:
12390 
        break
12391 
      if fid == 1:
12392 
        if ftype == TType.I64:
3064 chandransh 12393 
          self.orderId = iprot.readI64();
94 ashish 12394 
        else:
12395 
          iprot.skip(ftype)
12396 
      elif fid == 2:
12397 
        if ftype == TType.I64:
3064 chandransh 12398 
          self.customerId = iprot.readI64();
94 ashish 12399 
        else:
12400 
          iprot.skip(ftype)
12401 
      else:
12402 
        iprot.skip(ftype)
12403 
      iprot.readFieldEnd()
12404 
    iprot.readStructEnd()
12405 
 
12406 
  def write(self, oprot):
12407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12409 
      return
3064 chandransh 12410 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12411 
    if self.orderId is not None:
3064 chandransh 12412 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12413 
      oprot.writeI64(self.orderId)
12414 
      oprot.writeFieldEnd()
3431 rajveer 12415 
    if self.customerId is not None:
3064 chandransh 12416 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12417 
      oprot.writeI64(self.customerId)
94 ashish 12418 
      oprot.writeFieldEnd()
12419 
    oprot.writeFieldStop()
12420 
    oprot.writeStructEnd()
12421 
 
3431 rajveer 12422 
  def validate(self):
12423 
    return
12424 
 
12425 
 
94 ashish 12426 
  def __repr__(self):
12427 
    L = ['%s=%r' % (key, value)
12428 
      for key, value in self.__dict__.iteritems()]
12429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12430 
 
12431 
  def __eq__(self, other):
12432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12433 
 
12434 
  def __ne__(self, other):
12435 
    return not (self == other)
12436 
 
3064 chandransh 12437 
class getOrderForCustomer_result:
94 ashish 12438 
  """
12439 
  Attributes:
12440 
   - success
12441 
   - ex
12442 
  """
12443 
 
12444 
  thrift_spec = (
3064 chandransh 12445 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12447 
  )
12448 
 
12449 
  def __init__(self, success=None, ex=None,):
12450 
    self.success = success
12451 
    self.ex = ex
12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 0:
3064 chandransh 12463 
        if ftype == TType.STRUCT:
12464 
          self.success = Order()
12465 
          self.success.read(iprot)
94 ashish 12466 
        else:
12467 
          iprot.skip(ftype)
12468 
      elif fid == 1:
12469 
        if ftype == TType.STRUCT:
12470 
          self.ex = TransactionServiceException()
12471 
          self.ex.read(iprot)
12472 
        else:
12473 
          iprot.skip(ftype)
12474 
      else:
12475 
        iprot.skip(ftype)
12476 
      iprot.readFieldEnd()
12477 
    iprot.readStructEnd()
12478 
 
12479 
  def write(self, oprot):
12480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12482 
      return
3064 chandransh 12483 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12484 
    if self.success is not None:
3064 chandransh 12485 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12486 
      self.success.write(oprot)
94 ashish 12487 
      oprot.writeFieldEnd()
3431 rajveer 12488 
    if self.ex is not None:
94 ashish 12489 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12490 
      self.ex.write(oprot)
12491 
      oprot.writeFieldEnd()
12492 
    oprot.writeFieldStop()
12493 
    oprot.writeStructEnd()
12494 
 
3431 rajveer 12495 
  def validate(self):
12496 
    return
12497 
 
12498 
 
94 ashish 12499 
  def __repr__(self):
12500 
    L = ['%s=%r' % (key, value)
12501 
      for key, value in self.__dict__.iteritems()]
12502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12503 
 
12504 
  def __eq__(self, other):
12505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12506 
 
12507 
  def __ne__(self, other):
12508 
    return not (self == other)
12509 
 
3064 chandransh 12510 
class getAlerts_args:
94 ashish 12511 
  """
12512 
  Attributes:
4394 rajveer 12513 
   - type
4444 rajveer 12514 
   - warehouseId
4394 rajveer 12515 
   - status
12516 
   - timestamp
94 ashish 12517 
  """
12518 
 
12519 
  thrift_spec = (
12520 
    None, # 0
4394 rajveer 12521 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12522 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12523 
    (3, TType.I64, 'status', None, None, ), # 3
12524 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12525 
  )
12526 
 
4444 rajveer 12527 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12528 
    self.type = type
4444 rajveer 12529 
    self.warehouseId = warehouseId
4394 rajveer 12530 
    self.status = status
12531 
    self.timestamp = timestamp
94 ashish 12532 
 
12533 
  def read(self, iprot):
12534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12536 
      return
12537 
    iprot.readStructBegin()
12538 
    while True:
12539 
      (fname, ftype, fid) = iprot.readFieldBegin()
12540 
      if ftype == TType.STOP:
12541 
        break
12542 
      if fid == 1:
3064 chandransh 12543 
        if ftype == TType.I64:
4394 rajveer 12544 
          self.type = iprot.readI64();
94 ashish 12545 
        else:
12546 
          iprot.skip(ftype)
3064 chandransh 12547 
      elif fid == 2:
4394 rajveer 12548 
        if ftype == TType.I64:
4444 rajveer 12549 
          self.warehouseId = iprot.readI64();
3064 chandransh 12550 
        else:
12551 
          iprot.skip(ftype)
4394 rajveer 12552 
      elif fid == 3:
12553 
        if ftype == TType.I64:
4444 rajveer 12554 
          self.status = iprot.readI64();
12555 
        else:
12556 
          iprot.skip(ftype)
12557 
      elif fid == 4:
12558 
        if ftype == TType.I64:
4394 rajveer 12559 
          self.timestamp = iprot.readI64();
12560 
        else:
12561 
          iprot.skip(ftype)
94 ashish 12562 
      else:
12563 
        iprot.skip(ftype)
12564 
      iprot.readFieldEnd()
12565 
    iprot.readStructEnd()
12566 
 
12567 
  def write(self, oprot):
12568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12570 
      return
3064 chandransh 12571 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12572 
    if self.type is not None:
12573 
      oprot.writeFieldBegin('type', TType.I64, 1)
12574 
      oprot.writeI64(self.type)
94 ashish 12575 
      oprot.writeFieldEnd()
4444 rajveer 12576 
    if self.warehouseId is not None:
12577 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12578 
      oprot.writeI64(self.warehouseId)
12579 
      oprot.writeFieldEnd()
4394 rajveer 12580 
    if self.status is not None:
4444 rajveer 12581 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12582 
      oprot.writeI64(self.status)
3064 chandransh 12583 
      oprot.writeFieldEnd()
4394 rajveer 12584 
    if self.timestamp is not None:
4444 rajveer 12585 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12586 
      oprot.writeI64(self.timestamp)
12587 
      oprot.writeFieldEnd()
94 ashish 12588 
    oprot.writeFieldStop()
12589 
    oprot.writeStructEnd()
12590 
 
3431 rajveer 12591 
  def validate(self):
12592 
    return
12593 
 
12594 
 
94 ashish 12595 
  def __repr__(self):
12596 
    L = ['%s=%r' % (key, value)
12597 
      for key, value in self.__dict__.iteritems()]
12598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12599 
 
12600 
  def __eq__(self, other):
12601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12602 
 
12603 
  def __ne__(self, other):
12604 
    return not (self == other)
12605 
 
3064 chandransh 12606 
class getAlerts_result:
94 ashish 12607 
  """
12608 
  Attributes:
12609 
   - success
12610 
  """
12611 
 
12612 
  thrift_spec = (
3064 chandransh 12613 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12614 
  )
12615 
 
3064 chandransh 12616 
  def __init__(self, success=None,):
94 ashish 12617 
    self.success = success
12618 
 
12619 
  def read(self, iprot):
12620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12622 
      return
12623 
    iprot.readStructBegin()
12624 
    while True:
12625 
      (fname, ftype, fid) = iprot.readFieldBegin()
12626 
      if ftype == TType.STOP:
12627 
        break
12628 
      if fid == 0:
3064 chandransh 12629 
        if ftype == TType.LIST:
12630 
          self.success = []
6188 rajveer 12631 
          (_etype242, _size239) = iprot.readListBegin()
12632 
          for _i243 in xrange(_size239):
12633 
            _elem244 = Alert()
12634 
            _elem244.read(iprot)
12635 
            self.success.append(_elem244)
3064 chandransh 12636 
          iprot.readListEnd()
94 ashish 12637 
        else:
12638 
          iprot.skip(ftype)
12639 
      else:
12640 
        iprot.skip(ftype)
12641 
      iprot.readFieldEnd()
12642 
    iprot.readStructEnd()
12643 
 
12644 
  def write(self, oprot):
12645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12647 
      return
3064 chandransh 12648 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12649 
    if self.success is not None:
3064 chandransh 12650 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12651 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12652 
      for iter245 in self.success:
12653 
        iter245.write(oprot)
3064 chandransh 12654 
      oprot.writeListEnd()
94 ashish 12655 
      oprot.writeFieldEnd()
12656 
    oprot.writeFieldStop()
12657 
    oprot.writeStructEnd()
12658 
 
3431 rajveer 12659 
  def validate(self):
12660 
    return
12661 
 
12662 
 
94 ashish 12663 
  def __repr__(self):
12664 
    L = ['%s=%r' % (key, value)
12665 
      for key, value in self.__dict__.iteritems()]
12666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12667 
 
12668 
  def __eq__(self, other):
12669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12670 
 
12671 
  def __ne__(self, other):
12672 
    return not (self == other)
12673 
 
4394 rajveer 12674 
class addAlert_args:
94 ashish 12675 
  """
12676 
  Attributes:
3064 chandransh 12677 
   - type
4444 rajveer 12678 
   - warehouseId
4394 rajveer 12679 
   - description
94 ashish 12680 
  """
12681 
 
12682 
  thrift_spec = (
12683 
    None, # 0
4394 rajveer 12684 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12685 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12686 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12687 
  )
12688 
 
4444 rajveer 12689 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12690 
    self.type = type
4444 rajveer 12691 
    self.warehouseId = warehouseId
4394 rajveer 12692 
    self.description = description
94 ashish 12693 
 
12694 
  def read(self, iprot):
12695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12697 
      return
12698 
    iprot.readStructBegin()
12699 
    while True:
12700 
      (fname, ftype, fid) = iprot.readFieldBegin()
12701 
      if ftype == TType.STOP:
12702 
        break
12703 
      if fid == 1:
12704 
        if ftype == TType.I64:
4394 rajveer 12705 
          self.type = iprot.readI64();
94 ashish 12706 
        else:
12707 
          iprot.skip(ftype)
3064 chandransh 12708 
      elif fid == 2:
4444 rajveer 12709 
        if ftype == TType.I64:
12710 
          self.warehouseId = iprot.readI64();
12711 
        else:
12712 
          iprot.skip(ftype)
12713 
      elif fid == 3:
3064 chandransh 12714 
        if ftype == TType.STRING:
4394 rajveer 12715 
          self.description = iprot.readString();
3064 chandransh 12716 
        else:
12717 
          iprot.skip(ftype)
94 ashish 12718 
      else:
12719 
        iprot.skip(ftype)
12720 
      iprot.readFieldEnd()
12721 
    iprot.readStructEnd()
12722 
 
12723 
  def write(self, oprot):
12724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12726 
      return
4394 rajveer 12727 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12728 
    if self.type is not None:
4394 rajveer 12729 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12730 
      oprot.writeI64(self.type)
12731 
      oprot.writeFieldEnd()
4444 rajveer 12732 
    if self.warehouseId is not None:
12733 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12734 
      oprot.writeI64(self.warehouseId)
12735 
      oprot.writeFieldEnd()
4394 rajveer 12736 
    if self.description is not None:
4444 rajveer 12737 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12738 
      oprot.writeString(self.description)
3064 chandransh 12739 
      oprot.writeFieldEnd()
94 ashish 12740 
    oprot.writeFieldStop()
12741 
    oprot.writeStructEnd()
12742 
 
3431 rajveer 12743 
  def validate(self):
12744 
    return
12745 
 
12746 
 
94 ashish 12747 
  def __repr__(self):
12748 
    L = ['%s=%r' % (key, value)
12749 
      for key, value in self.__dict__.iteritems()]
12750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12751 
 
12752 
  def __eq__(self, other):
12753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12754 
 
12755 
  def __ne__(self, other):
12756 
    return not (self == other)
12757 
 
4394 rajveer 12758 
class addAlert_result:
3064 chandransh 12759 
 
12760 
  thrift_spec = (
12761 
  )
12762 
 
12763 
  def read(self, iprot):
12764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12766 
      return
12767 
    iprot.readStructBegin()
12768 
    while True:
12769 
      (fname, ftype, fid) = iprot.readFieldBegin()
12770 
      if ftype == TType.STOP:
12771 
        break
12772 
      else:
12773 
        iprot.skip(ftype)
12774 
      iprot.readFieldEnd()
12775 
    iprot.readStructEnd()
12776 
 
12777 
  def write(self, oprot):
12778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12780 
      return
4394 rajveer 12781 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12782 
    oprot.writeFieldStop()
12783 
    oprot.writeStructEnd()
12784 
 
3431 rajveer 12785 
  def validate(self):
12786 
    return
12787 
 
12788 
 
3064 chandransh 12789 
  def __repr__(self):
12790 
    L = ['%s=%r' % (key, value)
12791 
      for key, value in self.__dict__.iteritems()]
12792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12793 
 
12794 
  def __eq__(self, other):
12795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12796 
 
12797 
  def __ne__(self, other):
12798 
    return not (self == other)
12799 
 
4444 rajveer 12800 
class markAlertsAsSeen_args:
12801 
  """
12802 
  Attributes:
12803 
   - warehouseId
12804 
  """
12805 
 
12806 
  thrift_spec = (
12807 
    None, # 0
12808 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12809 
  )
12810 
 
12811 
  def __init__(self, warehouseId=None,):
12812 
    self.warehouseId = warehouseId
12813 
 
12814 
  def read(self, iprot):
12815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12817 
      return
12818 
    iprot.readStructBegin()
12819 
    while True:
12820 
      (fname, ftype, fid) = iprot.readFieldBegin()
12821 
      if ftype == TType.STOP:
12822 
        break
12823 
      if fid == 1:
12824 
        if ftype == TType.I64:
12825 
          self.warehouseId = iprot.readI64();
12826 
        else:
12827 
          iprot.skip(ftype)
12828 
      else:
12829 
        iprot.skip(ftype)
12830 
      iprot.readFieldEnd()
12831 
    iprot.readStructEnd()
12832 
 
12833 
  def write(self, oprot):
12834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12836 
      return
12837 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12838 
    if self.warehouseId is not None:
12839 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12840 
      oprot.writeI64(self.warehouseId)
12841 
      oprot.writeFieldEnd()
12842 
    oprot.writeFieldStop()
12843 
    oprot.writeStructEnd()
12844 
 
12845 
  def validate(self):
12846 
    return
12847 
 
12848 
 
12849 
  def __repr__(self):
12850 
    L = ['%s=%r' % (key, value)
12851 
      for key, value in self.__dict__.iteritems()]
12852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12853 
 
12854 
  def __eq__(self, other):
12855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12856 
 
12857 
  def __ne__(self, other):
12858 
    return not (self == other)
12859 
 
12860 
class markAlertsAsSeen_result:
12861 
 
12862 
  thrift_spec = (
12863 
  )
12864 
 
12865 
  def read(self, iprot):
12866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12868 
      return
12869 
    iprot.readStructBegin()
12870 
    while True:
12871 
      (fname, ftype, fid) = iprot.readFieldBegin()
12872 
      if ftype == TType.STOP:
12873 
        break
12874 
      else:
12875 
        iprot.skip(ftype)
12876 
      iprot.readFieldEnd()
12877 
    iprot.readStructEnd()
12878 
 
12879 
  def write(self, oprot):
12880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12882 
      return
12883 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12884 
    oprot.writeFieldStop()
12885 
    oprot.writeStructEnd()
12886 
 
12887 
  def validate(self):
12888 
    return
12889 
 
12890 
 
12891 
  def __repr__(self):
12892 
    L = ['%s=%r' % (key, value)
12893 
      for key, value in self.__dict__.iteritems()]
12894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12895 
 
12896 
  def __eq__(self, other):
12897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12898 
 
12899 
  def __ne__(self, other):
12900 
    return not (self == other)
12901 
 
3064 chandransh 12902 
class getValidOrderCount_args:
12903 
 
12904 
  thrift_spec = (
12905 
  )
12906 
 
12907 
  def read(self, iprot):
12908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12910 
      return
12911 
    iprot.readStructBegin()
12912 
    while True:
12913 
      (fname, ftype, fid) = iprot.readFieldBegin()
12914 
      if ftype == TType.STOP:
12915 
        break
12916 
      else:
12917 
        iprot.skip(ftype)
12918 
      iprot.readFieldEnd()
12919 
    iprot.readStructEnd()
12920 
 
12921 
  def write(self, oprot):
12922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12924 
      return
12925 
    oprot.writeStructBegin('getValidOrderCount_args')
12926 
    oprot.writeFieldStop()
12927 
    oprot.writeStructEnd()
12928 
 
3431 rajveer 12929 
  def validate(self):
12930 
    return
12931 
 
12932 
 
3064 chandransh 12933 
  def __repr__(self):
12934 
    L = ['%s=%r' % (key, value)
12935 
      for key, value in self.__dict__.iteritems()]
12936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12937 
 
12938 
  def __eq__(self, other):
12939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12940 
 
12941 
  def __ne__(self, other):
12942 
    return not (self == other)
12943 
 
12944 
class getValidOrderCount_result:
94 ashish 12945 
  """
12946 
  Attributes:
12947 
   - success
12948 
  """
12949 
 
12950 
  thrift_spec = (
3064 chandransh 12951 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12952 
  )
12953 
 
3064 chandransh 12954 
  def __init__(self, success=None,):
94 ashish 12955 
    self.success = success
12956 
 
12957 
  def read(self, iprot):
12958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12960 
      return
12961 
    iprot.readStructBegin()
12962 
    while True:
12963 
      (fname, ftype, fid) = iprot.readFieldBegin()
12964 
      if ftype == TType.STOP:
12965 
        break
12966 
      if fid == 0:
3064 chandransh 12967 
        if ftype == TType.I64:
12968 
          self.success = iprot.readI64();
94 ashish 12969 
        else:
12970 
          iprot.skip(ftype)
12971 
      else:
12972 
        iprot.skip(ftype)
12973 
      iprot.readFieldEnd()
12974 
    iprot.readStructEnd()
12975 
 
12976 
  def write(self, oprot):
12977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12979 
      return
3064 chandransh 12980 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12981 
    if self.success is not None:
3064 chandransh 12982 
      oprot.writeFieldBegin('success', TType.I64, 0)
12983 
      oprot.writeI64(self.success)
94 ashish 12984 
      oprot.writeFieldEnd()
12985 
    oprot.writeFieldStop()
12986 
    oprot.writeStructEnd()
12987 
 
3431 rajveer 12988 
  def validate(self):
12989 
    return
12990 
 
12991 
 
94 ashish 12992 
  def __repr__(self):
12993 
    L = ['%s=%r' % (key, value)
12994 
      for key, value in self.__dict__.iteritems()]
12995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12996 
 
12997 
  def __eq__(self, other):
12998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12999 
 
13000 
  def __ne__(self, other):
13001 
    return not (self == other)
13002 
 
3064 chandransh 13003 
class getNoOfCustomersWithSuccessfulTransaction_args:
13004 
 
13005 
  thrift_spec = (
13006 
  )
13007 
 
13008 
  def read(self, iprot):
13009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13011 
      return
13012 
    iprot.readStructBegin()
13013 
    while True:
13014 
      (fname, ftype, fid) = iprot.readFieldBegin()
13015 
      if ftype == TType.STOP:
13016 
        break
13017 
      else:
13018 
        iprot.skip(ftype)
13019 
      iprot.readFieldEnd()
13020 
    iprot.readStructEnd()
13021 
 
13022 
  def write(self, oprot):
13023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13025 
      return
13026 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13027 
    oprot.writeFieldStop()
13028 
    oprot.writeStructEnd()
13029 
 
3431 rajveer 13030 
  def validate(self):
13031 
    return
13032 
 
13033 
 
3064 chandransh 13034 
  def __repr__(self):
13035 
    L = ['%s=%r' % (key, value)
13036 
      for key, value in self.__dict__.iteritems()]
13037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13038 
 
13039 
  def __eq__(self, other):
13040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13041 
 
13042 
  def __ne__(self, other):
13043 
    return not (self == other)
13044 
 
13045 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13046 
  """
13047 
  Attributes:
3064 chandransh 13048 
   - success
94 ashish 13049 
  """
13050 
 
13051 
  thrift_spec = (
3064 chandransh 13052 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13053 
  )
13054 
 
3064 chandransh 13055 
  def __init__(self, success=None,):
13056 
    self.success = success
94 ashish 13057 
 
13058 
  def read(self, iprot):
13059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13061 
      return
13062 
    iprot.readStructBegin()
13063 
    while True:
13064 
      (fname, ftype, fid) = iprot.readFieldBegin()
13065 
      if ftype == TType.STOP:
13066 
        break
3064 chandransh 13067 
      if fid == 0:
94 ashish 13068 
        if ftype == TType.I64:
3064 chandransh 13069 
          self.success = iprot.readI64();
94 ashish 13070 
        else:
13071 
          iprot.skip(ftype)
13072 
      else:
13073 
        iprot.skip(ftype)
13074 
      iprot.readFieldEnd()
13075 
    iprot.readStructEnd()
13076 
 
13077 
  def write(self, oprot):
13078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13080 
      return
3064 chandransh 13081 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13082 
    if self.success is not None:
3064 chandransh 13083 
      oprot.writeFieldBegin('success', TType.I64, 0)
13084 
      oprot.writeI64(self.success)
94 ashish 13085 
      oprot.writeFieldEnd()
13086 
    oprot.writeFieldStop()
13087 
    oprot.writeStructEnd()
13088 
 
3431 rajveer 13089 
  def validate(self):
13090 
    return
13091 
 
13092 
 
94 ashish 13093 
  def __repr__(self):
13094 
    L = ['%s=%r' % (key, value)
13095 
      for key, value in self.__dict__.iteritems()]
13096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13097 
 
13098 
  def __eq__(self, other):
13099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13100 
 
13101 
  def __ne__(self, other):
13102 
    return not (self == other)
13103 
 
3064 chandransh 13104 
class getValidOrdersAmountRange_args:
13105 
 
13106 
  thrift_spec = (
13107 
  )
13108 
 
13109 
  def read(self, iprot):
13110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13112 
      return
13113 
    iprot.readStructBegin()
13114 
    while True:
13115 
      (fname, ftype, fid) = iprot.readFieldBegin()
13116 
      if ftype == TType.STOP:
13117 
        break
13118 
      else:
13119 
        iprot.skip(ftype)
13120 
      iprot.readFieldEnd()
13121 
    iprot.readStructEnd()
13122 
 
13123 
  def write(self, oprot):
13124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13126 
      return
13127 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13128 
    oprot.writeFieldStop()
13129 
    oprot.writeStructEnd()
13130 
 
3431 rajveer 13131 
  def validate(self):
13132 
    return
13133 
 
13134 
 
3064 chandransh 13135 
  def __repr__(self):
13136 
    L = ['%s=%r' % (key, value)
13137 
      for key, value in self.__dict__.iteritems()]
13138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13139 
 
13140 
  def __eq__(self, other):
13141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13142 
 
13143 
  def __ne__(self, other):
13144 
    return not (self == other)
13145 
 
13146 
class getValidOrdersAmountRange_result:
94 ashish 13147 
  """
13148 
  Attributes:
13149 
   - success
13150 
  """
13151 
 
13152 
  thrift_spec = (
3064 chandransh 13153 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13154 
  )
13155 
 
3064 chandransh 13156 
  def __init__(self, success=None,):
94 ashish 13157 
    self.success = success
13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 0:
483 rajveer 13169 
        if ftype == TType.LIST:
13170 
          self.success = []
6188 rajveer 13171 
          (_etype249, _size246) = iprot.readListBegin()
13172 
          for _i250 in xrange(_size246):
13173 
            _elem251 = iprot.readDouble();
13174 
            self.success.append(_elem251)
483 rajveer 13175 
          iprot.readListEnd()
94 ashish 13176 
        else:
13177 
          iprot.skip(ftype)
13178 
      else:
13179 
        iprot.skip(ftype)
13180 
      iprot.readFieldEnd()
13181 
    iprot.readStructEnd()
13182 
 
13183 
  def write(self, oprot):
13184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13186 
      return
3064 chandransh 13187 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13188 
    if self.success is not None:
483 rajveer 13189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13190 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13191 
      for iter252 in self.success:
13192 
        oprot.writeDouble(iter252)
483 rajveer 13193 
      oprot.writeListEnd()
94 ashish 13194 
      oprot.writeFieldEnd()
13195 
    oprot.writeFieldStop()
13196 
    oprot.writeStructEnd()
13197 
 
3431 rajveer 13198 
  def validate(self):
13199 
    return
13200 
 
13201 
 
94 ashish 13202 
  def __repr__(self):
13203 
    L = ['%s=%r' % (key, value)
13204 
      for key, value in self.__dict__.iteritems()]
13205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13206 
 
13207 
  def __eq__(self, other):
13208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13209 
 
13210 
  def __ne__(self, other):
13211 
    return not (self == other)
13212 
 
3064 chandransh 13213 
class getValidOrders_args:
1528 ankur.sing 13214 
  """
13215 
  Attributes:
3064 chandransh 13216 
   - limit
5874 rajveer 13217 
   - onlyStore
1528 ankur.sing 13218 
  """
13219 
 
13220 
  thrift_spec = (
13221 
    None, # 0
3064 chandransh 13222 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13223 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13224 
  )
13225 
 
5874 rajveer 13226 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13227 
    self.limit = limit
5874 rajveer 13228 
    self.onlyStore = onlyStore
1528 ankur.sing 13229 
 
13230 
  def read(self, iprot):
13231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13233 
      return
13234 
    iprot.readStructBegin()
13235 
    while True:
13236 
      (fname, ftype, fid) = iprot.readFieldBegin()
13237 
      if ftype == TType.STOP:
13238 
        break
13239 
      if fid == 1:
13240 
        if ftype == TType.I64:
3064 chandransh 13241 
          self.limit = iprot.readI64();
1528 ankur.sing 13242 
        else:
13243 
          iprot.skip(ftype)
5874 rajveer 13244 
      elif fid == 2:
13245 
        if ftype == TType.BOOL:
13246 
          self.onlyStore = iprot.readBool();
13247 
        else:
13248 
          iprot.skip(ftype)
1528 ankur.sing 13249 
      else:
13250 
        iprot.skip(ftype)
13251 
      iprot.readFieldEnd()
13252 
    iprot.readStructEnd()
13253 
 
13254 
  def write(self, oprot):
13255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13257 
      return
3064 chandransh 13258 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13259 
    if self.limit is not None:
3064 chandransh 13260 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13261 
      oprot.writeI64(self.limit)
1528 ankur.sing 13262 
      oprot.writeFieldEnd()
5874 rajveer 13263 
    if self.onlyStore is not None:
13264 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13265 
      oprot.writeBool(self.onlyStore)
13266 
      oprot.writeFieldEnd()
1528 ankur.sing 13267 
    oprot.writeFieldStop()
13268 
    oprot.writeStructEnd()
13269 
 
3431 rajveer 13270 
  def validate(self):
13271 
    return
13272 
 
13273 
 
1528 ankur.sing 13274 
  def __repr__(self):
13275 
    L = ['%s=%r' % (key, value)
13276 
      for key, value in self.__dict__.iteritems()]
13277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13278 
 
13279 
  def __eq__(self, other):
13280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13281 
 
13282 
  def __ne__(self, other):
13283 
    return not (self == other)
13284 
 
3064 chandransh 13285 
class getValidOrders_result:
1528 ankur.sing 13286 
  """
13287 
  Attributes:
13288 
   - success
13289 
  """
13290 
 
13291 
  thrift_spec = (
3064 chandransh 13292 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13293 
  )
13294 
 
3064 chandransh 13295 
  def __init__(self, success=None,):
1528 ankur.sing 13296 
    self.success = success
13297 
 
13298 
  def read(self, iprot):
13299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13301 
      return
13302 
    iprot.readStructBegin()
13303 
    while True:
13304 
      (fname, ftype, fid) = iprot.readFieldBegin()
13305 
      if ftype == TType.STOP:
13306 
        break
13307 
      if fid == 0:
3064 chandransh 13308 
        if ftype == TType.LIST:
13309 
          self.success = []
6188 rajveer 13310 
          (_etype256, _size253) = iprot.readListBegin()
13311 
          for _i257 in xrange(_size253):
13312 
            _elem258 = Order()
13313 
            _elem258.read(iprot)
13314 
            self.success.append(_elem258)
3064 chandransh 13315 
          iprot.readListEnd()
1528 ankur.sing 13316 
        else:
13317 
          iprot.skip(ftype)
13318 
      else:
13319 
        iprot.skip(ftype)
13320 
      iprot.readFieldEnd()
13321 
    iprot.readStructEnd()
13322 
 
13323 
  def write(self, oprot):
13324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13326 
      return
3064 chandransh 13327 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13328 
    if self.success is not None:
3064 chandransh 13329 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13330 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13331 
      for iter259 in self.success:
13332 
        iter259.write(oprot)
3064 chandransh 13333 
      oprot.writeListEnd()
1528 ankur.sing 13334 
      oprot.writeFieldEnd()
13335 
    oprot.writeFieldStop()
13336 
    oprot.writeStructEnd()
13337 
 
3431 rajveer 13338 
  def validate(self):
13339 
    return
13340 
 
13341 
 
1528 ankur.sing 13342 
  def __repr__(self):
13343 
    L = ['%s=%r' % (key, value)
13344 
      for key, value in self.__dict__.iteritems()]
13345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13346 
 
13347 
  def __eq__(self, other):
13348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13349 
 
13350 
  def __ne__(self, other):
13351 
    return not (self == other)
13352 
 
1220 chandransh 13353 
class batchOrders_args:
13354 
  """
13355 
  Attributes:
13356 
   - warehouseId
13357 
  """
13358 
 
13359 
  thrift_spec = (
13360 
    None, # 0
13361 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13362 
  )
13363 
 
13364 
  def __init__(self, warehouseId=None,):
13365 
    self.warehouseId = warehouseId
13366 
 
13367 
  def read(self, iprot):
13368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13370 
      return
13371 
    iprot.readStructBegin()
13372 
    while True:
13373 
      (fname, ftype, fid) = iprot.readFieldBegin()
13374 
      if ftype == TType.STOP:
13375 
        break
13376 
      if fid == 1:
13377 
        if ftype == TType.I64:
13378 
          self.warehouseId = iprot.readI64();
13379 
        else:
13380 
          iprot.skip(ftype)
13381 
      else:
13382 
        iprot.skip(ftype)
13383 
      iprot.readFieldEnd()
13384 
    iprot.readStructEnd()
13385 
 
13386 
  def write(self, oprot):
13387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13389 
      return
13390 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13391 
    if self.warehouseId is not None:
1220 chandransh 13392 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13393 
      oprot.writeI64(self.warehouseId)
13394 
      oprot.writeFieldEnd()
13395 
    oprot.writeFieldStop()
13396 
    oprot.writeStructEnd()
13397 
 
3431 rajveer 13398 
  def validate(self):
13399 
    return
13400 
 
13401 
 
1220 chandransh 13402 
  def __repr__(self):
13403 
    L = ['%s=%r' % (key, value)
13404 
      for key, value in self.__dict__.iteritems()]
13405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13406 
 
13407 
  def __eq__(self, other):
13408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13409 
 
13410 
  def __ne__(self, other):
13411 
    return not (self == other)
13412 
 
13413 
class batchOrders_result:
13414 
  """
13415 
  Attributes:
13416 
   - success
13417 
   - ex
13418 
  """
13419 
 
13420 
  thrift_spec = (
13421 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13423 
  )
13424 
 
13425 
  def __init__(self, success=None, ex=None,):
13426 
    self.success = success
13427 
    self.ex = ex
13428 
 
13429 
  def read(self, iprot):
13430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13432 
      return
13433 
    iprot.readStructBegin()
13434 
    while True:
13435 
      (fname, ftype, fid) = iprot.readFieldBegin()
13436 
      if ftype == TType.STOP:
13437 
        break
13438 
      if fid == 0:
13439 
        if ftype == TType.LIST:
13440 
          self.success = []
6188 rajveer 13441 
          (_etype263, _size260) = iprot.readListBegin()
13442 
          for _i264 in xrange(_size260):
13443 
            _elem265 = Order()
13444 
            _elem265.read(iprot)
13445 
            self.success.append(_elem265)
1220 chandransh 13446 
          iprot.readListEnd()
13447 
        else:
13448 
          iprot.skip(ftype)
13449 
      elif fid == 1:
13450 
        if ftype == TType.STRUCT:
13451 
          self.ex = TransactionServiceException()
13452 
          self.ex.read(iprot)
13453 
        else:
13454 
          iprot.skip(ftype)
13455 
      else:
13456 
        iprot.skip(ftype)
13457 
      iprot.readFieldEnd()
13458 
    iprot.readStructEnd()
13459 
 
13460 
  def write(self, oprot):
13461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13463 
      return
13464 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13465 
    if self.success is not None:
1220 chandransh 13466 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13467 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13468 
      for iter266 in self.success:
13469 
        iter266.write(oprot)
1220 chandransh 13470 
      oprot.writeListEnd()
13471 
      oprot.writeFieldEnd()
3431 rajveer 13472 
    if self.ex is not None:
1220 chandransh 13473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13474 
      self.ex.write(oprot)
13475 
      oprot.writeFieldEnd()
13476 
    oprot.writeFieldStop()
13477 
    oprot.writeStructEnd()
13478 
 
3431 rajveer 13479 
  def validate(self):
13480 
    return
13481 
 
13482 
 
1220 chandransh 13483 
  def __repr__(self):
13484 
    L = ['%s=%r' % (key, value)
13485 
      for key, value in self.__dict__.iteritems()]
13486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13487 
 
13488 
  def __eq__(self, other):
13489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13490 
 
13491 
  def __ne__(self, other):
13492 
    return not (self == other)
13493 
 
1208 chandransh 13494 
class markOrderAsOutOfStock_args:
13495 
  """
13496 
  Attributes:
13497 
   - orderId
13498 
  """
13499 
 
13500 
  thrift_spec = (
13501 
    None, # 0
13502 
    (1, TType.I64, 'orderId', None, None, ), # 1
13503 
  )
13504 
 
13505 
  def __init__(self, orderId=None,):
13506 
    self.orderId = orderId
13507 
 
13508 
  def read(self, iprot):
13509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13511 
      return
13512 
    iprot.readStructBegin()
13513 
    while True:
13514 
      (fname, ftype, fid) = iprot.readFieldBegin()
13515 
      if ftype == TType.STOP:
13516 
        break
13517 
      if fid == 1:
13518 
        if ftype == TType.I64:
13519 
          self.orderId = iprot.readI64();
13520 
        else:
13521 
          iprot.skip(ftype)
13522 
      else:
13523 
        iprot.skip(ftype)
13524 
      iprot.readFieldEnd()
13525 
    iprot.readStructEnd()
13526 
 
13527 
  def write(self, oprot):
13528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13530 
      return
13531 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13532 
    if self.orderId is not None:
1208 chandransh 13533 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13534 
      oprot.writeI64(self.orderId)
13535 
      oprot.writeFieldEnd()
13536 
    oprot.writeFieldStop()
13537 
    oprot.writeStructEnd()
13538 
 
3431 rajveer 13539 
  def validate(self):
13540 
    return
13541 
 
13542 
 
1208 chandransh 13543 
  def __repr__(self):
13544 
    L = ['%s=%r' % (key, value)
13545 
      for key, value in self.__dict__.iteritems()]
13546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13547 
 
13548 
  def __eq__(self, other):
13549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13550 
 
13551 
  def __ne__(self, other):
13552 
    return not (self == other)
13553 
 
13554 
class markOrderAsOutOfStock_result:
13555 
  """
13556 
  Attributes:
13557 
   - success
13558 
   - ex
13559 
  """
13560 
 
13561 
  thrift_spec = (
13562 
    (0, TType.BOOL, 'success', None, None, ), # 0
13563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13564 
  )
13565 
 
13566 
  def __init__(self, success=None, ex=None,):
13567 
    self.success = success
13568 
    self.ex = ex
13569 
 
13570 
  def read(self, iprot):
13571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13573 
      return
13574 
    iprot.readStructBegin()
13575 
    while True:
13576 
      (fname, ftype, fid) = iprot.readFieldBegin()
13577 
      if ftype == TType.STOP:
13578 
        break
13579 
      if fid == 0:
13580 
        if ftype == TType.BOOL:
13581 
          self.success = iprot.readBool();
13582 
        else:
13583 
          iprot.skip(ftype)
13584 
      elif fid == 1:
13585 
        if ftype == TType.STRUCT:
13586 
          self.ex = TransactionServiceException()
13587 
          self.ex.read(iprot)
13588 
        else:
13589 
          iprot.skip(ftype)
13590 
      else:
13591 
        iprot.skip(ftype)
13592 
      iprot.readFieldEnd()
13593 
    iprot.readStructEnd()
13594 
 
13595 
  def write(self, oprot):
13596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13598 
      return
13599 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13600 
    if self.success is not None:
1208 chandransh 13601 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13602 
      oprot.writeBool(self.success)
13603 
      oprot.writeFieldEnd()
3431 rajveer 13604 
    if self.ex is not None:
1208 chandransh 13605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13606 
      self.ex.write(oprot)
13607 
      oprot.writeFieldEnd()
13608 
    oprot.writeFieldStop()
13609 
    oprot.writeStructEnd()
13610 
 
3431 rajveer 13611 
  def validate(self):
13612 
    return
13613 
 
13614 
 
1208 chandransh 13615 
  def __repr__(self):
13616 
    L = ['%s=%r' % (key, value)
13617 
      for key, value in self.__dict__.iteritems()]
13618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13619 
 
13620 
  def __eq__(self, other):
13621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13622 
 
13623 
  def __ne__(self, other):
13624 
    return not (self == other)
13625 
 
3064 chandransh 13626 
class verifyOrder_args:
759 chandransh 13627 
  """
13628 
  Attributes:
3064 chandransh 13629 
   - orderId
759 chandransh 13630 
  """
13631 
 
13632 
  thrift_spec = (
13633 
    None, # 0
3064 chandransh 13634 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13635 
  )
13636 
 
3064 chandransh 13637 
  def __init__(self, orderId=None,):
13638 
    self.orderId = orderId
759 chandransh 13639 
 
13640 
  def read(self, iprot):
13641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13643 
      return
13644 
    iprot.readStructBegin()
13645 
    while True:
13646 
      (fname, ftype, fid) = iprot.readFieldBegin()
13647 
      if ftype == TType.STOP:
13648 
        break
13649 
      if fid == 1:
13650 
        if ftype == TType.I64:
3064 chandransh 13651 
          self.orderId = iprot.readI64();
759 chandransh 13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      else:
13655 
        iprot.skip(ftype)
13656 
      iprot.readFieldEnd()
13657 
    iprot.readStructEnd()
13658 
 
13659 
  def write(self, oprot):
13660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13662 
      return
3064 chandransh 13663 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13664 
    if self.orderId is not None:
3064 chandransh 13665 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13666 
      oprot.writeI64(self.orderId)
759 chandransh 13667 
      oprot.writeFieldEnd()
13668 
    oprot.writeFieldStop()
13669 
    oprot.writeStructEnd()
13670 
 
3431 rajveer 13671 
  def validate(self):
13672 
    return
13673 
 
13674 
 
759 chandransh 13675 
  def __repr__(self):
13676 
    L = ['%s=%r' % (key, value)
13677 
      for key, value in self.__dict__.iteritems()]
13678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13679 
 
13680 
  def __eq__(self, other):
13681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13682 
 
13683 
  def __ne__(self, other):
13684 
    return not (self == other)
13685 
 
3064 chandransh 13686 
class verifyOrder_result:
759 chandransh 13687 
  """
13688 
  Attributes:
13689 
   - success
13690 
   - ex
13691 
  """
13692 
 
13693 
  thrift_spec = (
13694 
    (0, TType.BOOL, 'success', None, None, ), # 0
13695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13696 
  )
13697 
 
13698 
  def __init__(self, success=None, ex=None,):
13699 
    self.success = success
13700 
    self.ex = ex
13701 
 
13702 
  def read(self, iprot):
13703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13705 
      return
13706 
    iprot.readStructBegin()
13707 
    while True:
13708 
      (fname, ftype, fid) = iprot.readFieldBegin()
13709 
      if ftype == TType.STOP:
13710 
        break
13711 
      if fid == 0:
13712 
        if ftype == TType.BOOL:
13713 
          self.success = iprot.readBool();
13714 
        else:
13715 
          iprot.skip(ftype)
13716 
      elif fid == 1:
13717 
        if ftype == TType.STRUCT:
13718 
          self.ex = TransactionServiceException()
13719 
          self.ex.read(iprot)
13720 
        else:
13721 
          iprot.skip(ftype)
13722 
      else:
13723 
        iprot.skip(ftype)
13724 
      iprot.readFieldEnd()
13725 
    iprot.readStructEnd()
13726 
 
13727 
  def write(self, oprot):
13728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13730 
      return
3064 chandransh 13731 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13732 
    if self.success is not None:
759 chandransh 13733 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13734 
      oprot.writeBool(self.success)
13735 
      oprot.writeFieldEnd()
3431 rajveer 13736 
    if self.ex is not None:
759 chandransh 13737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13738 
      self.ex.write(oprot)
13739 
      oprot.writeFieldEnd()
13740 
    oprot.writeFieldStop()
13741 
    oprot.writeStructEnd()
13742 
 
3431 rajveer 13743 
  def validate(self):
13744 
    return
13745 
 
13746 
 
759 chandransh 13747 
  def __repr__(self):
13748 
    L = ['%s=%r' % (key, value)
13749 
      for key, value in self.__dict__.iteritems()]
13750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13751 
 
13752 
  def __eq__(self, other):
13753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13754 
 
13755 
  def __ne__(self, other):
13756 
    return not (self == other)
13757 
 
3064 chandransh 13758 
class acceptOrder_args:
1113 chandransh 13759 
  """
13760 
  Attributes:
3064 chandransh 13761 
   - orderId
1113 chandransh 13762 
  """
13763 
 
13764 
  thrift_spec = (
13765 
    None, # 0
3064 chandransh 13766 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13767 
  )
13768 
 
3064 chandransh 13769 
  def __init__(self, orderId=None,):
13770 
    self.orderId = orderId
1113 chandransh 13771 
 
13772 
  def read(self, iprot):
13773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13775 
      return
13776 
    iprot.readStructBegin()
13777 
    while True:
13778 
      (fname, ftype, fid) = iprot.readFieldBegin()
13779 
      if ftype == TType.STOP:
13780 
        break
13781 
      if fid == 1:
13782 
        if ftype == TType.I64:
3064 chandransh 13783 
          self.orderId = iprot.readI64();
1113 chandransh 13784 
        else:
13785 
          iprot.skip(ftype)
13786 
      else:
13787 
        iprot.skip(ftype)
13788 
      iprot.readFieldEnd()
13789 
    iprot.readStructEnd()
13790 
 
13791 
  def write(self, oprot):
13792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13794 
      return
3064 chandransh 13795 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13796 
    if self.orderId is not None:
3064 chandransh 13797 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13798 
      oprot.writeI64(self.orderId)
1113 chandransh 13799 
      oprot.writeFieldEnd()
13800 
    oprot.writeFieldStop()
13801 
    oprot.writeStructEnd()
13802 
 
3431 rajveer 13803 
  def validate(self):
13804 
    return
13805 
 
13806 
 
1113 chandransh 13807 
  def __repr__(self):
13808 
    L = ['%s=%r' % (key, value)
13809 
      for key, value in self.__dict__.iteritems()]
13810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13811 
 
13812 
  def __eq__(self, other):
13813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13814 
 
13815 
  def __ne__(self, other):
13816 
    return not (self == other)
13817 
 
3064 chandransh 13818 
class acceptOrder_result:
1113 chandransh 13819 
  """
13820 
  Attributes:
13821 
   - success
13822 
   - ex
13823 
  """
13824 
 
13825 
  thrift_spec = (
3064 chandransh 13826 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13828 
  )
13829 
 
13830 
  def __init__(self, success=None, ex=None,):
13831 
    self.success = success
13832 
    self.ex = ex
13833 
 
13834 
  def read(self, iprot):
13835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13837 
      return
13838 
    iprot.readStructBegin()
13839 
    while True:
13840 
      (fname, ftype, fid) = iprot.readFieldBegin()
13841 
      if ftype == TType.STOP:
13842 
        break
13843 
      if fid == 0:
3064 chandransh 13844 
        if ftype == TType.BOOL:
13845 
          self.success = iprot.readBool();
1113 chandransh 13846 
        else:
13847 
          iprot.skip(ftype)
13848 
      elif fid == 1:
13849 
        if ftype == TType.STRUCT:
13850 
          self.ex = TransactionServiceException()
13851 
          self.ex.read(iprot)
13852 
        else:
13853 
          iprot.skip(ftype)
13854 
      else:
13855 
        iprot.skip(ftype)
13856 
      iprot.readFieldEnd()
13857 
    iprot.readStructEnd()
13858 
 
13859 
  def write(self, oprot):
13860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13862 
      return
3064 chandransh 13863 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13864 
    if self.success is not None:
3064 chandransh 13865 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13866 
      oprot.writeBool(self.success)
1113 chandransh 13867 
      oprot.writeFieldEnd()
3431 rajveer 13868 
    if self.ex is not None:
1113 chandransh 13869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13870 
      self.ex.write(oprot)
13871 
      oprot.writeFieldEnd()
13872 
    oprot.writeFieldStop()
13873 
    oprot.writeStructEnd()
13874 
 
3431 rajveer 13875 
  def validate(self):
13876 
    return
13877 
 
13878 
 
1113 chandransh 13879 
  def __repr__(self):
13880 
    L = ['%s=%r' % (key, value)
13881 
      for key, value in self.__dict__.iteritems()]
13882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13883 
 
13884 
  def __eq__(self, other):
13885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13886 
 
13887 
  def __ne__(self, other):
13888 
    return not (self == other)
13889 
 
3064 chandransh 13890 
class addBillingDetails_args:
1135 chandransh 13891 
  """
13892 
  Attributes:
3064 chandransh 13893 
   - orderId
13894 
   - invoice_number
4658 mandeep.dh 13895 
   - serialNumber
4283 anupam.sin 13896 
   - itemNumber
3064 chandransh 13897 
   - billed_by
4264 rajveer 13898 
   - jacketNumber
4283 anupam.sin 13899 
   - billingType
5110 mandeep.dh 13900 
   - fulfilmentWarehouseId
4763 rajveer 13901 
   - authorize
1135 chandransh 13902 
  """
13903 
 
13904 
  thrift_spec = (
13905 
    None, # 0
3064 chandransh 13906 
    (1, TType.I64, 'orderId', None, None, ), # 1
13907 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13908 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13909 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13910 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13911 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13912 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13913 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13914 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13915 
  )
13916 
 
5110 mandeep.dh 13917 
  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 13918 
    self.orderId = orderId
13919 
    self.invoice_number = invoice_number
4658 mandeep.dh 13920 
    self.serialNumber = serialNumber
4283 anupam.sin 13921 
    self.itemNumber = itemNumber
3064 chandransh 13922 
    self.billed_by = billed_by
4264 rajveer 13923 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13924 
    self.billingType = billingType
5110 mandeep.dh 13925 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13926 
    self.authorize = authorize
1135 chandransh 13927 
 
13928 
  def read(self, iprot):
13929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13931 
      return
13932 
    iprot.readStructBegin()
13933 
    while True:
13934 
      (fname, ftype, fid) = iprot.readFieldBegin()
13935 
      if ftype == TType.STOP:
13936 
        break
13937 
      if fid == 1:
13938 
        if ftype == TType.I64:
3064 chandransh 13939 
          self.orderId = iprot.readI64();
1135 chandransh 13940 
        else:
13941 
          iprot.skip(ftype)
13942 
      elif fid == 2:
3064 chandransh 13943 
        if ftype == TType.STRING:
13944 
          self.invoice_number = iprot.readString();
1135 chandransh 13945 
        else:
13946 
          iprot.skip(ftype)
3064 chandransh 13947 
      elif fid == 3:
5411 rajveer 13948 
        if ftype == TType.LIST:
13949 
          self.serialNumber = []
6188 rajveer 13950 
          (_etype270, _size267) = iprot.readListBegin()
13951 
          for _i271 in xrange(_size267):
13952 
            _elem272 = iprot.readString();
13953 
            self.serialNumber.append(_elem272)
5411 rajveer 13954 
          iprot.readListEnd()
3064 chandransh 13955 
        else:
13956 
          iprot.skip(ftype)
13957 
      elif fid == 4:
5411 rajveer 13958 
        if ftype == TType.LIST:
13959 
          self.itemNumber = []
6188 rajveer 13960 
          (_etype276, _size273) = iprot.readListBegin()
13961 
          for _i277 in xrange(_size273):
13962 
            _elem278 = iprot.readString();
13963 
            self.itemNumber.append(_elem278)
5411 rajveer 13964 
          iprot.readListEnd()
3064 chandransh 13965 
        else:
13966 
          iprot.skip(ftype)
13967 
      elif fid == 5:
13968 
        if ftype == TType.STRING:
4283 anupam.sin 13969 
          self.billed_by = iprot.readString();
3064 chandransh 13970 
        else:
13971 
          iprot.skip(ftype)
13972 
      elif fid == 6:
13973 
        if ftype == TType.I64:
4283 anupam.sin 13974 
          self.jacketNumber = iprot.readI64();
13975 
        else:
13976 
          iprot.skip(ftype)
13977 
      elif fid == 7:
13978 
        if ftype == TType.I64:
3064 chandransh 13979 
          self.billingType = iprot.readI64();
13980 
        else:
13981 
          iprot.skip(ftype)
4283 anupam.sin 13982 
      elif fid == 8:
13983 
        if ftype == TType.I64:
5110 mandeep.dh 13984 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13985 
        else:
13986 
          iprot.skip(ftype)
4763 rajveer 13987 
      elif fid == 9:
13988 
        if ftype == TType.BOOL:
13989 
          self.authorize = iprot.readBool();
13990 
        else:
13991 
          iprot.skip(ftype)
1246 chandransh 13992 
      else:
13993 
        iprot.skip(ftype)
13994 
      iprot.readFieldEnd()
13995 
    iprot.readStructEnd()
13996 
 
13997 
  def write(self, oprot):
13998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14000 
      return
4283 anupam.sin 14001 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14002 
    if self.orderId is not None:
3064 chandransh 14003 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14004 
      oprot.writeI64(self.orderId)
1246 chandransh 14005 
      oprot.writeFieldEnd()
4283 anupam.sin 14006 
    if self.invoice_number is not None:
14007 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14008 
      oprot.writeString(self.invoice_number)
1246 chandransh 14009 
      oprot.writeFieldEnd()
4658 mandeep.dh 14010 
    if self.serialNumber is not None:
5411 rajveer 14011 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14012 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14013 
      for iter279 in self.serialNumber:
14014 
        oprot.writeString(iter279)
5411 rajveer 14015 
      oprot.writeListEnd()
3064 chandransh 14016 
      oprot.writeFieldEnd()
3431 rajveer 14017 
    if self.itemNumber is not None:
5411 rajveer 14018 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14019 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14020 
      for iter280 in self.itemNumber:
14021 
        oprot.writeString(iter280)
5411 rajveer 14022 
      oprot.writeListEnd()
3064 chandransh 14023 
      oprot.writeFieldEnd()
4283 anupam.sin 14024 
    if self.billed_by is not None:
14025 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14026 
      oprot.writeString(self.billed_by)
3064 chandransh 14027 
      oprot.writeFieldEnd()
4283 anupam.sin 14028 
    if self.jacketNumber is not None:
14029 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14030 
      oprot.writeI64(self.jacketNumber)
14031 
      oprot.writeFieldEnd()
3431 rajveer 14032 
    if self.billingType is not None:
4283 anupam.sin 14033 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14034 
      oprot.writeI64(self.billingType)
14035 
      oprot.writeFieldEnd()
5110 mandeep.dh 14036 
    if self.fulfilmentWarehouseId is not None:
14037 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14038 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14039 
      oprot.writeFieldEnd()
4763 rajveer 14040 
    if self.authorize is not None:
14041 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14042 
      oprot.writeBool(self.authorize)
14043 
      oprot.writeFieldEnd()
1246 chandransh 14044 
    oprot.writeFieldStop()
14045 
    oprot.writeStructEnd()
14046 
 
3431 rajveer 14047 
  def validate(self):
14048 
    return
14049 
 
14050 
 
1246 chandransh 14051 
  def __repr__(self):
14052 
    L = ['%s=%r' % (key, value)
14053 
      for key, value in self.__dict__.iteritems()]
14054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14055 
 
14056 
  def __eq__(self, other):
14057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14058 
 
14059 
  def __ne__(self, other):
14060 
    return not (self == other)
14061 
 
4283 anupam.sin 14062 
class addBillingDetails_result:
1246 chandransh 14063 
  """
14064 
  Attributes:
3064 chandransh 14065 
   - success
1246 chandransh 14066 
   - ex
14067 
  """
14068 
 
14069 
  thrift_spec = (
3064 chandransh 14070 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14072 
  )
14073 
 
3064 chandransh 14074 
  def __init__(self, success=None, ex=None,):
14075 
    self.success = success
1246 chandransh 14076 
    self.ex = ex
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
3064 chandransh 14087 
      if fid == 0:
14088 
        if ftype == TType.BOOL:
14089 
          self.success = iprot.readBool();
14090 
        else:
14091 
          iprot.skip(ftype)
14092 
      elif fid == 1:
1246 chandransh 14093 
        if ftype == TType.STRUCT:
14094 
          self.ex = TransactionServiceException()
14095 
          self.ex.read(iprot)
14096 
        else:
14097 
          iprot.skip(ftype)
14098 
      else:
14099 
        iprot.skip(ftype)
14100 
      iprot.readFieldEnd()
14101 
    iprot.readStructEnd()
14102 
 
14103 
  def write(self, oprot):
14104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14106 
      return
4283 anupam.sin 14107 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14108 
    if self.success is not None:
3064 chandransh 14109 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14110 
      oprot.writeBool(self.success)
14111 
      oprot.writeFieldEnd()
3431 rajveer 14112 
    if self.ex is not None:
1246 chandransh 14113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14114 
      self.ex.write(oprot)
14115 
      oprot.writeFieldEnd()
14116 
    oprot.writeFieldStop()
14117 
    oprot.writeStructEnd()
14118 
 
3431 rajveer 14119 
  def validate(self):
14120 
    return
14121 
 
14122 
 
1246 chandransh 14123 
  def __repr__(self):
14124 
    L = ['%s=%r' % (key, value)
14125 
      for key, value in self.__dict__.iteritems()]
14126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14127 
 
14128 
  def __eq__(self, other):
14129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14130 
 
14131 
  def __ne__(self, other):
14132 
    return not (self == other)
14133 
 
4579 rajveer 14134 
class addInvoiceNumber_args:
14135 
  """
14136 
  Attributes:
14137 
   - orderId
14138 
   - invoiceNumber
4763 rajveer 14139 
   - color
6756 amar.kumar 14140 
   - serialNumber
14141 
   - itemNumber
4579 rajveer 14142 
  """
14143 
 
14144 
  thrift_spec = (
14145 
    None, # 0
14146 
    (1, TType.I64, 'orderId', None, None, ), # 1
14147 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14148 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14149 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14150 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14151 
  )
14152 
 
6756 amar.kumar 14153 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14154 
    self.orderId = orderId
14155 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14156 
    self.color = color
6756 amar.kumar 14157 
    self.serialNumber = serialNumber
14158 
    self.itemNumber = itemNumber
4579 rajveer 14159 
 
14160 
  def read(self, iprot):
14161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14163 
      return
14164 
    iprot.readStructBegin()
14165 
    while True:
14166 
      (fname, ftype, fid) = iprot.readFieldBegin()
14167 
      if ftype == TType.STOP:
14168 
        break
14169 
      if fid == 1:
14170 
        if ftype == TType.I64:
14171 
          self.orderId = iprot.readI64();
14172 
        else:
14173 
          iprot.skip(ftype)
14174 
      elif fid == 2:
14175 
        if ftype == TType.STRING:
14176 
          self.invoiceNumber = iprot.readString();
14177 
        else:
14178 
          iprot.skip(ftype)
4763 rajveer 14179 
      elif fid == 3:
14180 
        if ftype == TType.STRING:
14181 
          self.color = iprot.readString();
14182 
        else:
14183 
          iprot.skip(ftype)
6756 amar.kumar 14184 
      elif fid == 4:
14185 
        if ftype == TType.STRING:
14186 
          self.serialNumber = iprot.readString();
14187 
        else:
14188 
          iprot.skip(ftype)
14189 
      elif fid == 5:
14190 
        if ftype == TType.STRING:
14191 
          self.itemNumber = iprot.readString();
14192 
        else:
14193 
          iprot.skip(ftype)
4579 rajveer 14194 
      else:
14195 
        iprot.skip(ftype)
14196 
      iprot.readFieldEnd()
14197 
    iprot.readStructEnd()
14198 
 
14199 
  def write(self, oprot):
14200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14202 
      return
14203 
    oprot.writeStructBegin('addInvoiceNumber_args')
14204 
    if self.orderId is not None:
14205 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14206 
      oprot.writeI64(self.orderId)
14207 
      oprot.writeFieldEnd()
14208 
    if self.invoiceNumber is not None:
14209 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14210 
      oprot.writeString(self.invoiceNumber)
14211 
      oprot.writeFieldEnd()
4763 rajveer 14212 
    if self.color is not None:
14213 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14214 
      oprot.writeString(self.color)
14215 
      oprot.writeFieldEnd()
6756 amar.kumar 14216 
    if self.serialNumber is not None:
14217 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14218 
      oprot.writeString(self.serialNumber)
14219 
      oprot.writeFieldEnd()
14220 
    if self.itemNumber is not None:
14221 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14222 
      oprot.writeString(self.itemNumber)
14223 
      oprot.writeFieldEnd()
4579 rajveer 14224 
    oprot.writeFieldStop()
14225 
    oprot.writeStructEnd()
14226 
 
14227 
  def validate(self):
14228 
    return
14229 
 
14230 
 
14231 
  def __repr__(self):
14232 
    L = ['%s=%r' % (key, value)
14233 
      for key, value in self.__dict__.iteritems()]
14234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14235 
 
14236 
  def __eq__(self, other):
14237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14238 
 
14239 
  def __ne__(self, other):
14240 
    return not (self == other)
14241 
 
14242 
class addInvoiceNumber_result:
14243 
  """
14244 
  Attributes:
14245 
   - ex
14246 
  """
14247 
 
14248 
  thrift_spec = (
14249 
    None, # 0
14250 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14251 
  )
14252 
 
14253 
  def __init__(self, ex=None,):
14254 
    self.ex = ex
14255 
 
14256 
  def read(self, iprot):
14257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14259 
      return
14260 
    iprot.readStructBegin()
14261 
    while True:
14262 
      (fname, ftype, fid) = iprot.readFieldBegin()
14263 
      if ftype == TType.STOP:
14264 
        break
14265 
      if fid == 1:
14266 
        if ftype == TType.STRUCT:
14267 
          self.ex = TransactionServiceException()
14268 
          self.ex.read(iprot)
14269 
        else:
14270 
          iprot.skip(ftype)
14271 
      else:
14272 
        iprot.skip(ftype)
14273 
      iprot.readFieldEnd()
14274 
    iprot.readStructEnd()
14275 
 
14276 
  def write(self, oprot):
14277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14279 
      return
14280 
    oprot.writeStructBegin('addInvoiceNumber_result')
14281 
    if self.ex is not None:
14282 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14283 
      self.ex.write(oprot)
14284 
      oprot.writeFieldEnd()
14285 
    oprot.writeFieldStop()
14286 
    oprot.writeStructEnd()
14287 
 
14288 
  def validate(self):
14289 
    return
14290 
 
14291 
 
14292 
  def __repr__(self):
14293 
    L = ['%s=%r' % (key, value)
14294 
      for key, value in self.__dict__.iteritems()]
14295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14296 
 
14297 
  def __eq__(self, other):
14298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14299 
 
14300 
  def __ne__(self, other):
14301 
    return not (self == other)
14302 
 
4910 phani.kuma 14303 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14304 
  """
14305 
  Attributes:
3064 chandransh 14306 
   - warehouseId
1408 ankur.sing 14307 
   - providerId
3064 chandransh 14308 
   - cod
4910 phani.kuma 14309 
   - orderIds
1408 ankur.sing 14310 
  """
14311 
 
14312 
  thrift_spec = (
14313 
    None, # 0
3064 chandransh 14314 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14315 
    (2, TType.I64, 'providerId', None, None, ), # 2
14316 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14317 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14318 
  )
14319 
 
4910 phani.kuma 14320 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14321 
    self.warehouseId = warehouseId
1408 ankur.sing 14322 
    self.providerId = providerId
3064 chandransh 14323 
    self.cod = cod
4910 phani.kuma 14324 
    self.orderIds = orderIds
1408 ankur.sing 14325 
 
14326 
  def read(self, iprot):
14327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14329 
      return
14330 
    iprot.readStructBegin()
14331 
    while True:
14332 
      (fname, ftype, fid) = iprot.readFieldBegin()
14333 
      if ftype == TType.STOP:
14334 
        break
14335 
      if fid == 1:
14336 
        if ftype == TType.I64:
3064 chandransh 14337 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14338 
        else:
14339 
          iprot.skip(ftype)
14340 
      elif fid == 2:
14341 
        if ftype == TType.I64:
3064 chandransh 14342 
          self.providerId = iprot.readI64();
1408 ankur.sing 14343 
        else:
14344 
          iprot.skip(ftype)
3064 chandransh 14345 
      elif fid == 3:
14346 
        if ftype == TType.BOOL:
14347 
          self.cod = iprot.readBool();
14348 
        else:
14349 
          iprot.skip(ftype)
4910 phani.kuma 14350 
      elif fid == 4:
14351 
        if ftype == TType.LIST:
14352 
          self.orderIds = []
6188 rajveer 14353 
          (_etype284, _size281) = iprot.readListBegin()
14354 
          for _i285 in xrange(_size281):
14355 
            _elem286 = iprot.readI64();
14356 
            self.orderIds.append(_elem286)
4910 phani.kuma 14357 
          iprot.readListEnd()
14358 
        else:
14359 
          iprot.skip(ftype)
1408 ankur.sing 14360 
      else:
14361 
        iprot.skip(ftype)
14362 
      iprot.readFieldEnd()
14363 
    iprot.readStructEnd()
14364 
 
14365 
  def write(self, oprot):
14366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14368 
      return
4910 phani.kuma 14369 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14370 
    if self.warehouseId is not None:
3064 chandransh 14371 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14372 
      oprot.writeI64(self.warehouseId)
14373 
      oprot.writeFieldEnd()
3431 rajveer 14374 
    if self.providerId is not None:
3064 chandransh 14375 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14376 
      oprot.writeI64(self.providerId)
14377 
      oprot.writeFieldEnd()
3431 rajveer 14378 
    if self.cod is not None:
3064 chandransh 14379 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14380 
      oprot.writeBool(self.cod)
1408 ankur.sing 14381 
      oprot.writeFieldEnd()
4910 phani.kuma 14382 
    if self.orderIds is not None:
14383 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14384 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14385 
      for iter287 in self.orderIds:
14386 
        oprot.writeI64(iter287)
4910 phani.kuma 14387 
      oprot.writeListEnd()
14388 
      oprot.writeFieldEnd()
1408 ankur.sing 14389 
    oprot.writeFieldStop()
14390 
    oprot.writeStructEnd()
14391 
 
3431 rajveer 14392 
  def validate(self):
14393 
    return
14394 
 
14395 
 
1408 ankur.sing 14396 
  def __repr__(self):
14397 
    L = ['%s=%r' % (key, value)
14398 
      for key, value in self.__dict__.iteritems()]
14399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14400 
 
14401 
  def __eq__(self, other):
14402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14403 
 
14404 
  def __ne__(self, other):
14405 
    return not (self == other)
14406 
 
4910 phani.kuma 14407 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14408 
  """
14409 
  Attributes:
14410 
   - success
3064 chandransh 14411 
   - ex
1408 ankur.sing 14412 
  """
14413 
 
14414 
  thrift_spec = (
3064 chandransh 14415 
    (0, TType.BOOL, 'success', None, None, ), # 0
14416 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14417 
  )
14418 
 
3064 chandransh 14419 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14420 
    self.success = success
3064 chandransh 14421 
    self.ex = ex
1408 ankur.sing 14422 
 
14423 
  def read(self, iprot):
14424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14426 
      return
14427 
    iprot.readStructBegin()
14428 
    while True:
14429 
      (fname, ftype, fid) = iprot.readFieldBegin()
14430 
      if ftype == TType.STOP:
14431 
        break
14432 
      if fid == 0:
3064 chandransh 14433 
        if ftype == TType.BOOL:
14434 
          self.success = iprot.readBool();
1408 ankur.sing 14435 
        else:
14436 
          iprot.skip(ftype)
3064 chandransh 14437 
      elif fid == 1:
14438 
        if ftype == TType.STRUCT:
14439 
          self.ex = TransactionServiceException()
14440 
          self.ex.read(iprot)
14441 
        else:
14442 
          iprot.skip(ftype)
1408 ankur.sing 14443 
      else:
14444 
        iprot.skip(ftype)
14445 
      iprot.readFieldEnd()
14446 
    iprot.readStructEnd()
14447 
 
14448 
  def write(self, oprot):
14449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14451 
      return
4910 phani.kuma 14452 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14453 
    if self.success is not None:
3064 chandransh 14454 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14455 
      oprot.writeBool(self.success)
1408 ankur.sing 14456 
      oprot.writeFieldEnd()
3431 rajveer 14457 
    if self.ex is not None:
3064 chandransh 14458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14459 
      self.ex.write(oprot)
14460 
      oprot.writeFieldEnd()
1408 ankur.sing 14461 
    oprot.writeFieldStop()
14462 
    oprot.writeStructEnd()
14463 
 
3431 rajveer 14464 
  def validate(self):
14465 
    return
14466 
 
14467 
 
1408 ankur.sing 14468 
  def __repr__(self):
14469 
    L = ['%s=%r' % (key, value)
14470 
      for key, value in self.__dict__.iteritems()]
14471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14472 
 
14473 
  def __eq__(self, other):
14474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14475 
 
14476 
  def __ne__(self, other):
14477 
    return not (self == other)
14478 
 
5676 rajveer 14479 
class markOrdersAsReturnedFromStore_args:
14480 
  """
14481 
  Attributes:
14482 
   - providerId
14483 
   - orderIds
5713 rajveer 14484 
   - awbs
5676 rajveer 14485 
  """
14486 
 
14487 
  thrift_spec = (
14488 
    None, # 0
14489 
    (1, TType.I64, 'providerId', None, None, ), # 1
14490 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14491 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14492 
  )
14493 
 
5713 rajveer 14494 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14495 
    self.providerId = providerId
14496 
    self.orderIds = orderIds
5713 rajveer 14497 
    self.awbs = awbs
5676 rajveer 14498 
 
14499 
  def read(self, iprot):
14500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14502 
      return
14503 
    iprot.readStructBegin()
14504 
    while True:
14505 
      (fname, ftype, fid) = iprot.readFieldBegin()
14506 
      if ftype == TType.STOP:
14507 
        break
14508 
      if fid == 1:
14509 
        if ftype == TType.I64:
14510 
          self.providerId = iprot.readI64();
14511 
        else:
14512 
          iprot.skip(ftype)
14513 
      elif fid == 2:
14514 
        if ftype == TType.LIST:
14515 
          self.orderIds = []
6188 rajveer 14516 
          (_etype291, _size288) = iprot.readListBegin()
14517 
          for _i292 in xrange(_size288):
14518 
            _elem293 = iprot.readI64();
14519 
            self.orderIds.append(_elem293)
5676 rajveer 14520 
          iprot.readListEnd()
14521 
        else:
14522 
          iprot.skip(ftype)
5713 rajveer 14523 
      elif fid == 3:
14524 
        if ftype == TType.LIST:
14525 
          self.awbs = []
6188 rajveer 14526 
          (_etype297, _size294) = iprot.readListBegin()
14527 
          for _i298 in xrange(_size294):
14528 
            _elem299 = iprot.readString();
14529 
            self.awbs.append(_elem299)
5713 rajveer 14530 
          iprot.readListEnd()
14531 
        else:
14532 
          iprot.skip(ftype)
5676 rajveer 14533 
      else:
14534 
        iprot.skip(ftype)
14535 
      iprot.readFieldEnd()
14536 
    iprot.readStructEnd()
14537 
 
14538 
  def write(self, oprot):
14539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14541 
      return
14542 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14543 
    if self.providerId is not None:
14544 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14545 
      oprot.writeI64(self.providerId)
14546 
      oprot.writeFieldEnd()
14547 
    if self.orderIds is not None:
14548 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14549 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14550 
      for iter300 in self.orderIds:
14551 
        oprot.writeI64(iter300)
5676 rajveer 14552 
      oprot.writeListEnd()
14553 
      oprot.writeFieldEnd()
5713 rajveer 14554 
    if self.awbs is not None:
14555 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14556 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14557 
      for iter301 in self.awbs:
14558 
        oprot.writeString(iter301)
5713 rajveer 14559 
      oprot.writeListEnd()
14560 
      oprot.writeFieldEnd()
5676 rajveer 14561 
    oprot.writeFieldStop()
14562 
    oprot.writeStructEnd()
14563 
 
14564 
  def validate(self):
14565 
    return
14566 
 
14567 
 
14568 
  def __repr__(self):
14569 
    L = ['%s=%r' % (key, value)
14570 
      for key, value in self.__dict__.iteritems()]
14571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14572 
 
14573 
  def __eq__(self, other):
14574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14575 
 
14576 
  def __ne__(self, other):
14577 
    return not (self == other)
14578 
 
14579 
class markOrdersAsReturnedFromStore_result:
14580 
  """
14581 
  Attributes:
14582 
   - success
14583 
   - ex
14584 
  """
14585 
 
14586 
  thrift_spec = (
14587 
    (0, TType.BOOL, 'success', None, None, ), # 0
14588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14589 
  )
14590 
 
14591 
  def __init__(self, success=None, ex=None,):
14592 
    self.success = success
14593 
    self.ex = ex
14594 
 
14595 
  def read(self, iprot):
14596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14598 
      return
14599 
    iprot.readStructBegin()
14600 
    while True:
14601 
      (fname, ftype, fid) = iprot.readFieldBegin()
14602 
      if ftype == TType.STOP:
14603 
        break
14604 
      if fid == 0:
14605 
        if ftype == TType.BOOL:
14606 
          self.success = iprot.readBool();
14607 
        else:
14608 
          iprot.skip(ftype)
14609 
      elif fid == 1:
14610 
        if ftype == TType.STRUCT:
14611 
          self.ex = TransactionServiceException()
14612 
          self.ex.read(iprot)
14613 
        else:
14614 
          iprot.skip(ftype)
14615 
      else:
14616 
        iprot.skip(ftype)
14617 
      iprot.readFieldEnd()
14618 
    iprot.readStructEnd()
14619 
 
14620 
  def write(self, oprot):
14621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14623 
      return
14624 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14625 
    if self.success is not None:
14626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14627 
      oprot.writeBool(self.success)
14628 
      oprot.writeFieldEnd()
14629 
    if self.ex is not None:
14630 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14631 
      self.ex.write(oprot)
14632 
      oprot.writeFieldEnd()
14633 
    oprot.writeFieldStop()
14634 
    oprot.writeStructEnd()
14635 
 
14636 
  def validate(self):
14637 
    return
14638 
 
14639 
 
14640 
  def __repr__(self):
14641 
    L = ['%s=%r' % (key, value)
14642 
      for key, value in self.__dict__.iteritems()]
14643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14644 
 
14645 
  def __eq__(self, other):
14646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14647 
 
14648 
  def __ne__(self, other):
14649 
    return not (self == other)
14650 
 
4910 phani.kuma 14651 
class markOrdersAsPickedUp_args:
4410 rajveer 14652 
  """
14653 
  Attributes:
14654 
   - providerId
4910 phani.kuma 14655 
   - pickupDetails
4410 rajveer 14656 
  """
14657 
 
14658 
  thrift_spec = (
14659 
    None, # 0
4910 phani.kuma 14660 
    (1, TType.I64, 'providerId', None, None, ), # 1
14661 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14662 
  )
14663 
 
4910 phani.kuma 14664 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14665 
    self.providerId = providerId
4910 phani.kuma 14666 
    self.pickupDetails = pickupDetails
4410 rajveer 14667 
 
14668 
  def read(self, iprot):
14669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14671 
      return
14672 
    iprot.readStructBegin()
14673 
    while True:
14674 
      (fname, ftype, fid) = iprot.readFieldBegin()
14675 
      if ftype == TType.STOP:
14676 
        break
14677 
      if fid == 1:
14678 
        if ftype == TType.I64:
4910 phani.kuma 14679 
          self.providerId = iprot.readI64();
4410 rajveer 14680 
        else:
14681 
          iprot.skip(ftype)
14682 
      elif fid == 2:
4910 phani.kuma 14683 
        if ftype == TType.MAP:
14684 
          self.pickupDetails = {}
6188 rajveer 14685 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14686 
          for _i306 in xrange(_size302):
14687 
            _key307 = iprot.readString();
14688 
            _val308 = iprot.readString();
14689 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14690 
          iprot.readMapEnd()
4410 rajveer 14691 
        else:
14692 
          iprot.skip(ftype)
14693 
      else:
14694 
        iprot.skip(ftype)
14695 
      iprot.readFieldEnd()
14696 
    iprot.readStructEnd()
14697 
 
14698 
  def write(self, oprot):
14699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14701 
      return
4910 phani.kuma 14702 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14703 
    if self.providerId is not None:
4910 phani.kuma 14704 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14705 
      oprot.writeI64(self.providerId)
14706 
      oprot.writeFieldEnd()
4910 phani.kuma 14707 
    if self.pickupDetails is not None:
14708 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14709 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14710 
      for kiter309,viter310 in self.pickupDetails.items():
14711 
        oprot.writeString(kiter309)
14712 
        oprot.writeString(viter310)
4910 phani.kuma 14713 
      oprot.writeMapEnd()
4410 rajveer 14714 
      oprot.writeFieldEnd()
14715 
    oprot.writeFieldStop()
14716 
    oprot.writeStructEnd()
14717 
 
14718 
  def validate(self):
14719 
    return
14720 
 
14721 
 
14722 
  def __repr__(self):
14723 
    L = ['%s=%r' % (key, value)
14724 
      for key, value in self.__dict__.iteritems()]
14725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14726 
 
14727 
  def __eq__(self, other):
14728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14729 
 
14730 
  def __ne__(self, other):
14731 
    return not (self == other)
14732 
 
4910 phani.kuma 14733 
class markOrdersAsPickedUp_result:
4410 rajveer 14734 
  """
14735 
  Attributes:
14736 
   - ex
14737 
  """
14738 
 
14739 
  thrift_spec = (
4910 phani.kuma 14740 
    None, # 0
4410 rajveer 14741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14742 
  )
14743 
 
4910 phani.kuma 14744 
  def __init__(self, ex=None,):
4410 rajveer 14745 
    self.ex = ex
14746 
 
14747 
  def read(self, iprot):
14748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14750 
      return
14751 
    iprot.readStructBegin()
14752 
    while True:
14753 
      (fname, ftype, fid) = iprot.readFieldBegin()
14754 
      if ftype == TType.STOP:
14755 
        break
4910 phani.kuma 14756 
      if fid == 1:
4410 rajveer 14757 
        if ftype == TType.STRUCT:
14758 
          self.ex = TransactionServiceException()
14759 
          self.ex.read(iprot)
14760 
        else:
14761 
          iprot.skip(ftype)
14762 
      else:
14763 
        iprot.skip(ftype)
14764 
      iprot.readFieldEnd()
14765 
    iprot.readStructEnd()
14766 
 
14767 
  def write(self, oprot):
14768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14770 
      return
4910 phani.kuma 14771 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14772 
    if self.ex is not None:
14773 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14774 
      self.ex.write(oprot)
14775 
      oprot.writeFieldEnd()
14776 
    oprot.writeFieldStop()
14777 
    oprot.writeStructEnd()
14778 
 
14779 
  def validate(self):
14780 
    return
14781 
 
14782 
 
14783 
  def __repr__(self):
14784 
    L = ['%s=%r' % (key, value)
14785 
      for key, value in self.__dict__.iteritems()]
14786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14787 
 
14788 
  def __eq__(self, other):
14789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14790 
 
14791 
  def __ne__(self, other):
14792 
    return not (self == other)
14793 
 
4910 phani.kuma 14794 
class getOrdersNotPickedUp_args:
304 ashish 14795 
  """
14796 
  Attributes:
3064 chandransh 14797 
   - providerId
304 ashish 14798 
  """
94 ashish 14799 
 
304 ashish 14800 
  thrift_spec = (
14801 
    None, # 0
3064 chandransh 14802 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14803 
  )
14804 
 
4910 phani.kuma 14805 
  def __init__(self, providerId=None,):
3064 chandransh 14806 
    self.providerId = providerId
304 ashish 14807 
 
14808 
  def read(self, iprot):
14809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14811 
      return
14812 
    iprot.readStructBegin()
14813 
    while True:
14814 
      (fname, ftype, fid) = iprot.readFieldBegin()
14815 
      if ftype == TType.STOP:
14816 
        break
14817 
      if fid == 1:
14818 
        if ftype == TType.I64:
3064 chandransh 14819 
          self.providerId = iprot.readI64();
304 ashish 14820 
        else:
14821 
          iprot.skip(ftype)
14822 
      else:
14823 
        iprot.skip(ftype)
14824 
      iprot.readFieldEnd()
14825 
    iprot.readStructEnd()
14826 
 
14827 
  def write(self, oprot):
14828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14830 
      return
4910 phani.kuma 14831 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14832 
    if self.providerId is not None:
3064 chandransh 14833 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14834 
      oprot.writeI64(self.providerId)
304 ashish 14835 
      oprot.writeFieldEnd()
14836 
    oprot.writeFieldStop()
14837 
    oprot.writeStructEnd()
14838 
 
3431 rajveer 14839 
  def validate(self):
14840 
    return
14841 
 
14842 
 
304 ashish 14843 
  def __repr__(self):
14844 
    L = ['%s=%r' % (key, value)
14845 
      for key, value in self.__dict__.iteritems()]
14846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14847 
 
14848 
  def __eq__(self, other):
14849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14850 
 
14851 
  def __ne__(self, other):
14852 
    return not (self == other)
14853 
 
4910 phani.kuma 14854 
class getOrdersNotPickedUp_result:
304 ashish 14855 
  """
14856 
  Attributes:
14857 
   - success
14858 
  """
14859 
 
14860 
  thrift_spec = (
3064 chandransh 14861 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14862 
  )
14863 
 
4910 phani.kuma 14864 
  def __init__(self, success=None,):
304 ashish 14865 
    self.success = success
14866 
 
14867 
  def read(self, iprot):
14868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14870 
      return
14871 
    iprot.readStructBegin()
14872 
    while True:
14873 
      (fname, ftype, fid) = iprot.readFieldBegin()
14874 
      if ftype == TType.STOP:
14875 
        break
14876 
      if fid == 0:
14877 
        if ftype == TType.LIST:
14878 
          self.success = []
6188 rajveer 14879 
          (_etype314, _size311) = iprot.readListBegin()
14880 
          for _i315 in xrange(_size311):
14881 
            _elem316 = Order()
14882 
            _elem316.read(iprot)
14883 
            self.success.append(_elem316)
304 ashish 14884 
          iprot.readListEnd()
14885 
        else:
14886 
          iprot.skip(ftype)
14887 
      else:
14888 
        iprot.skip(ftype)
14889 
      iprot.readFieldEnd()
14890 
    iprot.readStructEnd()
14891 
 
14892 
  def write(self, oprot):
14893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14895 
      return
4910 phani.kuma 14896 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14897 
    if self.success is not None:
304 ashish 14898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14900 
      for iter317 in self.success:
14901 
        iter317.write(oprot)
304 ashish 14902 
      oprot.writeListEnd()
14903 
      oprot.writeFieldEnd()
14904 
    oprot.writeFieldStop()
14905 
    oprot.writeStructEnd()
14906 
 
3431 rajveer 14907 
  def validate(self):
14908 
    return
14909 
 
14910 
 
304 ashish 14911 
  def __repr__(self):
14912 
    L = ['%s=%r' % (key, value)
14913 
      for key, value in self.__dict__.iteritems()]
14914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14915 
 
14916 
  def __eq__(self, other):
14917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14918 
 
14919 
  def __ne__(self, other):
14920 
    return not (self == other)
14921 
 
3064 chandransh 14922 
class markOrdersAsDelivered_args:
304 ashish 14923 
  """
14924 
  Attributes:
3064 chandransh 14925 
   - providerId
14926 
   - deliveredOrders
304 ashish 14927 
  """
14928 
 
14929 
  thrift_spec = (
14930 
    None, # 0
3064 chandransh 14931 
    (1, TType.I64, 'providerId', None, None, ), # 1
14932 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14933 
  )
14934 
 
3064 chandransh 14935 
  def __init__(self, providerId=None, deliveredOrders=None,):
14936 
    self.providerId = providerId
14937 
    self.deliveredOrders = deliveredOrders
304 ashish 14938 
 
14939 
  def read(self, iprot):
14940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14942 
      return
14943 
    iprot.readStructBegin()
14944 
    while True:
14945 
      (fname, ftype, fid) = iprot.readFieldBegin()
14946 
      if ftype == TType.STOP:
14947 
        break
14948 
      if fid == 1:
14949 
        if ftype == TType.I64:
3064 chandransh 14950 
          self.providerId = iprot.readI64();
304 ashish 14951 
        else:
14952 
          iprot.skip(ftype)
14953 
      elif fid == 2:
3064 chandransh 14954 
        if ftype == TType.MAP:
14955 
          self.deliveredOrders = {}
6188 rajveer 14956 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14957 
          for _i322 in xrange(_size318):
14958 
            _key323 = iprot.readString();
14959 
            _val324 = iprot.readString();
14960 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14961 
          iprot.readMapEnd()
304 ashish 14962 
        else:
14963 
          iprot.skip(ftype)
14964 
      else:
14965 
        iprot.skip(ftype)
14966 
      iprot.readFieldEnd()
14967 
    iprot.readStructEnd()
14968 
 
14969 
  def write(self, oprot):
14970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14972 
      return
3064 chandransh 14973 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14974 
    if self.providerId is not None:
3064 chandransh 14975 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14976 
      oprot.writeI64(self.providerId)
304 ashish 14977 
      oprot.writeFieldEnd()
3431 rajveer 14978 
    if self.deliveredOrders is not None:
3064 chandransh 14979 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14980 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14981 
      for kiter325,viter326 in self.deliveredOrders.items():
14982 
        oprot.writeString(kiter325)
14983 
        oprot.writeString(viter326)
3064 chandransh 14984 
      oprot.writeMapEnd()
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 
 
3064 chandransh 15004 
class markOrdersAsDelivered_result:
15005 
  """
15006 
  Attributes:
15007 
   - ex
15008 
  """
304 ashish 15009 
 
15010 
  thrift_spec = (
3064 chandransh 15011 
    None, # 0
15012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15013 
  )
15014 
 
3064 chandransh 15015 
  def __init__(self, ex=None,):
15016 
    self.ex = ex
304 ashish 15017 
 
1596 ankur.sing 15018 
  def read(self, iprot):
15019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15021 
      return
15022 
    iprot.readStructBegin()
15023 
    while True:
15024 
      (fname, ftype, fid) = iprot.readFieldBegin()
15025 
      if ftype == TType.STOP:
15026 
        break
3064 chandransh 15027 
      if fid == 1:
15028 
        if ftype == TType.STRUCT:
15029 
          self.ex = TransactionServiceException()
15030 
          self.ex.read(iprot)
15031 
        else:
15032 
          iprot.skip(ftype)
1596 ankur.sing 15033 
      else:
15034 
        iprot.skip(ftype)
15035 
      iprot.readFieldEnd()
15036 
    iprot.readStructEnd()
15037 
 
15038 
  def write(self, oprot):
15039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15041 
      return
3064 chandransh 15042 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15043 
    if self.ex is not None:
3064 chandransh 15044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15045 
      self.ex.write(oprot)
15046 
      oprot.writeFieldEnd()
1596 ankur.sing 15047 
    oprot.writeFieldStop()
15048 
    oprot.writeStructEnd()
15049 
 
3431 rajveer 15050 
  def validate(self):
15051 
    return
15052 
 
15053 
 
1596 ankur.sing 15054 
  def __repr__(self):
15055 
    L = ['%s=%r' % (key, value)
15056 
      for key, value in self.__dict__.iteritems()]
15057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15058 
 
15059 
  def __eq__(self, other):
15060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15061 
 
15062 
  def __ne__(self, other):
15063 
    return not (self == other)
15064 
 
4910 phani.kuma 15065 
class markAsRTOrders_args:
1596 ankur.sing 15066 
  """
15067 
  Attributes:
3064 chandransh 15068 
   - providerId
15069 
   - returnedOrders
1596 ankur.sing 15070 
  """
15071 
 
15072 
  thrift_spec = (
3064 chandransh 15073 
    None, # 0
15074 
    (1, TType.I64, 'providerId', None, None, ), # 1
15075 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15076 
  )
15077 
 
3064 chandransh 15078 
  def __init__(self, providerId=None, returnedOrders=None,):
15079 
    self.providerId = providerId
15080 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15081 
 
15082 
  def read(self, iprot):
15083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15085 
      return
15086 
    iprot.readStructBegin()
15087 
    while True:
15088 
      (fname, ftype, fid) = iprot.readFieldBegin()
15089 
      if ftype == TType.STOP:
15090 
        break
3064 chandransh 15091 
      if fid == 1:
1596 ankur.sing 15092 
        if ftype == TType.I64:
3064 chandransh 15093 
          self.providerId = iprot.readI64();
1596 ankur.sing 15094 
        else:
15095 
          iprot.skip(ftype)
3064 chandransh 15096 
      elif fid == 2:
15097 
        if ftype == TType.MAP:
15098 
          self.returnedOrders = {}
6188 rajveer 15099 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15100 
          for _i331 in xrange(_size327):
15101 
            _key332 = iprot.readString();
15102 
            _val333 = iprot.readString();
15103 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15104 
          iprot.readMapEnd()
15105 
        else:
15106 
          iprot.skip(ftype)
1596 ankur.sing 15107 
      else:
15108 
        iprot.skip(ftype)
15109 
      iprot.readFieldEnd()
15110 
    iprot.readStructEnd()
15111 
 
15112 
  def write(self, oprot):
15113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15115 
      return
4910 phani.kuma 15116 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15117 
    if self.providerId is not None:
3064 chandransh 15118 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15119 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15120 
      oprot.writeFieldEnd()
3431 rajveer 15121 
    if self.returnedOrders is not None:
3064 chandransh 15122 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15123 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15124 
      for kiter334,viter335 in self.returnedOrders.items():
15125 
        oprot.writeString(kiter334)
15126 
        oprot.writeString(viter335)
3064 chandransh 15127 
      oprot.writeMapEnd()
15128 
      oprot.writeFieldEnd()
1596 ankur.sing 15129 
    oprot.writeFieldStop()
15130 
    oprot.writeStructEnd()
15131 
 
3431 rajveer 15132 
  def validate(self):
15133 
    return
15134 
 
15135 
 
1596 ankur.sing 15136 
  def __repr__(self):
15137 
    L = ['%s=%r' % (key, value)
15138 
      for key, value in self.__dict__.iteritems()]
15139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15140 
 
15141 
  def __eq__(self, other):
15142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15143 
 
15144 
  def __ne__(self, other):
15145 
    return not (self == other)
15146 
 
4910 phani.kuma 15147 
class markAsRTOrders_result:
3064 chandransh 15148 
  """
15149 
  Attributes:
15150 
   - ex
15151 
  """
1596 ankur.sing 15152 
 
1627 ankur.sing 15153 
  thrift_spec = (
3064 chandransh 15154 
    None, # 0
15155 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15156 
  )
15157 
 
3064 chandransh 15158 
  def __init__(self, ex=None,):
15159 
    self.ex = ex
15160 
 
1627 ankur.sing 15161 
  def read(self, iprot):
15162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15164 
      return
15165 
    iprot.readStructBegin()
15166 
    while True:
15167 
      (fname, ftype, fid) = iprot.readFieldBegin()
15168 
      if ftype == TType.STOP:
15169 
        break
3064 chandransh 15170 
      if fid == 1:
15171 
        if ftype == TType.STRUCT:
15172 
          self.ex = TransactionServiceException()
15173 
          self.ex.read(iprot)
15174 
        else:
15175 
          iprot.skip(ftype)
1627 ankur.sing 15176 
      else:
15177 
        iprot.skip(ftype)
15178 
      iprot.readFieldEnd()
15179 
    iprot.readStructEnd()
15180 
 
15181 
  def write(self, oprot):
15182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15184 
      return
4910 phani.kuma 15185 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15186 
    if self.ex is not None:
3064 chandransh 15187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15188 
      self.ex.write(oprot)
15189 
      oprot.writeFieldEnd()
1627 ankur.sing 15190 
    oprot.writeFieldStop()
15191 
    oprot.writeStructEnd()
15192 
 
3431 rajveer 15193 
  def validate(self):
15194 
    return
15195 
 
15196 
 
1627 ankur.sing 15197 
  def __repr__(self):
15198 
    L = ['%s=%r' % (key, value)
15199 
      for key, value in self.__dict__.iteritems()]
15200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15201 
 
15202 
  def __eq__(self, other):
15203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15204 
 
15205 
  def __ne__(self, other):
15206 
    return not (self == other)
15207 
 
4910 phani.kuma 15208 
class getRTOrders_args:
15209 
  """
15210 
  Attributes:
15211 
   - providerId
15212 
  """
15213 
 
15214 
  thrift_spec = (
15215 
    None, # 0
15216 
    (1, TType.I64, 'providerId', None, None, ), # 1
15217 
  )
15218 
 
15219 
  def __init__(self, providerId=None,):
15220 
    self.providerId = providerId
15221 
 
15222 
  def read(self, iprot):
15223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15225 
      return
15226 
    iprot.readStructBegin()
15227 
    while True:
15228 
      (fname, ftype, fid) = iprot.readFieldBegin()
15229 
      if ftype == TType.STOP:
15230 
        break
15231 
      if fid == 1:
15232 
        if ftype == TType.I64:
15233 
          self.providerId = iprot.readI64();
15234 
        else:
15235 
          iprot.skip(ftype)
15236 
      else:
15237 
        iprot.skip(ftype)
15238 
      iprot.readFieldEnd()
15239 
    iprot.readStructEnd()
15240 
 
15241 
  def write(self, oprot):
15242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15244 
      return
15245 
    oprot.writeStructBegin('getRTOrders_args')
15246 
    if self.providerId is not None:
15247 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15248 
      oprot.writeI64(self.providerId)
15249 
      oprot.writeFieldEnd()
15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
15268 
class getRTOrders_result:
15269 
  """
15270 
  Attributes:
15271 
   - success
15272 
  """
15273 
 
15274 
  thrift_spec = (
15275 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15276 
  )
15277 
 
15278 
  def __init__(self, success=None,):
15279 
    self.success = success
15280 
 
15281 
  def read(self, iprot):
15282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15284 
      return
15285 
    iprot.readStructBegin()
15286 
    while True:
15287 
      (fname, ftype, fid) = iprot.readFieldBegin()
15288 
      if ftype == TType.STOP:
15289 
        break
15290 
      if fid == 0:
15291 
        if ftype == TType.LIST:
15292 
          self.success = []
6188 rajveer 15293 
          (_etype339, _size336) = iprot.readListBegin()
15294 
          for _i340 in xrange(_size336):
15295 
            _elem341 = Order()
15296 
            _elem341.read(iprot)
15297 
            self.success.append(_elem341)
4910 phani.kuma 15298 
          iprot.readListEnd()
15299 
        else:
15300 
          iprot.skip(ftype)
15301 
      else:
15302 
        iprot.skip(ftype)
15303 
      iprot.readFieldEnd()
15304 
    iprot.readStructEnd()
15305 
 
15306 
  def write(self, oprot):
15307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15309 
      return
15310 
    oprot.writeStructBegin('getRTOrders_result')
15311 
    if self.success is not None:
15312 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15313 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15314 
      for iter342 in self.success:
15315 
        iter342.write(oprot)
4910 phani.kuma 15316 
      oprot.writeListEnd()
15317 
      oprot.writeFieldEnd()
15318 
    oprot.writeFieldStop()
15319 
    oprot.writeStructEnd()
15320 
 
15321 
  def validate(self):
15322 
    return
15323 
 
15324 
 
15325 
  def __repr__(self):
15326 
    L = ['%s=%r' % (key, value)
15327 
      for key, value in self.__dict__.iteritems()]
15328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15329 
 
15330 
  def __eq__(self, other):
15331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15332 
 
15333 
  def __ne__(self, other):
15334 
    return not (self == other)
15335 
 
3064 chandransh 15336 
class updateNonDeliveryReason_args:
1627 ankur.sing 15337 
  """
15338 
  Attributes:
3064 chandransh 15339 
   - providerId
15340 
   - undeliveredOrders
1627 ankur.sing 15341 
  """
15342 
 
15343 
  thrift_spec = (
3064 chandransh 15344 
    None, # 0
15345 
    (1, TType.I64, 'providerId', None, None, ), # 1
15346 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15347 
  )
15348 
 
3064 chandransh 15349 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15350 
    self.providerId = providerId
15351 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15352 
 
15353 
  def read(self, iprot):
15354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15356 
      return
15357 
    iprot.readStructBegin()
15358 
    while True:
15359 
      (fname, ftype, fid) = iprot.readFieldBegin()
15360 
      if ftype == TType.STOP:
15361 
        break
3064 chandransh 15362 
      if fid == 1:
1627 ankur.sing 15363 
        if ftype == TType.I64:
3064 chandransh 15364 
          self.providerId = iprot.readI64();
1627 ankur.sing 15365 
        else:
15366 
          iprot.skip(ftype)
3064 chandransh 15367 
      elif fid == 2:
15368 
        if ftype == TType.MAP:
15369 
          self.undeliveredOrders = {}
6188 rajveer 15370 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15371 
          for _i347 in xrange(_size343):
15372 
            _key348 = iprot.readString();
15373 
            _val349 = iprot.readString();
15374 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15375 
          iprot.readMapEnd()
15376 
        else:
15377 
          iprot.skip(ftype)
1627 ankur.sing 15378 
      else:
15379 
        iprot.skip(ftype)
15380 
      iprot.readFieldEnd()
15381 
    iprot.readStructEnd()
15382 
 
15383 
  def write(self, oprot):
15384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15386 
      return
3064 chandransh 15387 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15388 
    if self.providerId is not None:
3064 chandransh 15389 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15390 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15391 
      oprot.writeFieldEnd()
3431 rajveer 15392 
    if self.undeliveredOrders is not None:
3064 chandransh 15393 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15394 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15395 
      for kiter350,viter351 in self.undeliveredOrders.items():
15396 
        oprot.writeString(kiter350)
15397 
        oprot.writeString(viter351)
3064 chandransh 15398 
      oprot.writeMapEnd()
15399 
      oprot.writeFieldEnd()
1627 ankur.sing 15400 
    oprot.writeFieldStop()
15401 
    oprot.writeStructEnd()
15402 
 
3431 rajveer 15403 
  def validate(self):
15404 
    return
15405 
 
15406 
 
1627 ankur.sing 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 
 
3064 chandransh 15418 
class updateNonDeliveryReason_result:
1627 ankur.sing 15419 
  """
15420 
  Attributes:
3064 chandransh 15421 
   - ex
1627 ankur.sing 15422 
  """
15423 
 
15424 
  thrift_spec = (
4910 phani.kuma 15425 
    None, # 0
3064 chandransh 15426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15427 
  )
15428 
 
4910 phani.kuma 15429 
  def __init__(self, ex=None,):
3064 chandransh 15430 
    self.ex = ex
1627 ankur.sing 15431 
 
15432 
  def read(self, iprot):
15433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15435 
      return
15436 
    iprot.readStructBegin()
15437 
    while True:
15438 
      (fname, ftype, fid) = iprot.readFieldBegin()
15439 
      if ftype == TType.STOP:
15440 
        break
4910 phani.kuma 15441 
      if fid == 1:
15442 
        if ftype == TType.STRUCT:
15443 
          self.ex = TransactionServiceException()
15444 
          self.ex.read(iprot)
15445 
        else:
15446 
          iprot.skip(ftype)
15447 
      else:
15448 
        iprot.skip(ftype)
15449 
      iprot.readFieldEnd()
15450 
    iprot.readStructEnd()
15451 
 
15452 
  def write(self, oprot):
15453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15455 
      return
15456 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15457 
    if self.ex is not None:
15458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15459 
      self.ex.write(oprot)
15460 
      oprot.writeFieldEnd()
15461 
    oprot.writeFieldStop()
15462 
    oprot.writeStructEnd()
15463 
 
15464 
  def validate(self):
15465 
    return
15466 
 
15467 
 
15468 
  def __repr__(self):
15469 
    L = ['%s=%r' % (key, value)
15470 
      for key, value in self.__dict__.iteritems()]
15471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15472 
 
15473 
  def __eq__(self, other):
15474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15475 
 
15476 
  def __ne__(self, other):
15477 
    return not (self == other)
15478 
 
15479 
class getNonDeliveredOrdersbyCourier_args:
15480 
  """
15481 
  Attributes:
15482 
   - providerId
15483 
  """
15484 
 
15485 
  thrift_spec = (
15486 
    None, # 0
15487 
    (1, TType.I64, 'providerId', None, None, ), # 1
15488 
  )
15489 
 
15490 
  def __init__(self, providerId=None,):
15491 
    self.providerId = providerId
15492 
 
15493 
  def read(self, iprot):
15494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15496 
      return
15497 
    iprot.readStructBegin()
15498 
    while True:
15499 
      (fname, ftype, fid) = iprot.readFieldBegin()
15500 
      if ftype == TType.STOP:
15501 
        break
15502 
      if fid == 1:
15503 
        if ftype == TType.I64:
15504 
          self.providerId = iprot.readI64();
15505 
        else:
15506 
          iprot.skip(ftype)
15507 
      else:
15508 
        iprot.skip(ftype)
15509 
      iprot.readFieldEnd()
15510 
    iprot.readStructEnd()
15511 
 
15512 
  def write(self, oprot):
15513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15515 
      return
15516 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15517 
    if self.providerId is not None:
15518 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15519 
      oprot.writeI64(self.providerId)
15520 
      oprot.writeFieldEnd()
15521 
    oprot.writeFieldStop()
15522 
    oprot.writeStructEnd()
15523 
 
15524 
  def validate(self):
15525 
    return
15526 
 
15527 
 
15528 
  def __repr__(self):
15529 
    L = ['%s=%r' % (key, value)
15530 
      for key, value in self.__dict__.iteritems()]
15531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15532 
 
15533 
  def __eq__(self, other):
15534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15535 
 
15536 
  def __ne__(self, other):
15537 
    return not (self == other)
15538 
 
15539 
class getNonDeliveredOrdersbyCourier_result:
15540 
  """
15541 
  Attributes:
15542 
   - success
15543 
  """
15544 
 
15545 
  thrift_spec = (
15546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15547 
  )
15548 
 
15549 
  def __init__(self, success=None,):
15550 
    self.success = success
15551 
 
15552 
  def read(self, iprot):
15553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15555 
      return
15556 
    iprot.readStructBegin()
15557 
    while True:
15558 
      (fname, ftype, fid) = iprot.readFieldBegin()
15559 
      if ftype == TType.STOP:
15560 
        break
4581 phani.kuma 15561 
      if fid == 0:
15562 
        if ftype == TType.LIST:
15563 
          self.success = []
6188 rajveer 15564 
          (_etype355, _size352) = iprot.readListBegin()
15565 
          for _i356 in xrange(_size352):
15566 
            _elem357 = Order()
15567 
            _elem357.read(iprot)
15568 
            self.success.append(_elem357)
4581 phani.kuma 15569 
          iprot.readListEnd()
15570 
        else:
15571 
          iprot.skip(ftype)
4910 phani.kuma 15572 
      else:
15573 
        iprot.skip(ftype)
15574 
      iprot.readFieldEnd()
15575 
    iprot.readStructEnd()
15576 
 
15577 
  def write(self, oprot):
15578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15580 
      return
15581 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15582 
    if self.success is not None:
15583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15585 
      for iter358 in self.success:
15586 
        iter358.write(oprot)
4910 phani.kuma 15587 
      oprot.writeListEnd()
15588 
      oprot.writeFieldEnd()
15589 
    oprot.writeFieldStop()
15590 
    oprot.writeStructEnd()
15591 
 
15592 
  def validate(self):
15593 
    return
15594 
 
15595 
 
15596 
  def __repr__(self):
15597 
    L = ['%s=%r' % (key, value)
15598 
      for key, value in self.__dict__.iteritems()]
15599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15600 
 
15601 
  def __eq__(self, other):
15602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15603 
 
15604 
  def __ne__(self, other):
15605 
    return not (self == other)
15606 
 
15607 
class markOrdersAsLocalConnected_args:
15608 
  """
15609 
  Attributes:
15610 
   - providerId
15611 
   - local_connected_orders
15612 
  """
15613 
 
15614 
  thrift_spec = (
15615 
    None, # 0
15616 
    (1, TType.I64, 'providerId', None, None, ), # 1
15617 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15618 
  )
15619 
 
15620 
  def __init__(self, providerId=None, local_connected_orders=None,):
15621 
    self.providerId = providerId
15622 
    self.local_connected_orders = local_connected_orders
15623 
 
15624 
  def read(self, iprot):
15625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15627 
      return
15628 
    iprot.readStructBegin()
15629 
    while True:
15630 
      (fname, ftype, fid) = iprot.readFieldBegin()
15631 
      if ftype == TType.STOP:
15632 
        break
15633 
      if fid == 1:
15634 
        if ftype == TType.I64:
15635 
          self.providerId = iprot.readI64();
15636 
        else:
15637 
          iprot.skip(ftype)
15638 
      elif fid == 2:
15639 
        if ftype == TType.MAP:
15640 
          self.local_connected_orders = {}
6188 rajveer 15641 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15642 
          for _i363 in xrange(_size359):
15643 
            _key364 = iprot.readString();
15644 
            _val365 = iprot.readString();
15645 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15646 
          iprot.readMapEnd()
15647 
        else:
15648 
          iprot.skip(ftype)
15649 
      else:
15650 
        iprot.skip(ftype)
15651 
      iprot.readFieldEnd()
15652 
    iprot.readStructEnd()
15653 
 
15654 
  def write(self, oprot):
15655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15657 
      return
15658 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15659 
    if self.providerId is not None:
15660 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15661 
      oprot.writeI64(self.providerId)
15662 
      oprot.writeFieldEnd()
15663 
    if self.local_connected_orders is not None:
15664 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15665 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15666 
      for kiter366,viter367 in self.local_connected_orders.items():
15667 
        oprot.writeString(kiter366)
15668 
        oprot.writeString(viter367)
4910 phani.kuma 15669 
      oprot.writeMapEnd()
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 markOrdersAsLocalConnected_result:
15690 
  """
15691 
  Attributes:
15692 
   - ex
15693 
  """
15694 
 
15695 
  thrift_spec = (
15696 
    None, # 0
15697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15698 
  )
15699 
 
15700 
  def __init__(self, ex=None,):
15701 
    self.ex = ex
15702 
 
15703 
  def read(self, iprot):
15704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15706 
      return
15707 
    iprot.readStructBegin()
15708 
    while True:
15709 
      (fname, ftype, fid) = iprot.readFieldBegin()
15710 
      if ftype == TType.STOP:
15711 
        break
15712 
      if fid == 1:
3064 chandransh 15713 
        if ftype == TType.STRUCT:
15714 
          self.ex = TransactionServiceException()
15715 
          self.ex.read(iprot)
1627 ankur.sing 15716 
        else:
15717 
          iprot.skip(ftype)
15718 
      else:
15719 
        iprot.skip(ftype)
15720 
      iprot.readFieldEnd()
15721 
    iprot.readStructEnd()
15722 
 
15723 
  def write(self, oprot):
15724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15726 
      return
4910 phani.kuma 15727 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15728 
    if self.ex is not None:
15729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15730 
      self.ex.write(oprot)
15731 
      oprot.writeFieldEnd()
15732 
    oprot.writeFieldStop()
15733 
    oprot.writeStructEnd()
15734 
 
15735 
  def validate(self):
15736 
    return
15737 
 
15738 
 
15739 
  def __repr__(self):
15740 
    L = ['%s=%r' % (key, value)
15741 
      for key, value in self.__dict__.iteritems()]
15742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15743 
 
15744 
  def __eq__(self, other):
15745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15746 
 
15747 
  def __ne__(self, other):
15748 
    return not (self == other)
15749 
 
15750 
class getOrdersNotLocalConnected_args:
15751 
  """
15752 
  Attributes:
15753 
   - providerId
15754 
  """
15755 
 
15756 
  thrift_spec = (
15757 
    None, # 0
15758 
    (1, TType.I64, 'providerId', None, None, ), # 1
15759 
  )
15760 
 
15761 
  def __init__(self, providerId=None,):
15762 
    self.providerId = providerId
15763 
 
15764 
  def read(self, iprot):
15765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15767 
      return
15768 
    iprot.readStructBegin()
15769 
    while True:
15770 
      (fname, ftype, fid) = iprot.readFieldBegin()
15771 
      if ftype == TType.STOP:
15772 
        break
15773 
      if fid == 1:
15774 
        if ftype == TType.I64:
15775 
          self.providerId = iprot.readI64();
15776 
        else:
15777 
          iprot.skip(ftype)
15778 
      else:
15779 
        iprot.skip(ftype)
15780 
      iprot.readFieldEnd()
15781 
    iprot.readStructEnd()
15782 
 
15783 
  def write(self, oprot):
15784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15786 
      return
15787 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15788 
    if self.providerId is not None:
15789 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15790 
      oprot.writeI64(self.providerId)
15791 
      oprot.writeFieldEnd()
15792 
    oprot.writeFieldStop()
15793 
    oprot.writeStructEnd()
15794 
 
15795 
  def validate(self):
15796 
    return
15797 
 
15798 
 
15799 
  def __repr__(self):
15800 
    L = ['%s=%r' % (key, value)
15801 
      for key, value in self.__dict__.iteritems()]
15802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15803 
 
15804 
  def __eq__(self, other):
15805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15806 
 
15807 
  def __ne__(self, other):
15808 
    return not (self == other)
15809 
 
15810 
class getOrdersNotLocalConnected_result:
15811 
  """
15812 
  Attributes:
15813 
   - success
15814 
  """
15815 
 
15816 
  thrift_spec = (
15817 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15818 
  )
15819 
 
15820 
  def __init__(self, success=None,):
15821 
    self.success = success
15822 
 
15823 
  def read(self, iprot):
15824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15826 
      return
15827 
    iprot.readStructBegin()
15828 
    while True:
15829 
      (fname, ftype, fid) = iprot.readFieldBegin()
15830 
      if ftype == TType.STOP:
15831 
        break
15832 
      if fid == 0:
15833 
        if ftype == TType.LIST:
15834 
          self.success = []
6188 rajveer 15835 
          (_etype371, _size368) = iprot.readListBegin()
15836 
          for _i372 in xrange(_size368):
15837 
            _elem373 = Order()
15838 
            _elem373.read(iprot)
15839 
            self.success.append(_elem373)
4910 phani.kuma 15840 
          iprot.readListEnd()
15841 
        else:
15842 
          iprot.skip(ftype)
15843 
      else:
15844 
        iprot.skip(ftype)
15845 
      iprot.readFieldEnd()
15846 
    iprot.readStructEnd()
15847 
 
15848 
  def write(self, oprot):
15849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15851 
      return
15852 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15853 
    if self.success is not None:
15854 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15855 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15856 
      for iter374 in self.success:
15857 
        iter374.write(oprot)
4581 phani.kuma 15858 
      oprot.writeListEnd()
15859 
      oprot.writeFieldEnd()
4910 phani.kuma 15860 
    oprot.writeFieldStop()
15861 
    oprot.writeStructEnd()
15862 
 
15863 
  def validate(self):
15864 
    return
15865 
 
15866 
 
15867 
  def __repr__(self):
15868 
    L = ['%s=%r' % (key, value)
15869 
      for key, value in self.__dict__.iteritems()]
15870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15871 
 
15872 
  def __eq__(self, other):
15873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15874 
 
15875 
  def __ne__(self, other):
15876 
    return not (self == other)
15877 
 
15878 
class markOrdersAsDestinationCityReached_args:
15879 
  """
15880 
  Attributes:
15881 
   - providerId
15882 
   - destination_city_reached_orders
15883 
  """
15884 
 
15885 
  thrift_spec = (
15886 
    None, # 0
15887 
    (1, TType.I64, 'providerId', None, None, ), # 1
15888 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15889 
  )
15890 
 
15891 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15892 
    self.providerId = providerId
15893 
    self.destination_city_reached_orders = destination_city_reached_orders
15894 
 
15895 
  def read(self, iprot):
15896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15898 
      return
15899 
    iprot.readStructBegin()
15900 
    while True:
15901 
      (fname, ftype, fid) = iprot.readFieldBegin()
15902 
      if ftype == TType.STOP:
15903 
        break
15904 
      if fid == 1:
15905 
        if ftype == TType.I64:
15906 
          self.providerId = iprot.readI64();
15907 
        else:
15908 
          iprot.skip(ftype)
15909 
      elif fid == 2:
15910 
        if ftype == TType.MAP:
15911 
          self.destination_city_reached_orders = {}
6188 rajveer 15912 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15913 
          for _i379 in xrange(_size375):
15914 
            _key380 = iprot.readString();
15915 
            _val381 = iprot.readString();
15916 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15917 
          iprot.readMapEnd()
15918 
        else:
15919 
          iprot.skip(ftype)
15920 
      else:
15921 
        iprot.skip(ftype)
15922 
      iprot.readFieldEnd()
15923 
    iprot.readStructEnd()
15924 
 
15925 
  def write(self, oprot):
15926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15928 
      return
15929 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15930 
    if self.providerId is not None:
15931 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15932 
      oprot.writeI64(self.providerId)
15933 
      oprot.writeFieldEnd()
15934 
    if self.destination_city_reached_orders is not None:
15935 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15936 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15937 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15938 
        oprot.writeString(kiter382)
15939 
        oprot.writeString(viter383)
4910 phani.kuma 15940 
      oprot.writeMapEnd()
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 markOrdersAsDestinationCityReached_result:
15961 
  """
15962 
  Attributes:
15963 
   - ex
15964 
  """
15965 
 
15966 
  thrift_spec = (
15967 
    None, # 0
15968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15969 
  )
15970 
 
15971 
  def __init__(self, ex=None,):
15972 
    self.ex = ex
15973 
 
15974 
  def read(self, iprot):
15975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15977 
      return
15978 
    iprot.readStructBegin()
15979 
    while True:
15980 
      (fname, ftype, fid) = iprot.readFieldBegin()
15981 
      if ftype == TType.STOP:
15982 
        break
15983 
      if fid == 1:
15984 
        if ftype == TType.STRUCT:
15985 
          self.ex = TransactionServiceException()
15986 
          self.ex.read(iprot)
15987 
        else:
15988 
          iprot.skip(ftype)
15989 
      else:
15990 
        iprot.skip(ftype)
15991 
      iprot.readFieldEnd()
15992 
    iprot.readStructEnd()
15993 
 
15994 
  def write(self, oprot):
15995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15997 
      return
15998 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15999 
    if self.ex is not None:
3064 chandransh 16000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16001 
      self.ex.write(oprot)
1627 ankur.sing 16002 
      oprot.writeFieldEnd()
16003 
    oprot.writeFieldStop()
16004 
    oprot.writeStructEnd()
16005 
 
3431 rajveer 16006 
  def validate(self):
16007 
    return
16008 
 
16009 
 
1627 ankur.sing 16010 
  def __repr__(self):
16011 
    L = ['%s=%r' % (key, value)
16012 
      for key, value in self.__dict__.iteritems()]
16013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16014 
 
16015 
  def __eq__(self, other):
16016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16017 
 
16018 
  def __ne__(self, other):
16019 
    return not (self == other)
16020 
 
4910 phani.kuma 16021 
class markOrdersAsFirstDeliveryAttempted_args:
16022 
  """
16023 
  Attributes:
16024 
   - providerId
16025 
   - first_atdl_orders
16026 
  """
16027 
 
16028 
  thrift_spec = (
16029 
    None, # 0
16030 
    (1, TType.I64, 'providerId', None, None, ), # 1
16031 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16032 
  )
16033 
 
16034 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16035 
    self.providerId = providerId
16036 
    self.first_atdl_orders = first_atdl_orders
16037 
 
16038 
  def read(self, iprot):
16039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16041 
      return
16042 
    iprot.readStructBegin()
16043 
    while True:
16044 
      (fname, ftype, fid) = iprot.readFieldBegin()
16045 
      if ftype == TType.STOP:
16046 
        break
16047 
      if fid == 1:
16048 
        if ftype == TType.I64:
16049 
          self.providerId = iprot.readI64();
16050 
        else:
16051 
          iprot.skip(ftype)
16052 
      elif fid == 2:
16053 
        if ftype == TType.MAP:
16054 
          self.first_atdl_orders = {}
6188 rajveer 16055 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16056 
          for _i388 in xrange(_size384):
16057 
            _key389 = iprot.readString();
16058 
            _val390 = iprot.readString();
16059 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16060 
          iprot.readMapEnd()
16061 
        else:
16062 
          iprot.skip(ftype)
16063 
      else:
16064 
        iprot.skip(ftype)
16065 
      iprot.readFieldEnd()
16066 
    iprot.readStructEnd()
16067 
 
16068 
  def write(self, oprot):
16069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16071 
      return
16072 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16073 
    if self.providerId is not None:
16074 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16075 
      oprot.writeI64(self.providerId)
16076 
      oprot.writeFieldEnd()
16077 
    if self.first_atdl_orders is not None:
16078 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16079 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16080 
      for kiter391,viter392 in self.first_atdl_orders.items():
16081 
        oprot.writeString(kiter391)
16082 
        oprot.writeString(viter392)
4910 phani.kuma 16083 
      oprot.writeMapEnd()
16084 
      oprot.writeFieldEnd()
16085 
    oprot.writeFieldStop()
16086 
    oprot.writeStructEnd()
16087 
 
16088 
  def validate(self):
16089 
    return
16090 
 
16091 
 
16092 
  def __repr__(self):
16093 
    L = ['%s=%r' % (key, value)
16094 
      for key, value in self.__dict__.iteritems()]
16095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16096 
 
16097 
  def __eq__(self, other):
16098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16099 
 
16100 
  def __ne__(self, other):
16101 
    return not (self == other)
16102 
 
16103 
class markOrdersAsFirstDeliveryAttempted_result:
16104 
  """
16105 
  Attributes:
16106 
   - ex
16107 
  """
16108 
 
16109 
  thrift_spec = (
16110 
    None, # 0
16111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16112 
  )
16113 
 
16114 
  def __init__(self, ex=None,):
16115 
    self.ex = ex
16116 
 
16117 
  def read(self, iprot):
16118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16120 
      return
16121 
    iprot.readStructBegin()
16122 
    while True:
16123 
      (fname, ftype, fid) = iprot.readFieldBegin()
16124 
      if ftype == TType.STOP:
16125 
        break
16126 
      if fid == 1:
16127 
        if ftype == TType.STRUCT:
16128 
          self.ex = TransactionServiceException()
16129 
          self.ex.read(iprot)
16130 
        else:
16131 
          iprot.skip(ftype)
16132 
      else:
16133 
        iprot.skip(ftype)
16134 
      iprot.readFieldEnd()
16135 
    iprot.readStructEnd()
16136 
 
16137 
  def write(self, oprot):
16138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16140 
      return
16141 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16142 
    if self.ex is not None:
16143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16144 
      self.ex.write(oprot)
16145 
      oprot.writeFieldEnd()
16146 
    oprot.writeFieldStop()
16147 
    oprot.writeStructEnd()
16148 
 
16149 
  def validate(self):
16150 
    return
16151 
 
16152 
 
16153 
  def __repr__(self):
16154 
    L = ['%s=%r' % (key, value)
16155 
      for key, value in self.__dict__.iteritems()]
16156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16157 
 
16158 
  def __eq__(self, other):
16159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16160 
 
16161 
  def __ne__(self, other):
16162 
    return not (self == other)
16163 
 
3064 chandransh 16164 
class getUndeliveredOrders_args:
1886 ankur.sing 16165 
  """
16166 
  Attributes:
3064 chandransh 16167 
   - providerId
16168 
   - warehouseId
1886 ankur.sing 16169 
  """
1627 ankur.sing 16170 
 
1886 ankur.sing 16171 
  thrift_spec = (
16172 
    None, # 0
3064 chandransh 16173 
    (1, TType.I64, 'providerId', None, None, ), # 1
16174 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16175 
  )
16176 
 
3064 chandransh 16177 
  def __init__(self, providerId=None, warehouseId=None,):
16178 
    self.providerId = providerId
16179 
    self.warehouseId = warehouseId
1886 ankur.sing 16180 
 
16181 
  def read(self, iprot):
16182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16184 
      return
16185 
    iprot.readStructBegin()
16186 
    while True:
16187 
      (fname, ftype, fid) = iprot.readFieldBegin()
16188 
      if ftype == TType.STOP:
16189 
        break
16190 
      if fid == 1:
16191 
        if ftype == TType.I64:
3064 chandransh 16192 
          self.providerId = iprot.readI64();
1886 ankur.sing 16193 
        else:
16194 
          iprot.skip(ftype)
3064 chandransh 16195 
      elif fid == 2:
16196 
        if ftype == TType.I64:
16197 
          self.warehouseId = iprot.readI64();
16198 
        else:
16199 
          iprot.skip(ftype)
1886 ankur.sing 16200 
      else:
16201 
        iprot.skip(ftype)
16202 
      iprot.readFieldEnd()
16203 
    iprot.readStructEnd()
16204 
 
16205 
  def write(self, oprot):
16206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16208 
      return
3064 chandransh 16209 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16210 
    if self.providerId is not None:
3064 chandransh 16211 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16212 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16213 
      oprot.writeFieldEnd()
3431 rajveer 16214 
    if self.warehouseId is not None:
3064 chandransh 16215 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16216 
      oprot.writeI64(self.warehouseId)
16217 
      oprot.writeFieldEnd()
1886 ankur.sing 16218 
    oprot.writeFieldStop()
16219 
    oprot.writeStructEnd()
16220 
 
3431 rajveer 16221 
  def validate(self):
16222 
    return
16223 
 
16224 
 
1886 ankur.sing 16225 
  def __repr__(self):
16226 
    L = ['%s=%r' % (key, value)
16227 
      for key, value in self.__dict__.iteritems()]
16228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16229 
 
16230 
  def __eq__(self, other):
16231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16232 
 
16233 
  def __ne__(self, other):
16234 
    return not (self == other)
16235 
 
3064 chandransh 16236 
class getUndeliveredOrders_result:
1886 ankur.sing 16237 
  """
16238 
  Attributes:
16239 
   - success
16240 
  """
16241 
 
16242 
  thrift_spec = (
16243 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16244 
  )
16245 
 
16246 
  def __init__(self, success=None,):
16247 
    self.success = success
16248 
 
16249 
  def read(self, iprot):
16250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16252 
      return
16253 
    iprot.readStructBegin()
16254 
    while True:
16255 
      (fname, ftype, fid) = iprot.readFieldBegin()
16256 
      if ftype == TType.STOP:
16257 
        break
16258 
      if fid == 0:
16259 
        if ftype == TType.LIST:
16260 
          self.success = []
6188 rajveer 16261 
          (_etype396, _size393) = iprot.readListBegin()
16262 
          for _i397 in xrange(_size393):
16263 
            _elem398 = Order()
16264 
            _elem398.read(iprot)
16265 
            self.success.append(_elem398)
1886 ankur.sing 16266 
          iprot.readListEnd()
16267 
        else:
16268 
          iprot.skip(ftype)
16269 
      else:
16270 
        iprot.skip(ftype)
16271 
      iprot.readFieldEnd()
16272 
    iprot.readStructEnd()
16273 
 
16274 
  def write(self, oprot):
16275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16277 
      return
3064 chandransh 16278 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16279 
    if self.success is not None:
1886 ankur.sing 16280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16282 
      for iter399 in self.success:
16283 
        iter399.write(oprot)
1886 ankur.sing 16284 
      oprot.writeListEnd()
16285 
      oprot.writeFieldEnd()
16286 
    oprot.writeFieldStop()
16287 
    oprot.writeStructEnd()
16288 
 
3431 rajveer 16289 
  def validate(self):
16290 
    return
16291 
 
16292 
 
1886 ankur.sing 16293 
  def __repr__(self):
16294 
    L = ['%s=%r' % (key, value)
16295 
      for key, value in self.__dict__.iteritems()]
16296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16297 
 
16298 
  def __eq__(self, other):
16299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16300 
 
16301 
  def __ne__(self, other):
16302 
    return not (self == other)
16303 
 
4783 phani.kuma 16304 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16305 
 
16306 
  thrift_spec = (
16307 
  )
16308 
 
16309 
  def read(self, iprot):
16310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16312 
      return
16313 
    iprot.readStructBegin()
16314 
    while True:
16315 
      (fname, ftype, fid) = iprot.readFieldBegin()
16316 
      if ftype == TType.STOP:
16317 
        break
16318 
      else:
16319 
        iprot.skip(ftype)
16320 
      iprot.readFieldEnd()
16321 
    iprot.readStructEnd()
16322 
 
16323 
  def write(self, oprot):
16324 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16325 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16326 
      return
16327 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16328 
    oprot.writeFieldStop()
16329 
    oprot.writeStructEnd()
16330 
 
16331 
  def validate(self):
16332 
    return
16333 
 
16334 
 
16335 
  def __repr__(self):
16336 
    L = ['%s=%r' % (key, value)
16337 
      for key, value in self.__dict__.iteritems()]
16338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16339 
 
16340 
  def __eq__(self, other):
16341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16342 
 
16343 
  def __ne__(self, other):
16344 
    return not (self == other)
16345 
 
16346 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16347 
  """
16348 
  Attributes:
16349 
   - success
16350 
  """
16351 
 
16352 
  thrift_spec = (
16353 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16354 
  )
16355 
 
16356 
  def __init__(self, success=None,):
16357 
    self.success = success
16358 
 
16359 
  def read(self, iprot):
16360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16362 
      return
16363 
    iprot.readStructBegin()
16364 
    while True:
16365 
      (fname, ftype, fid) = iprot.readFieldBegin()
16366 
      if ftype == TType.STOP:
16367 
        break
16368 
      if fid == 0:
16369 
        if ftype == TType.LIST:
16370 
          self.success = []
6188 rajveer 16371 
          (_etype403, _size400) = iprot.readListBegin()
16372 
          for _i404 in xrange(_size400):
16373 
            _elem405 = Order()
16374 
            _elem405.read(iprot)
16375 
            self.success.append(_elem405)
4783 phani.kuma 16376 
          iprot.readListEnd()
16377 
        else:
16378 
          iprot.skip(ftype)
16379 
      else:
16380 
        iprot.skip(ftype)
16381 
      iprot.readFieldEnd()
16382 
    iprot.readStructEnd()
16383 
 
16384 
  def write(self, oprot):
16385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16387 
      return
16388 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16389 
    if self.success is not None:
16390 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16391 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16392 
      for iter406 in self.success:
16393 
        iter406.write(oprot)
4783 phani.kuma 16394 
      oprot.writeListEnd()
16395 
      oprot.writeFieldEnd()
16396 
    oprot.writeFieldStop()
16397 
    oprot.writeStructEnd()
16398 
 
16399 
  def validate(self):
16400 
    return
16401 
 
16402 
 
16403 
  def __repr__(self):
16404 
    L = ['%s=%r' % (key, value)
16405 
      for key, value in self.__dict__.iteritems()]
16406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16407 
 
16408 
  def __eq__(self, other):
16409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16410 
 
16411 
  def __ne__(self, other):
16412 
    return not (self == other)
16413 
 
2536 chandransh 16414 
class toggleDOAFlag_args:
16415 
  """
16416 
  Attributes:
16417 
   - orderId
16418 
  """
1886 ankur.sing 16419 
 
2536 chandransh 16420 
  thrift_spec = (
16421 
    None, # 0
16422 
    (1, TType.I64, 'orderId', None, None, ), # 1
16423 
  )
16424 
 
16425 
  def __init__(self, orderId=None,):
16426 
    self.orderId = orderId
16427 
 
16428 
  def read(self, iprot):
16429 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16430 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16431 
      return
16432 
    iprot.readStructBegin()
16433 
    while True:
16434 
      (fname, ftype, fid) = iprot.readFieldBegin()
16435 
      if ftype == TType.STOP:
16436 
        break
16437 
      if fid == 1:
16438 
        if ftype == TType.I64:
16439 
          self.orderId = iprot.readI64();
16440 
        else:
16441 
          iprot.skip(ftype)
16442 
      else:
16443 
        iprot.skip(ftype)
16444 
      iprot.readFieldEnd()
16445 
    iprot.readStructEnd()
16446 
 
16447 
  def write(self, oprot):
16448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16450 
      return
16451 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16452 
    if self.orderId is not None:
2536 chandransh 16453 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16454 
      oprot.writeI64(self.orderId)
16455 
      oprot.writeFieldEnd()
16456 
    oprot.writeFieldStop()
16457 
    oprot.writeStructEnd()
16458 
 
3431 rajveer 16459 
  def validate(self):
16460 
    return
16461 
 
16462 
 
2536 chandransh 16463 
  def __repr__(self):
16464 
    L = ['%s=%r' % (key, value)
16465 
      for key, value in self.__dict__.iteritems()]
16466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16467 
 
16468 
  def __eq__(self, other):
16469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16470 
 
16471 
  def __ne__(self, other):
16472 
    return not (self == other)
16473 
 
16474 
class toggleDOAFlag_result:
16475 
  """
16476 
  Attributes:
16477 
   - success
16478 
   - ex
16479 
  """
16480 
 
16481 
  thrift_spec = (
16482 
    (0, TType.BOOL, 'success', None, None, ), # 0
16483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16484 
  )
16485 
 
16486 
  def __init__(self, success=None, ex=None,):
16487 
    self.success = success
16488 
    self.ex = ex
16489 
 
16490 
  def read(self, iprot):
16491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16493 
      return
16494 
    iprot.readStructBegin()
16495 
    while True:
16496 
      (fname, ftype, fid) = iprot.readFieldBegin()
16497 
      if ftype == TType.STOP:
16498 
        break
16499 
      if fid == 0:
16500 
        if ftype == TType.BOOL:
16501 
          self.success = iprot.readBool();
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      elif fid == 1:
16505 
        if ftype == TType.STRUCT:
16506 
          self.ex = TransactionServiceException()
16507 
          self.ex.read(iprot)
16508 
        else:
16509 
          iprot.skip(ftype)
16510 
      else:
16511 
        iprot.skip(ftype)
16512 
      iprot.readFieldEnd()
16513 
    iprot.readStructEnd()
16514 
 
16515 
  def write(self, oprot):
16516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16518 
      return
16519 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16520 
    if self.success is not None:
2536 chandransh 16521 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16522 
      oprot.writeBool(self.success)
16523 
      oprot.writeFieldEnd()
3431 rajveer 16524 
    if self.ex is not None:
2536 chandransh 16525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16526 
      self.ex.write(oprot)
16527 
      oprot.writeFieldEnd()
16528 
    oprot.writeFieldStop()
16529 
    oprot.writeStructEnd()
16530 
 
3431 rajveer 16531 
  def validate(self):
16532 
    return
16533 
 
16534 
 
2536 chandransh 16535 
  def __repr__(self):
16536 
    L = ['%s=%r' % (key, value)
16537 
      for key, value in self.__dict__.iteritems()]
16538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16539 
 
16540 
  def __eq__(self, other):
16541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16542 
 
16543 
  def __ne__(self, other):
16544 
    return not (self == other)
16545 
 
4712 rajveer 16546 
class markOrderAsDelivered_args:
16547 
  """
16548 
  Attributes:
16549 
   - orderId
16550 
   - deliveryTimestamp
16551 
   - receiver
16552 
  """
16553 
 
16554 
  thrift_spec = None
16555 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16556 
    self.orderId = orderId
16557 
    self.deliveryTimestamp = deliveryTimestamp
16558 
    self.receiver = receiver
16559 
 
16560 
  def read(self, iprot):
16561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16563 
      return
16564 
    iprot.readStructBegin()
16565 
    while True:
16566 
      (fname, ftype, fid) = iprot.readFieldBegin()
16567 
      if ftype == TType.STOP:
16568 
        break
16569 
      if fid == 1:
16570 
        if ftype == TType.I64:
16571 
          self.orderId = iprot.readI64();
16572 
        else:
16573 
          iprot.skip(ftype)
16574 
      elif fid == 2:
16575 
        if ftype == TType.I64:
16576 
          self.deliveryTimestamp = iprot.readI64();
16577 
        else:
16578 
          iprot.skip(ftype)
16579 
      elif fid == -1:
16580 
        if ftype == TType.STRING:
16581 
          self.receiver = iprot.readString();
16582 
        else:
16583 
          iprot.skip(ftype)
16584 
      else:
16585 
        iprot.skip(ftype)
16586 
      iprot.readFieldEnd()
16587 
    iprot.readStructEnd()
16588 
 
16589 
  def write(self, oprot):
16590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16592 
      return
16593 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16594 
    if self.receiver is not None:
16595 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16596 
      oprot.writeString(self.receiver)
16597 
      oprot.writeFieldEnd()
16598 
    if self.orderId is not None:
16599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16600 
      oprot.writeI64(self.orderId)
16601 
      oprot.writeFieldEnd()
16602 
    if self.deliveryTimestamp is not None:
16603 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16604 
      oprot.writeI64(self.deliveryTimestamp)
16605 
      oprot.writeFieldEnd()
16606 
    oprot.writeFieldStop()
16607 
    oprot.writeStructEnd()
16608 
 
16609 
  def validate(self):
16610 
    return
16611 
 
16612 
 
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 markOrderAsDelivered_result:
16625 
  """
16626 
  Attributes:
16627 
   - ex
16628 
  """
16629 
 
16630 
  thrift_spec = (
16631 
    None, # 0
16632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16633 
  )
16634 
 
16635 
  def __init__(self, ex=None,):
16636 
    self.ex = ex
16637 
 
16638 
  def read(self, iprot):
16639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16641 
      return
16642 
    iprot.readStructBegin()
16643 
    while True:
16644 
      (fname, ftype, fid) = iprot.readFieldBegin()
16645 
      if ftype == TType.STOP:
16646 
        break
16647 
      if fid == 1:
16648 
        if ftype == TType.STRUCT:
16649 
          self.ex = TransactionServiceException()
16650 
          self.ex.read(iprot)
16651 
        else:
16652 
          iprot.skip(ftype)
16653 
      else:
16654 
        iprot.skip(ftype)
16655 
      iprot.readFieldEnd()
16656 
    iprot.readStructEnd()
16657 
 
16658 
  def write(self, oprot):
16659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16661 
      return
16662 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16663 
    if self.ex is not None:
16664 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16665 
      self.ex.write(oprot)
16666 
      oprot.writeFieldEnd()
16667 
    oprot.writeFieldStop()
16668 
    oprot.writeStructEnd()
16669 
 
16670 
  def validate(self):
16671 
    return
16672 
 
16673 
 
16674 
  def __repr__(self):
16675 
    L = ['%s=%r' % (key, value)
16676 
      for key, value in self.__dict__.iteritems()]
16677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16678 
 
16679 
  def __eq__(self, other):
16680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16681 
 
16682 
  def __ne__(self, other):
16683 
    return not (self == other)
16684 
 
5553 rajveer 16685 
class markOrderAsReceivedAtStore_args:
16686 
  """
16687 
  Attributes:
16688 
   - orderId
16689 
   - deliveryTimestamp
16690 
  """
16691 
 
16692 
  thrift_spec = (
16693 
    None, # 0
16694 
    (1, TType.I64, 'orderId', None, None, ), # 1
16695 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16696 
  )
16697 
 
16698 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16699 
    self.orderId = orderId
16700 
    self.deliveryTimestamp = deliveryTimestamp
16701 
 
16702 
  def read(self, iprot):
16703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16705 
      return
16706 
    iprot.readStructBegin()
16707 
    while True:
16708 
      (fname, ftype, fid) = iprot.readFieldBegin()
16709 
      if ftype == TType.STOP:
16710 
        break
16711 
      if fid == 1:
16712 
        if ftype == TType.I64:
16713 
          self.orderId = iprot.readI64();
16714 
        else:
16715 
          iprot.skip(ftype)
16716 
      elif fid == 2:
16717 
        if ftype == TType.I64:
16718 
          self.deliveryTimestamp = iprot.readI64();
16719 
        else:
16720 
          iprot.skip(ftype)
16721 
      else:
16722 
        iprot.skip(ftype)
16723 
      iprot.readFieldEnd()
16724 
    iprot.readStructEnd()
16725 
 
16726 
  def write(self, oprot):
16727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16729 
      return
16730 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16731 
    if self.orderId is not None:
16732 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16733 
      oprot.writeI64(self.orderId)
16734 
      oprot.writeFieldEnd()
16735 
    if self.deliveryTimestamp is not None:
16736 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16737 
      oprot.writeI64(self.deliveryTimestamp)
16738 
      oprot.writeFieldEnd()
16739 
    oprot.writeFieldStop()
16740 
    oprot.writeStructEnd()
16741 
 
16742 
  def validate(self):
16743 
    return
16744 
 
16745 
 
16746 
  def __repr__(self):
16747 
    L = ['%s=%r' % (key, value)
16748 
      for key, value in self.__dict__.iteritems()]
16749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16750 
 
16751 
  def __eq__(self, other):
16752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16753 
 
16754 
  def __ne__(self, other):
16755 
    return not (self == other)
16756 
 
16757 
class markOrderAsReceivedAtStore_result:
16758 
  """
16759 
  Attributes:
16760 
   - ex
16761 
  """
16762 
 
16763 
  thrift_spec = (
16764 
    None, # 0
16765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16766 
  )
16767 
 
16768 
  def __init__(self, ex=None,):
16769 
    self.ex = ex
16770 
 
16771 
  def read(self, iprot):
16772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16774 
      return
16775 
    iprot.readStructBegin()
16776 
    while True:
16777 
      (fname, ftype, fid) = iprot.readFieldBegin()
16778 
      if ftype == TType.STOP:
16779 
        break
16780 
      if fid == 1:
16781 
        if ftype == TType.STRUCT:
16782 
          self.ex = TransactionServiceException()
16783 
          self.ex.read(iprot)
16784 
        else:
16785 
          iprot.skip(ftype)
16786 
      else:
16787 
        iprot.skip(ftype)
16788 
      iprot.readFieldEnd()
16789 
    iprot.readStructEnd()
16790 
 
16791 
  def write(self, oprot):
16792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16794 
      return
16795 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16796 
    if self.ex is not None:
16797 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16798 
      self.ex.write(oprot)
16799 
      oprot.writeFieldEnd()
16800 
    oprot.writeFieldStop()
16801 
    oprot.writeStructEnd()
16802 
 
16803 
  def validate(self):
16804 
    return
16805 
 
16806 
 
16807 
  def __repr__(self):
16808 
    L = ['%s=%r' % (key, value)
16809 
      for key, value in self.__dict__.iteritems()]
16810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16811 
 
16812 
  def __eq__(self, other):
16813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16814 
 
16815 
  def __ne__(self, other):
16816 
    return not (self == other)
16817 
 
4454 rajveer 16818 
class markOrderDoaRequestReceived_args:
16819 
  """
16820 
  Attributes:
16821 
   - orderId
16822 
  """
16823 
 
16824 
  thrift_spec = (
16825 
    None, # 0
16826 
    (1, TType.I64, 'orderId', None, None, ), # 1
16827 
  )
16828 
 
16829 
  def __init__(self, orderId=None,):
16830 
    self.orderId = orderId
16831 
 
16832 
  def read(self, iprot):
16833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16835 
      return
16836 
    iprot.readStructBegin()
16837 
    while True:
16838 
      (fname, ftype, fid) = iprot.readFieldBegin()
16839 
      if ftype == TType.STOP:
16840 
        break
16841 
      if fid == 1:
16842 
        if ftype == TType.I64:
16843 
          self.orderId = iprot.readI64();
16844 
        else:
16845 
          iprot.skip(ftype)
16846 
      else:
16847 
        iprot.skip(ftype)
16848 
      iprot.readFieldEnd()
16849 
    iprot.readStructEnd()
16850 
 
16851 
  def write(self, oprot):
16852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16854 
      return
16855 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16856 
    if self.orderId is not None:
16857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16858 
      oprot.writeI64(self.orderId)
16859 
      oprot.writeFieldEnd()
16860 
    oprot.writeFieldStop()
16861 
    oprot.writeStructEnd()
16862 
 
16863 
  def validate(self):
16864 
    return
16865 
 
16866 
 
16867 
  def __repr__(self):
16868 
    L = ['%s=%r' % (key, value)
16869 
      for key, value in self.__dict__.iteritems()]
16870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16871 
 
16872 
  def __eq__(self, other):
16873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16874 
 
16875 
  def __ne__(self, other):
16876 
    return not (self == other)
16877 
 
16878 
class markOrderDoaRequestReceived_result:
16879 
  """
16880 
  Attributes:
16881 
   - success
16882 
   - ex
16883 
  """
16884 
 
16885 
  thrift_spec = (
16886 
    (0, TType.BOOL, 'success', None, None, ), # 0
16887 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16888 
  )
16889 
 
16890 
  def __init__(self, success=None, ex=None,):
16891 
    self.success = success
16892 
    self.ex = ex
16893 
 
16894 
  def read(self, iprot):
16895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16897 
      return
16898 
    iprot.readStructBegin()
16899 
    while True:
16900 
      (fname, ftype, fid) = iprot.readFieldBegin()
16901 
      if ftype == TType.STOP:
16902 
        break
16903 
      if fid == 0:
16904 
        if ftype == TType.BOOL:
16905 
          self.success = iprot.readBool();
16906 
        else:
16907 
          iprot.skip(ftype)
16908 
      elif fid == 1:
16909 
        if ftype == TType.STRUCT:
16910 
          self.ex = TransactionServiceException()
16911 
          self.ex.read(iprot)
16912 
        else:
16913 
          iprot.skip(ftype)
16914 
      else:
16915 
        iprot.skip(ftype)
16916 
      iprot.readFieldEnd()
16917 
    iprot.readStructEnd()
16918 
 
16919 
  def write(self, oprot):
16920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16922 
      return
16923 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16924 
    if self.success is not None:
16925 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16926 
      oprot.writeBool(self.success)
16927 
      oprot.writeFieldEnd()
16928 
    if self.ex is not None:
16929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16930 
      self.ex.write(oprot)
16931 
      oprot.writeFieldEnd()
16932 
    oprot.writeFieldStop()
16933 
    oprot.writeStructEnd()
16934 
 
16935 
  def validate(self):
16936 
    return
16937 
 
16938 
 
16939 
  def __repr__(self):
16940 
    L = ['%s=%r' % (key, value)
16941 
      for key, value in self.__dict__.iteritems()]
16942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16943 
 
16944 
  def __eq__(self, other):
16945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16946 
 
16947 
  def __ne__(self, other):
16948 
    return not (self == other)
16949 
 
16950 
class markOrderDoaRequestAuthorized_args:
16951 
  """
16952 
  Attributes:
16953 
   - orderId
16954 
   - isAuthorized
16955 
  """
16956 
 
16957 
  thrift_spec = (
16958 
    None, # 0
16959 
    (1, TType.I64, 'orderId', None, None, ), # 1
16960 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16961 
  )
16962 
 
16963 
  def __init__(self, orderId=None, isAuthorized=None,):
16964 
    self.orderId = orderId
16965 
    self.isAuthorized = isAuthorized
16966 
 
16967 
  def read(self, iprot):
16968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16970 
      return
16971 
    iprot.readStructBegin()
16972 
    while True:
16973 
      (fname, ftype, fid) = iprot.readFieldBegin()
16974 
      if ftype == TType.STOP:
16975 
        break
16976 
      if fid == 1:
16977 
        if ftype == TType.I64:
16978 
          self.orderId = iprot.readI64();
16979 
        else:
16980 
          iprot.skip(ftype)
16981 
      elif fid == 2:
16982 
        if ftype == TType.BOOL:
16983 
          self.isAuthorized = iprot.readBool();
16984 
        else:
16985 
          iprot.skip(ftype)
16986 
      else:
16987 
        iprot.skip(ftype)
16988 
      iprot.readFieldEnd()
16989 
    iprot.readStructEnd()
16990 
 
16991 
  def write(self, oprot):
16992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16994 
      return
16995 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16996 
    if self.orderId is not None:
16997 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16998 
      oprot.writeI64(self.orderId)
16999 
      oprot.writeFieldEnd()
17000 
    if self.isAuthorized is not None:
17001 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17002 
      oprot.writeBool(self.isAuthorized)
17003 
      oprot.writeFieldEnd()
17004 
    oprot.writeFieldStop()
17005 
    oprot.writeStructEnd()
17006 
 
17007 
  def validate(self):
17008 
    return
17009 
 
17010 
 
17011 
  def __repr__(self):
17012 
    L = ['%s=%r' % (key, value)
17013 
      for key, value in self.__dict__.iteritems()]
17014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17015 
 
17016 
  def __eq__(self, other):
17017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17018 
 
17019 
  def __ne__(self, other):
17020 
    return not (self == other)
17021 
 
17022 
class markOrderDoaRequestAuthorized_result:
17023 
  """
17024 
  Attributes:
17025 
   - success
17026 
   - ex
17027 
  """
17028 
 
17029 
  thrift_spec = (
17030 
    (0, TType.BOOL, 'success', None, None, ), # 0
17031 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17032 
  )
17033 
 
17034 
  def __init__(self, success=None, ex=None,):
17035 
    self.success = success
17036 
    self.ex = ex
17037 
 
17038 
  def read(self, iprot):
17039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17041 
      return
17042 
    iprot.readStructBegin()
17043 
    while True:
17044 
      (fname, ftype, fid) = iprot.readFieldBegin()
17045 
      if ftype == TType.STOP:
17046 
        break
17047 
      if fid == 0:
17048 
        if ftype == TType.BOOL:
17049 
          self.success = iprot.readBool();
17050 
        else:
17051 
          iprot.skip(ftype)
17052 
      elif fid == 1:
17053 
        if ftype == TType.STRUCT:
17054 
          self.ex = TransactionServiceException()
17055 
          self.ex.read(iprot)
17056 
        else:
17057 
          iprot.skip(ftype)
17058 
      else:
17059 
        iprot.skip(ftype)
17060 
      iprot.readFieldEnd()
17061 
    iprot.readStructEnd()
17062 
 
17063 
  def write(self, oprot):
17064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17066 
      return
17067 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17068 
    if self.success is not None:
17069 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17070 
      oprot.writeBool(self.success)
17071 
      oprot.writeFieldEnd()
17072 
    if self.ex is not None:
17073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17074 
      self.ex.write(oprot)
17075 
      oprot.writeFieldEnd()
17076 
    oprot.writeFieldStop()
17077 
    oprot.writeStructEnd()
17078 
 
17079 
  def validate(self):
17080 
    return
17081 
 
17082 
 
17083 
  def __repr__(self):
17084 
    L = ['%s=%r' % (key, value)
17085 
      for key, value in self.__dict__.iteritems()]
17086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17087 
 
17088 
  def __eq__(self, other):
17089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17090 
 
17091 
  def __ne__(self, other):
17092 
    return not (self == other)
17093 
 
4488 rajveer 17094 
class markOrderReturnRequestReceived_args:
17095 
  """
17096 
  Attributes:
17097 
   - orderId
17098 
  """
17099 
 
17100 
  thrift_spec = (
17101 
    None, # 0
17102 
    (1, TType.I64, 'orderId', None, None, ), # 1
17103 
  )
17104 
 
17105 
  def __init__(self, orderId=None,):
17106 
    self.orderId = orderId
17107 
 
17108 
  def read(self, iprot):
17109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17111 
      return
17112 
    iprot.readStructBegin()
17113 
    while True:
17114 
      (fname, ftype, fid) = iprot.readFieldBegin()
17115 
      if ftype == TType.STOP:
17116 
        break
17117 
      if fid == 1:
17118 
        if ftype == TType.I64:
17119 
          self.orderId = iprot.readI64();
17120 
        else:
17121 
          iprot.skip(ftype)
17122 
      else:
17123 
        iprot.skip(ftype)
17124 
      iprot.readFieldEnd()
17125 
    iprot.readStructEnd()
17126 
 
17127 
  def write(self, oprot):
17128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17130 
      return
17131 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17132 
    if self.orderId is not None:
17133 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17134 
      oprot.writeI64(self.orderId)
17135 
      oprot.writeFieldEnd()
17136 
    oprot.writeFieldStop()
17137 
    oprot.writeStructEnd()
17138 
 
17139 
  def validate(self):
17140 
    return
17141 
 
17142 
 
17143 
  def __repr__(self):
17144 
    L = ['%s=%r' % (key, value)
17145 
      for key, value in self.__dict__.iteritems()]
17146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17147 
 
17148 
  def __eq__(self, other):
17149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17150 
 
17151 
  def __ne__(self, other):
17152 
    return not (self == other)
17153 
 
17154 
class markOrderReturnRequestReceived_result:
17155 
  """
17156 
  Attributes:
17157 
   - success
17158 
   - ex
17159 
  """
17160 
 
17161 
  thrift_spec = (
17162 
    (0, TType.BOOL, 'success', None, None, ), # 0
17163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17164 
  )
17165 
 
17166 
  def __init__(self, success=None, ex=None,):
17167 
    self.success = success
17168 
    self.ex = ex
17169 
 
17170 
  def read(self, iprot):
17171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17173 
      return
17174 
    iprot.readStructBegin()
17175 
    while True:
17176 
      (fname, ftype, fid) = iprot.readFieldBegin()
17177 
      if ftype == TType.STOP:
17178 
        break
17179 
      if fid == 0:
17180 
        if ftype == TType.BOOL:
17181 
          self.success = iprot.readBool();
17182 
        else:
17183 
          iprot.skip(ftype)
17184 
      elif fid == 1:
17185 
        if ftype == TType.STRUCT:
17186 
          self.ex = TransactionServiceException()
17187 
          self.ex.read(iprot)
17188 
        else:
17189 
          iprot.skip(ftype)
17190 
      else:
17191 
        iprot.skip(ftype)
17192 
      iprot.readFieldEnd()
17193 
    iprot.readStructEnd()
17194 
 
17195 
  def write(self, oprot):
17196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17198 
      return
17199 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17200 
    if self.success is not None:
17201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17202 
      oprot.writeBool(self.success)
17203 
      oprot.writeFieldEnd()
17204 
    if self.ex is not None:
17205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17206 
      self.ex.write(oprot)
17207 
      oprot.writeFieldEnd()
17208 
    oprot.writeFieldStop()
17209 
    oprot.writeStructEnd()
17210 
 
17211 
  def validate(self):
17212 
    return
17213 
 
17214 
 
17215 
  def __repr__(self):
17216 
    L = ['%s=%r' % (key, value)
17217 
      for key, value in self.__dict__.iteritems()]
17218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17219 
 
17220 
  def __eq__(self, other):
17221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17222 
 
17223 
  def __ne__(self, other):
17224 
    return not (self == other)
17225 
 
17226 
class markOrderReturnRequestAuthorized_args:
17227 
  """
17228 
  Attributes:
17229 
   - orderId
17230 
   - isAuthorized
17231 
  """
17232 
 
17233 
  thrift_spec = (
17234 
    None, # 0
17235 
    (1, TType.I64, 'orderId', None, None, ), # 1
17236 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17237 
  )
17238 
 
17239 
  def __init__(self, orderId=None, isAuthorized=None,):
17240 
    self.orderId = orderId
17241 
    self.isAuthorized = isAuthorized
17242 
 
17243 
  def read(self, iprot):
17244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17246 
      return
17247 
    iprot.readStructBegin()
17248 
    while True:
17249 
      (fname, ftype, fid) = iprot.readFieldBegin()
17250 
      if ftype == TType.STOP:
17251 
        break
17252 
      if fid == 1:
17253 
        if ftype == TType.I64:
17254 
          self.orderId = iprot.readI64();
17255 
        else:
17256 
          iprot.skip(ftype)
17257 
      elif fid == 2:
17258 
        if ftype == TType.BOOL:
17259 
          self.isAuthorized = iprot.readBool();
17260 
        else:
17261 
          iprot.skip(ftype)
17262 
      else:
17263 
        iprot.skip(ftype)
17264 
      iprot.readFieldEnd()
17265 
    iprot.readStructEnd()
17266 
 
17267 
  def write(self, oprot):
17268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17270 
      return
17271 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17272 
    if self.orderId is not None:
17273 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17274 
      oprot.writeI64(self.orderId)
17275 
      oprot.writeFieldEnd()
17276 
    if self.isAuthorized is not None:
17277 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17278 
      oprot.writeBool(self.isAuthorized)
17279 
      oprot.writeFieldEnd()
17280 
    oprot.writeFieldStop()
17281 
    oprot.writeStructEnd()
17282 
 
17283 
  def validate(self):
17284 
    return
17285 
 
17286 
 
17287 
  def __repr__(self):
17288 
    L = ['%s=%r' % (key, value)
17289 
      for key, value in self.__dict__.iteritems()]
17290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17291 
 
17292 
  def __eq__(self, other):
17293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17294 
 
17295 
  def __ne__(self, other):
17296 
    return not (self == other)
17297 
 
17298 
class markOrderReturnRequestAuthorized_result:
17299 
  """
17300 
  Attributes:
17301 
   - success
17302 
   - ex
17303 
  """
17304 
 
17305 
  thrift_spec = (
17306 
    (0, TType.BOOL, 'success', None, None, ), # 0
17307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17308 
  )
17309 
 
17310 
  def __init__(self, success=None, ex=None,):
17311 
    self.success = success
17312 
    self.ex = ex
17313 
 
17314 
  def read(self, iprot):
17315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17317 
      return
17318 
    iprot.readStructBegin()
17319 
    while True:
17320 
      (fname, ftype, fid) = iprot.readFieldBegin()
17321 
      if ftype == TType.STOP:
17322 
        break
17323 
      if fid == 0:
17324 
        if ftype == TType.BOOL:
17325 
          self.success = iprot.readBool();
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      elif fid == 1:
17329 
        if ftype == TType.STRUCT:
17330 
          self.ex = TransactionServiceException()
17331 
          self.ex.read(iprot)
17332 
        else:
17333 
          iprot.skip(ftype)
17334 
      else:
17335 
        iprot.skip(ftype)
17336 
      iprot.readFieldEnd()
17337 
    iprot.readStructEnd()
17338 
 
17339 
  def write(self, oprot):
17340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17342 
      return
17343 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17344 
    if self.success is not None:
17345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17346 
      oprot.writeBool(self.success)
17347 
      oprot.writeFieldEnd()
17348 
    if self.ex is not None:
17349 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17350 
      self.ex.write(oprot)
17351 
      oprot.writeFieldEnd()
17352 
    oprot.writeFieldStop()
17353 
    oprot.writeStructEnd()
17354 
 
17355 
  def validate(self):
17356 
    return
17357 
 
17358 
 
17359 
  def __repr__(self):
17360 
    L = ['%s=%r' % (key, value)
17361 
      for key, value in self.__dict__.iteritems()]
17362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17363 
 
17364 
  def __eq__(self, other):
17365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17366 
 
17367 
  def __ne__(self, other):
17368 
    return not (self == other)
17369 
 
2536 chandransh 17370 
class requestPickupNumber_args:
17371 
  """
17372 
  Attributes:
17373 
   - orderId
4579 rajveer 17374 
   - providerId
2536 chandransh 17375 
  """
17376 
 
17377 
  thrift_spec = (
17378 
    None, # 0
17379 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17380 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17381 
  )
17382 
 
4579 rajveer 17383 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17384 
    self.orderId = orderId
4579 rajveer 17385 
    self.providerId = providerId
2536 chandransh 17386 
 
17387 
  def read(self, iprot):
17388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17390 
      return
17391 
    iprot.readStructBegin()
17392 
    while True:
17393 
      (fname, ftype, fid) = iprot.readFieldBegin()
17394 
      if ftype == TType.STOP:
17395 
        break
17396 
      if fid == 1:
17397 
        if ftype == TType.I64:
17398 
          self.orderId = iprot.readI64();
17399 
        else:
17400 
          iprot.skip(ftype)
4579 rajveer 17401 
      elif fid == 2:
17402 
        if ftype == TType.I64:
17403 
          self.providerId = iprot.readI64();
17404 
        else:
17405 
          iprot.skip(ftype)
2536 chandransh 17406 
      else:
17407 
        iprot.skip(ftype)
17408 
      iprot.readFieldEnd()
17409 
    iprot.readStructEnd()
17410 
 
17411 
  def write(self, oprot):
17412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17414 
      return
17415 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17416 
    if self.orderId is not None:
2536 chandransh 17417 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17418 
      oprot.writeI64(self.orderId)
17419 
      oprot.writeFieldEnd()
4579 rajveer 17420 
    if self.providerId is not None:
17421 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17422 
      oprot.writeI64(self.providerId)
17423 
      oprot.writeFieldEnd()
2536 chandransh 17424 
    oprot.writeFieldStop()
17425 
    oprot.writeStructEnd()
17426 
 
3431 rajveer 17427 
  def validate(self):
17428 
    return
17429 
 
17430 
 
2536 chandransh 17431 
  def __repr__(self):
17432 
    L = ['%s=%r' % (key, value)
17433 
      for key, value in self.__dict__.iteritems()]
17434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17435 
 
17436 
  def __eq__(self, other):
17437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17438 
 
17439 
  def __ne__(self, other):
17440 
    return not (self == other)
17441 
 
17442 
class requestPickupNumber_result:
17443 
  """
17444 
  Attributes:
17445 
   - success
17446 
   - ex
17447 
  """
17448 
 
17449 
  thrift_spec = (
17450 
    (0, TType.BOOL, 'success', None, None, ), # 0
17451 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17452 
  )
17453 
 
17454 
  def __init__(self, success=None, ex=None,):
17455 
    self.success = success
17456 
    self.ex = ex
17457 
 
17458 
  def read(self, iprot):
17459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17461 
      return
17462 
    iprot.readStructBegin()
17463 
    while True:
17464 
      (fname, ftype, fid) = iprot.readFieldBegin()
17465 
      if ftype == TType.STOP:
17466 
        break
17467 
      if fid == 0:
17468 
        if ftype == TType.BOOL:
17469 
          self.success = iprot.readBool();
17470 
        else:
17471 
          iprot.skip(ftype)
17472 
      elif fid == 1:
17473 
        if ftype == TType.STRUCT:
17474 
          self.ex = TransactionServiceException()
17475 
          self.ex.read(iprot)
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      else:
17479 
        iprot.skip(ftype)
17480 
      iprot.readFieldEnd()
17481 
    iprot.readStructEnd()
17482 
 
17483 
  def write(self, oprot):
17484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17486 
      return
17487 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17488 
    if self.success is not None:
2536 chandransh 17489 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17490 
      oprot.writeBool(self.success)
17491 
      oprot.writeFieldEnd()
3431 rajveer 17492 
    if self.ex is not None:
2536 chandransh 17493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17494 
      self.ex.write(oprot)
17495 
      oprot.writeFieldEnd()
17496 
    oprot.writeFieldStop()
17497 
    oprot.writeStructEnd()
17498 
 
3431 rajveer 17499 
  def validate(self):
17500 
    return
17501 
 
17502 
 
2536 chandransh 17503 
  def __repr__(self):
17504 
    L = ['%s=%r' % (key, value)
17505 
      for key, value in self.__dict__.iteritems()]
17506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17507 
 
17508 
  def __eq__(self, other):
17509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17510 
 
17511 
  def __ne__(self, other):
17512 
    return not (self == other)
17513 
 
17514 
class authorizePickup_args:
17515 
  """
17516 
  Attributes:
17517 
   - orderId
17518 
   - pickupNumber
4602 rajveer 17519 
   - providerId
2536 chandransh 17520 
  """
17521 
 
17522 
  thrift_spec = (
17523 
    None, # 0
17524 
    (1, TType.I64, 'orderId', None, None, ), # 1
17525 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17526 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17527 
  )
17528 
 
4602 rajveer 17529 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17530 
    self.orderId = orderId
17531 
    self.pickupNumber = pickupNumber
4602 rajveer 17532 
    self.providerId = providerId
2536 chandransh 17533 
 
17534 
  def read(self, iprot):
17535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17537 
      return
17538 
    iprot.readStructBegin()
17539 
    while True:
17540 
      (fname, ftype, fid) = iprot.readFieldBegin()
17541 
      if ftype == TType.STOP:
17542 
        break
17543 
      if fid == 1:
17544 
        if ftype == TType.I64:
17545 
          self.orderId = iprot.readI64();
17546 
        else:
17547 
          iprot.skip(ftype)
17548 
      elif fid == 2:
17549 
        if ftype == TType.STRING:
17550 
          self.pickupNumber = iprot.readString();
17551 
        else:
17552 
          iprot.skip(ftype)
4602 rajveer 17553 
      elif fid == 3:
17554 
        if ftype == TType.I64:
17555 
          self.providerId = iprot.readI64();
17556 
        else:
17557 
          iprot.skip(ftype)
2536 chandransh 17558 
      else:
17559 
        iprot.skip(ftype)
17560 
      iprot.readFieldEnd()
17561 
    iprot.readStructEnd()
17562 
 
17563 
  def write(self, oprot):
17564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17566 
      return
17567 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17568 
    if self.orderId is not None:
2536 chandransh 17569 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17570 
      oprot.writeI64(self.orderId)
17571 
      oprot.writeFieldEnd()
3431 rajveer 17572 
    if self.pickupNumber is not None:
2536 chandransh 17573 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17574 
      oprot.writeString(self.pickupNumber)
17575 
      oprot.writeFieldEnd()
4602 rajveer 17576 
    if self.providerId is not None:
17577 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17578 
      oprot.writeI64(self.providerId)
17579 
      oprot.writeFieldEnd()
2536 chandransh 17580 
    oprot.writeFieldStop()
17581 
    oprot.writeStructEnd()
17582 
 
3431 rajveer 17583 
  def validate(self):
17584 
    return
17585 
 
17586 
 
2536 chandransh 17587 
  def __repr__(self):
17588 
    L = ['%s=%r' % (key, value)
17589 
      for key, value in self.__dict__.iteritems()]
17590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17591 
 
17592 
  def __eq__(self, other):
17593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17594 
 
17595 
  def __ne__(self, other):
17596 
    return not (self == other)
17597 
 
17598 
class authorizePickup_result:
17599 
  """
17600 
  Attributes:
17601 
   - success
17602 
   - ex
17603 
  """
17604 
 
17605 
  thrift_spec = (
17606 
    (0, TType.BOOL, 'success', None, None, ), # 0
17607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17608 
  )
17609 
 
17610 
  def __init__(self, success=None, ex=None,):
17611 
    self.success = success
17612 
    self.ex = ex
17613 
 
17614 
  def read(self, iprot):
17615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17617 
      return
17618 
    iprot.readStructBegin()
17619 
    while True:
17620 
      (fname, ftype, fid) = iprot.readFieldBegin()
17621 
      if ftype == TType.STOP:
17622 
        break
17623 
      if fid == 0:
17624 
        if ftype == TType.BOOL:
17625 
          self.success = iprot.readBool();
17626 
        else:
17627 
          iprot.skip(ftype)
17628 
      elif fid == 1:
17629 
        if ftype == TType.STRUCT:
17630 
          self.ex = TransactionServiceException()
17631 
          self.ex.read(iprot)
17632 
        else:
17633 
          iprot.skip(ftype)
17634 
      else:
17635 
        iprot.skip(ftype)
17636 
      iprot.readFieldEnd()
17637 
    iprot.readStructEnd()
17638 
 
17639 
  def write(self, oprot):
17640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17642 
      return
17643 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17644 
    if self.success is not None:
2536 chandransh 17645 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17646 
      oprot.writeBool(self.success)
17647 
      oprot.writeFieldEnd()
3431 rajveer 17648 
    if self.ex is not None:
2536 chandransh 17649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17650 
      self.ex.write(oprot)
17651 
      oprot.writeFieldEnd()
17652 
    oprot.writeFieldStop()
17653 
    oprot.writeStructEnd()
17654 
 
3431 rajveer 17655 
  def validate(self):
17656 
    return
17657 
 
17658 
 
2536 chandransh 17659 
  def __repr__(self):
17660 
    L = ['%s=%r' % (key, value)
17661 
      for key, value in self.__dict__.iteritems()]
17662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17663 
 
17664 
  def __eq__(self, other):
17665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17666 
 
17667 
  def __ne__(self, other):
17668 
    return not (self == other)
17669 
 
2764 chandransh 17670 
class markDoasAsPickedUp_args:
17671 
  """
17672 
  Attributes:
17673 
   - providerId
17674 
   - pickupDetails
17675 
  """
17676 
 
17677 
  thrift_spec = (
17678 
    None, # 0
17679 
    (1, TType.I64, 'providerId', None, None, ), # 1
17680 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17681 
  )
17682 
 
17683 
  def __init__(self, providerId=None, pickupDetails=None,):
17684 
    self.providerId = providerId
17685 
    self.pickupDetails = pickupDetails
17686 
 
17687 
  def read(self, iprot):
17688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17690 
      return
17691 
    iprot.readStructBegin()
17692 
    while True:
17693 
      (fname, ftype, fid) = iprot.readFieldBegin()
17694 
      if ftype == TType.STOP:
17695 
        break
17696 
      if fid == 1:
17697 
        if ftype == TType.I64:
17698 
          self.providerId = iprot.readI64();
17699 
        else:
17700 
          iprot.skip(ftype)
17701 
      elif fid == 2:
17702 
        if ftype == TType.MAP:
17703 
          self.pickupDetails = {}
6188 rajveer 17704 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17705 
          for _i411 in xrange(_size407):
17706 
            _key412 = iprot.readString();
17707 
            _val413 = iprot.readString();
17708 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17709 
          iprot.readMapEnd()
17710 
        else:
17711 
          iprot.skip(ftype)
17712 
      else:
17713 
        iprot.skip(ftype)
17714 
      iprot.readFieldEnd()
17715 
    iprot.readStructEnd()
17716 
 
17717 
  def write(self, oprot):
17718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17720 
      return
17721 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17722 
    if self.providerId is not None:
2764 chandransh 17723 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17724 
      oprot.writeI64(self.providerId)
17725 
      oprot.writeFieldEnd()
3431 rajveer 17726 
    if self.pickupDetails is not None:
2764 chandransh 17727 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17728 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17729 
      for kiter414,viter415 in self.pickupDetails.items():
17730 
        oprot.writeString(kiter414)
17731 
        oprot.writeString(viter415)
2764 chandransh 17732 
      oprot.writeMapEnd()
17733 
      oprot.writeFieldEnd()
17734 
    oprot.writeFieldStop()
17735 
    oprot.writeStructEnd()
17736 
 
3431 rajveer 17737 
  def validate(self):
17738 
    return
17739 
 
17740 
 
2764 chandransh 17741 
  def __repr__(self):
17742 
    L = ['%s=%r' % (key, value)
17743 
      for key, value in self.__dict__.iteritems()]
17744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17745 
 
17746 
  def __eq__(self, other):
17747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17748 
 
17749 
  def __ne__(self, other):
17750 
    return not (self == other)
17751 
 
17752 
class markDoasAsPickedUp_result:
4910 phani.kuma 17753 
 
17754 
  thrift_spec = (
17755 
  )
17756 
 
17757 
  def read(self, iprot):
17758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17760 
      return
17761 
    iprot.readStructBegin()
17762 
    while True:
17763 
      (fname, ftype, fid) = iprot.readFieldBegin()
17764 
      if ftype == TType.STOP:
17765 
        break
17766 
      else:
17767 
        iprot.skip(ftype)
17768 
      iprot.readFieldEnd()
17769 
    iprot.readStructEnd()
17770 
 
17771 
  def write(self, oprot):
17772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17774 
      return
17775 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17776 
    oprot.writeFieldStop()
17777 
    oprot.writeStructEnd()
17778 
 
17779 
  def validate(self):
17780 
    return
17781 
 
17782 
 
17783 
  def __repr__(self):
17784 
    L = ['%s=%r' % (key, value)
17785 
      for key, value in self.__dict__.iteritems()]
17786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17787 
 
17788 
  def __eq__(self, other):
17789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17790 
 
17791 
  def __ne__(self, other):
17792 
    return not (self == other)
17793 
 
17794 
class getDoasNotPickedUp_args:
2764 chandransh 17795 
  """
17796 
  Attributes:
4910 phani.kuma 17797 
   - providerId
17798 
  """
17799 
 
17800 
  thrift_spec = (
17801 
    None, # 0
17802 
    (1, TType.I64, 'providerId', None, None, ), # 1
17803 
  )
17804 
 
17805 
  def __init__(self, providerId=None,):
17806 
    self.providerId = providerId
17807 
 
17808 
  def read(self, iprot):
17809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17811 
      return
17812 
    iprot.readStructBegin()
17813 
    while True:
17814 
      (fname, ftype, fid) = iprot.readFieldBegin()
17815 
      if ftype == TType.STOP:
17816 
        break
17817 
      if fid == 1:
17818 
        if ftype == TType.I64:
17819 
          self.providerId = iprot.readI64();
17820 
        else:
17821 
          iprot.skip(ftype)
17822 
      else:
17823 
        iprot.skip(ftype)
17824 
      iprot.readFieldEnd()
17825 
    iprot.readStructEnd()
17826 
 
17827 
  def write(self, oprot):
17828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17830 
      return
17831 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17832 
    if self.providerId is not None:
17833 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17834 
      oprot.writeI64(self.providerId)
17835 
      oprot.writeFieldEnd()
17836 
    oprot.writeFieldStop()
17837 
    oprot.writeStructEnd()
17838 
 
17839 
  def validate(self):
17840 
    return
17841 
 
17842 
 
17843 
  def __repr__(self):
17844 
    L = ['%s=%r' % (key, value)
17845 
      for key, value in self.__dict__.iteritems()]
17846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17847 
 
17848 
  def __eq__(self, other):
17849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17850 
 
17851 
  def __ne__(self, other):
17852 
    return not (self == other)
17853 
 
17854 
class getDoasNotPickedUp_result:
17855 
  """
17856 
  Attributes:
2764 chandransh 17857 
   - success
17858 
  """
17859 
 
17860 
  thrift_spec = (
17861 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17862 
  )
17863 
 
17864 
  def __init__(self, success=None,):
17865 
    self.success = success
17866 
 
17867 
  def read(self, iprot):
17868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17870 
      return
17871 
    iprot.readStructBegin()
17872 
    while True:
17873 
      (fname, ftype, fid) = iprot.readFieldBegin()
17874 
      if ftype == TType.STOP:
17875 
        break
17876 
      if fid == 0:
17877 
        if ftype == TType.LIST:
17878 
          self.success = []
6188 rajveer 17879 
          (_etype419, _size416) = iprot.readListBegin()
17880 
          for _i420 in xrange(_size416):
17881 
            _elem421 = Order()
17882 
            _elem421.read(iprot)
17883 
            self.success.append(_elem421)
2764 chandransh 17884 
          iprot.readListEnd()
17885 
        else:
17886 
          iprot.skip(ftype)
17887 
      else:
17888 
        iprot.skip(ftype)
17889 
      iprot.readFieldEnd()
17890 
    iprot.readStructEnd()
17891 
 
17892 
  def write(self, oprot):
17893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17895 
      return
4910 phani.kuma 17896 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17897 
    if self.success is not None:
2764 chandransh 17898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17900 
      for iter422 in self.success:
17901 
        iter422.write(oprot)
2764 chandransh 17902 
      oprot.writeListEnd()
17903 
      oprot.writeFieldEnd()
17904 
    oprot.writeFieldStop()
17905 
    oprot.writeStructEnd()
17906 
 
3431 rajveer 17907 
  def validate(self):
17908 
    return
17909 
 
17910 
 
2764 chandransh 17911 
  def __repr__(self):
17912 
    L = ['%s=%r' % (key, value)
17913 
      for key, value in self.__dict__.iteritems()]
17914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17915 
 
17916 
  def __eq__(self, other):
17917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17918 
 
17919 
  def __ne__(self, other):
17920 
    return not (self == other)
17921 
 
4741 phani.kuma 17922 
class markReturnOrdersAsPickedUp_args:
17923 
  """
17924 
  Attributes:
17925 
   - providerId
17926 
   - pickupDetails
17927 
  """
17928 
 
17929 
  thrift_spec = (
17930 
    None, # 0
17931 
    (1, TType.I64, 'providerId', None, None, ), # 1
17932 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17933 
  )
17934 
 
17935 
  def __init__(self, providerId=None, pickupDetails=None,):
17936 
    self.providerId = providerId
17937 
    self.pickupDetails = pickupDetails
17938 
 
17939 
  def read(self, iprot):
17940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17942 
      return
17943 
    iprot.readStructBegin()
17944 
    while True:
17945 
      (fname, ftype, fid) = iprot.readFieldBegin()
17946 
      if ftype == TType.STOP:
17947 
        break
17948 
      if fid == 1:
17949 
        if ftype == TType.I64:
17950 
          self.providerId = iprot.readI64();
17951 
        else:
17952 
          iprot.skip(ftype)
17953 
      elif fid == 2:
17954 
        if ftype == TType.MAP:
17955 
          self.pickupDetails = {}
6188 rajveer 17956 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17957 
          for _i427 in xrange(_size423):
17958 
            _key428 = iprot.readString();
17959 
            _val429 = iprot.readString();
17960 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17961 
          iprot.readMapEnd()
17962 
        else:
17963 
          iprot.skip(ftype)
17964 
      else:
17965 
        iprot.skip(ftype)
17966 
      iprot.readFieldEnd()
17967 
    iprot.readStructEnd()
17968 
 
17969 
  def write(self, oprot):
17970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17972 
      return
17973 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17974 
    if self.providerId is not None:
17975 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17976 
      oprot.writeI64(self.providerId)
17977 
      oprot.writeFieldEnd()
17978 
    if self.pickupDetails is not None:
17979 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17980 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17981 
      for kiter430,viter431 in self.pickupDetails.items():
17982 
        oprot.writeString(kiter430)
17983 
        oprot.writeString(viter431)
4741 phani.kuma 17984 
      oprot.writeMapEnd()
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 markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18005 
 
18006 
  thrift_spec = (
18007 
  )
18008 
 
18009 
  def read(self, iprot):
18010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18012 
      return
18013 
    iprot.readStructBegin()
18014 
    while True:
18015 
      (fname, ftype, fid) = iprot.readFieldBegin()
18016 
      if ftype == TType.STOP:
18017 
        break
18018 
      else:
18019 
        iprot.skip(ftype)
18020 
      iprot.readFieldEnd()
18021 
    iprot.readStructEnd()
18022 
 
18023 
  def write(self, oprot):
18024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18026 
      return
18027 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18028 
    oprot.writeFieldStop()
18029 
    oprot.writeStructEnd()
18030 
 
18031 
  def validate(self):
18032 
    return
18033 
 
18034 
 
18035 
  def __repr__(self):
18036 
    L = ['%s=%r' % (key, value)
18037 
      for key, value in self.__dict__.iteritems()]
18038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18039 
 
18040 
  def __eq__(self, other):
18041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18042 
 
18043 
  def __ne__(self, other):
18044 
    return not (self == other)
18045 
 
18046 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18047 
  """
18048 
  Attributes:
4910 phani.kuma 18049 
   - providerId
18050 
  """
18051 
 
18052 
  thrift_spec = (
18053 
    None, # 0
18054 
    (1, TType.I64, 'providerId', None, None, ), # 1
18055 
  )
18056 
 
18057 
  def __init__(self, providerId=None,):
18058 
    self.providerId = providerId
18059 
 
18060 
  def read(self, iprot):
18061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18063 
      return
18064 
    iprot.readStructBegin()
18065 
    while True:
18066 
      (fname, ftype, fid) = iprot.readFieldBegin()
18067 
      if ftype == TType.STOP:
18068 
        break
18069 
      if fid == 1:
18070 
        if ftype == TType.I64:
18071 
          self.providerId = iprot.readI64();
18072 
        else:
18073 
          iprot.skip(ftype)
18074 
      else:
18075 
        iprot.skip(ftype)
18076 
      iprot.readFieldEnd()
18077 
    iprot.readStructEnd()
18078 
 
18079 
  def write(self, oprot):
18080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18082 
      return
18083 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18084 
    if self.providerId is not None:
18085 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18086 
      oprot.writeI64(self.providerId)
18087 
      oprot.writeFieldEnd()
18088 
    oprot.writeFieldStop()
18089 
    oprot.writeStructEnd()
18090 
 
18091 
  def validate(self):
18092 
    return
18093 
 
18094 
 
18095 
  def __repr__(self):
18096 
    L = ['%s=%r' % (key, value)
18097 
      for key, value in self.__dict__.iteritems()]
18098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18099 
 
18100 
  def __eq__(self, other):
18101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18102 
 
18103 
  def __ne__(self, other):
18104 
    return not (self == other)
18105 
 
18106 
class getReturnOrdersNotPickedUp_result:
18107 
  """
18108 
  Attributes:
4741 phani.kuma 18109 
   - success
18110 
  """
18111 
 
18112 
  thrift_spec = (
18113 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18114 
  )
18115 
 
18116 
  def __init__(self, success=None,):
18117 
    self.success = success
18118 
 
18119 
  def read(self, iprot):
18120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18122 
      return
18123 
    iprot.readStructBegin()
18124 
    while True:
18125 
      (fname, ftype, fid) = iprot.readFieldBegin()
18126 
      if ftype == TType.STOP:
18127 
        break
18128 
      if fid == 0:
18129 
        if ftype == TType.LIST:
18130 
          self.success = []
6188 rajveer 18131 
          (_etype435, _size432) = iprot.readListBegin()
18132 
          for _i436 in xrange(_size432):
18133 
            _elem437 = Order()
18134 
            _elem437.read(iprot)
18135 
            self.success.append(_elem437)
4741 phani.kuma 18136 
          iprot.readListEnd()
18137 
        else:
18138 
          iprot.skip(ftype)
18139 
      else:
18140 
        iprot.skip(ftype)
18141 
      iprot.readFieldEnd()
18142 
    iprot.readStructEnd()
18143 
 
18144 
  def write(self, oprot):
18145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18147 
      return
4910 phani.kuma 18148 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18149 
    if self.success is not None:
18150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18152 
      for iter438 in self.success:
18153 
        iter438.write(oprot)
4741 phani.kuma 18154 
      oprot.writeListEnd()
18155 
      oprot.writeFieldEnd()
18156 
    oprot.writeFieldStop()
18157 
    oprot.writeStructEnd()
18158 
 
18159 
  def validate(self):
18160 
    return
18161 
 
18162 
 
18163 
  def __repr__(self):
18164 
    L = ['%s=%r' % (key, value)
18165 
      for key, value in self.__dict__.iteritems()]
18166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18167 
 
18168 
  def __eq__(self, other):
18169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18170 
 
18171 
  def __ne__(self, other):
18172 
    return not (self == other)
18173 
 
2616 chandransh 18174 
class receiveReturn_args:
2591 chandransh 18175 
  """
18176 
  Attributes:
18177 
   - orderId
4479 rajveer 18178 
   - receiveCondition
2591 chandransh 18179 
  """
2536 chandransh 18180 
 
2591 chandransh 18181 
  thrift_spec = (
18182 
    None, # 0
18183 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18184 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18185 
  )
18186 
 
4479 rajveer 18187 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18188 
    self.orderId = orderId
4479 rajveer 18189 
    self.receiveCondition = receiveCondition
2591 chandransh 18190 
 
18191 
  def read(self, iprot):
18192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18194 
      return
18195 
    iprot.readStructBegin()
18196 
    while True:
18197 
      (fname, ftype, fid) = iprot.readFieldBegin()
18198 
      if ftype == TType.STOP:
18199 
        break
18200 
      if fid == 1:
18201 
        if ftype == TType.I64:
18202 
          self.orderId = iprot.readI64();
18203 
        else:
18204 
          iprot.skip(ftype)
4479 rajveer 18205 
      elif fid == 2:
18206 
        if ftype == TType.I64:
18207 
          self.receiveCondition = iprot.readI64();
18208 
        else:
18209 
          iprot.skip(ftype)
2591 chandransh 18210 
      else:
18211 
        iprot.skip(ftype)
18212 
      iprot.readFieldEnd()
18213 
    iprot.readStructEnd()
18214 
 
18215 
  def write(self, oprot):
18216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18218 
      return
2616 chandransh 18219 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18220 
    if self.orderId is not None:
2591 chandransh 18221 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18222 
      oprot.writeI64(self.orderId)
18223 
      oprot.writeFieldEnd()
4479 rajveer 18224 
    if self.receiveCondition is not None:
18225 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18226 
      oprot.writeI64(self.receiveCondition)
18227 
      oprot.writeFieldEnd()
2591 chandransh 18228 
    oprot.writeFieldStop()
18229 
    oprot.writeStructEnd()
18230 
 
3431 rajveer 18231 
  def validate(self):
18232 
    return
18233 
 
18234 
 
2591 chandransh 18235 
  def __repr__(self):
18236 
    L = ['%s=%r' % (key, value)
18237 
      for key, value in self.__dict__.iteritems()]
18238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18239 
 
18240 
  def __eq__(self, other):
18241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18242 
 
18243 
  def __ne__(self, other):
18244 
    return not (self == other)
18245 
 
2616 chandransh 18246 
class receiveReturn_result:
2591 chandransh 18247 
  """
18248 
  Attributes:
18249 
   - success
18250 
   - ex
18251 
  """
18252 
 
18253 
  thrift_spec = (
18254 
    (0, TType.BOOL, 'success', None, None, ), # 0
18255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18256 
  )
18257 
 
18258 
  def __init__(self, success=None, ex=None,):
18259 
    self.success = success
18260 
    self.ex = ex
18261 
 
18262 
  def read(self, iprot):
18263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18265 
      return
18266 
    iprot.readStructBegin()
18267 
    while True:
18268 
      (fname, ftype, fid) = iprot.readFieldBegin()
18269 
      if ftype == TType.STOP:
18270 
        break
18271 
      if fid == 0:
18272 
        if ftype == TType.BOOL:
18273 
          self.success = iprot.readBool();
18274 
        else:
18275 
          iprot.skip(ftype)
18276 
      elif fid == 1:
18277 
        if ftype == TType.STRUCT:
18278 
          self.ex = TransactionServiceException()
18279 
          self.ex.read(iprot)
18280 
        else:
18281 
          iprot.skip(ftype)
18282 
      else:
18283 
        iprot.skip(ftype)
18284 
      iprot.readFieldEnd()
18285 
    iprot.readStructEnd()
18286 
 
18287 
  def write(self, oprot):
18288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18290 
      return
2616 chandransh 18291 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18292 
    if self.success is not None:
2591 chandransh 18293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18294 
      oprot.writeBool(self.success)
18295 
      oprot.writeFieldEnd()
3431 rajveer 18296 
    if self.ex is not None:
2591 chandransh 18297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18298 
      self.ex.write(oprot)
18299 
      oprot.writeFieldEnd()
18300 
    oprot.writeFieldStop()
18301 
    oprot.writeStructEnd()
18302 
 
3431 rajveer 18303 
  def validate(self):
18304 
    return
18305 
 
18306 
 
2591 chandransh 18307 
  def __repr__(self):
18308 
    L = ['%s=%r' % (key, value)
18309 
      for key, value in self.__dict__.iteritems()]
18310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18311 
 
18312 
  def __eq__(self, other):
18313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18314 
 
18315 
  def __ne__(self, other):
18316 
    return not (self == other)
18317 
 
18318 
class validateDoa_args:
18319 
  """
18320 
  Attributes:
18321 
   - orderId
18322 
   - isValid
18323 
  """
18324 
 
18325 
  thrift_spec = (
18326 
    None, # 0
18327 
    (1, TType.I64, 'orderId', None, None, ), # 1
18328 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18329 
  )
18330 
 
18331 
  def __init__(self, orderId=None, isValid=None,):
18332 
    self.orderId = orderId
18333 
    self.isValid = isValid
18334 
 
18335 
  def read(self, iprot):
18336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18338 
      return
18339 
    iprot.readStructBegin()
18340 
    while True:
18341 
      (fname, ftype, fid) = iprot.readFieldBegin()
18342 
      if ftype == TType.STOP:
18343 
        break
18344 
      if fid == 1:
18345 
        if ftype == TType.I64:
18346 
          self.orderId = iprot.readI64();
18347 
        else:
18348 
          iprot.skip(ftype)
18349 
      elif fid == 2:
18350 
        if ftype == TType.BOOL:
18351 
          self.isValid = iprot.readBool();
18352 
        else:
18353 
          iprot.skip(ftype)
18354 
      else:
18355 
        iprot.skip(ftype)
18356 
      iprot.readFieldEnd()
18357 
    iprot.readStructEnd()
18358 
 
18359 
  def write(self, oprot):
18360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18362 
      return
18363 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18364 
    if self.orderId is not None:
2591 chandransh 18365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18366 
      oprot.writeI64(self.orderId)
18367 
      oprot.writeFieldEnd()
3431 rajveer 18368 
    if self.isValid is not None:
2591 chandransh 18369 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18370 
      oprot.writeBool(self.isValid)
18371 
      oprot.writeFieldEnd()
18372 
    oprot.writeFieldStop()
18373 
    oprot.writeStructEnd()
18374 
 
3431 rajveer 18375 
  def validate(self):
18376 
    return
18377 
 
18378 
 
2591 chandransh 18379 
  def __repr__(self):
18380 
    L = ['%s=%r' % (key, value)
18381 
      for key, value in self.__dict__.iteritems()]
18382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18383 
 
18384 
  def __eq__(self, other):
18385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18386 
 
18387 
  def __ne__(self, other):
18388 
    return not (self == other)
18389 
 
18390 
class validateDoa_result:
18391 
  """
18392 
  Attributes:
18393 
   - success
18394 
   - ex
18395 
  """
18396 
 
18397 
  thrift_spec = (
18398 
    (0, TType.BOOL, 'success', None, None, ), # 0
18399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18400 
  )
18401 
 
18402 
  def __init__(self, success=None, ex=None,):
18403 
    self.success = success
18404 
    self.ex = ex
18405 
 
18406 
  def read(self, iprot):
18407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18409 
      return
18410 
    iprot.readStructBegin()
18411 
    while True:
18412 
      (fname, ftype, fid) = iprot.readFieldBegin()
18413 
      if ftype == TType.STOP:
18414 
        break
18415 
      if fid == 0:
18416 
        if ftype == TType.BOOL:
18417 
          self.success = iprot.readBool();
18418 
        else:
18419 
          iprot.skip(ftype)
18420 
      elif fid == 1:
18421 
        if ftype == TType.STRUCT:
18422 
          self.ex = TransactionServiceException()
18423 
          self.ex.read(iprot)
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      else:
18427 
        iprot.skip(ftype)
18428 
      iprot.readFieldEnd()
18429 
    iprot.readStructEnd()
18430 
 
18431 
  def write(self, oprot):
18432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18434 
      return
18435 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18436 
    if self.success is not None:
2591 chandransh 18437 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18438 
      oprot.writeBool(self.success)
18439 
      oprot.writeFieldEnd()
3431 rajveer 18440 
    if self.ex is not None:
2591 chandransh 18441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18442 
      self.ex.write(oprot)
18443 
      oprot.writeFieldEnd()
18444 
    oprot.writeFieldStop()
18445 
    oprot.writeStructEnd()
18446 
 
3431 rajveer 18447 
  def validate(self):
18448 
    return
18449 
 
18450 
 
2591 chandransh 18451 
  def __repr__(self):
18452 
    L = ['%s=%r' % (key, value)
18453 
      for key, value in self.__dict__.iteritems()]
18454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18455 
 
18456 
  def __eq__(self, other):
18457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18458 
 
18459 
  def __ne__(self, other):
18460 
    return not (self == other)
18461 
 
4495 rajveer 18462 
class validateReturnProduct_args:
18463 
  """
18464 
  Attributes:
18465 
   - orderId
18466 
   - isUsable
18467 
  """
18468 
 
18469 
  thrift_spec = (
18470 
    None, # 0
18471 
    (1, TType.I64, 'orderId', None, None, ), # 1
18472 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18473 
  )
18474 
 
18475 
  def __init__(self, orderId=None, isUsable=None,):
18476 
    self.orderId = orderId
18477 
    self.isUsable = isUsable
18478 
 
18479 
  def read(self, iprot):
18480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18482 
      return
18483 
    iprot.readStructBegin()
18484 
    while True:
18485 
      (fname, ftype, fid) = iprot.readFieldBegin()
18486 
      if ftype == TType.STOP:
18487 
        break
18488 
      if fid == 1:
18489 
        if ftype == TType.I64:
18490 
          self.orderId = iprot.readI64();
18491 
        else:
18492 
          iprot.skip(ftype)
18493 
      elif fid == 2:
18494 
        if ftype == TType.BOOL:
18495 
          self.isUsable = iprot.readBool();
18496 
        else:
18497 
          iprot.skip(ftype)
18498 
      else:
18499 
        iprot.skip(ftype)
18500 
      iprot.readFieldEnd()
18501 
    iprot.readStructEnd()
18502 
 
18503 
  def write(self, oprot):
18504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18506 
      return
18507 
    oprot.writeStructBegin('validateReturnProduct_args')
18508 
    if self.orderId is not None:
18509 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18510 
      oprot.writeI64(self.orderId)
18511 
      oprot.writeFieldEnd()
18512 
    if self.isUsable is not None:
18513 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18514 
      oprot.writeBool(self.isUsable)
18515 
      oprot.writeFieldEnd()
18516 
    oprot.writeFieldStop()
18517 
    oprot.writeStructEnd()
18518 
 
18519 
  def validate(self):
18520 
    return
18521 
 
18522 
 
18523 
  def __repr__(self):
18524 
    L = ['%s=%r' % (key, value)
18525 
      for key, value in self.__dict__.iteritems()]
18526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18527 
 
18528 
  def __eq__(self, other):
18529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18530 
 
18531 
  def __ne__(self, other):
18532 
    return not (self == other)
18533 
 
18534 
class validateReturnProduct_result:
18535 
  """
18536 
  Attributes:
18537 
   - success
18538 
   - ex
18539 
  """
18540 
 
18541 
  thrift_spec = (
18542 
    (0, TType.BOOL, 'success', None, None, ), # 0
18543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18544 
  )
18545 
 
18546 
  def __init__(self, success=None, ex=None,):
18547 
    self.success = success
18548 
    self.ex = ex
18549 
 
18550 
  def read(self, iprot):
18551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18553 
      return
18554 
    iprot.readStructBegin()
18555 
    while True:
18556 
      (fname, ftype, fid) = iprot.readFieldBegin()
18557 
      if ftype == TType.STOP:
18558 
        break
18559 
      if fid == 0:
18560 
        if ftype == TType.BOOL:
18561 
          self.success = iprot.readBool();
18562 
        else:
18563 
          iprot.skip(ftype)
18564 
      elif fid == 1:
18565 
        if ftype == TType.STRUCT:
18566 
          self.ex = TransactionServiceException()
18567 
          self.ex.read(iprot)
18568 
        else:
18569 
          iprot.skip(ftype)
18570 
      else:
18571 
        iprot.skip(ftype)
18572 
      iprot.readFieldEnd()
18573 
    iprot.readStructEnd()
18574 
 
18575 
  def write(self, oprot):
18576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18578 
      return
18579 
    oprot.writeStructBegin('validateReturnProduct_result')
18580 
    if self.success is not None:
18581 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18582 
      oprot.writeBool(self.success)
18583 
      oprot.writeFieldEnd()
18584 
    if self.ex is not None:
18585 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18586 
      self.ex.write(oprot)
18587 
      oprot.writeFieldEnd()
18588 
    oprot.writeFieldStop()
18589 
    oprot.writeStructEnd()
18590 
 
18591 
  def validate(self):
18592 
    return
18593 
 
18594 
 
18595 
  def __repr__(self):
18596 
    L = ['%s=%r' % (key, value)
18597 
      for key, value in self.__dict__.iteritems()]
18598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18599 
 
18600 
  def __eq__(self, other):
18601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18602 
 
18603 
  def __ne__(self, other):
18604 
    return not (self == other)
18605 
 
2616 chandransh 18606 
class reshipOrder_args:
18607 
  """
18608 
  Attributes:
18609 
   - orderId
18610 
  """
2591 chandransh 18611 
 
2616 chandransh 18612 
  thrift_spec = (
18613 
    None, # 0
18614 
    (1, TType.I64, 'orderId', None, None, ), # 1
18615 
  )
18616 
 
18617 
  def __init__(self, orderId=None,):
18618 
    self.orderId = orderId
18619 
 
18620 
  def read(self, iprot):
18621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18623 
      return
18624 
    iprot.readStructBegin()
18625 
    while True:
18626 
      (fname, ftype, fid) = iprot.readFieldBegin()
18627 
      if ftype == TType.STOP:
18628 
        break
18629 
      if fid == 1:
18630 
        if ftype == TType.I64:
18631 
          self.orderId = iprot.readI64();
18632 
        else:
18633 
          iprot.skip(ftype)
18634 
      else:
18635 
        iprot.skip(ftype)
18636 
      iprot.readFieldEnd()
18637 
    iprot.readStructEnd()
18638 
 
18639 
  def write(self, oprot):
18640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18642 
      return
18643 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18644 
    if self.orderId is not None:
2616 chandransh 18645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18646 
      oprot.writeI64(self.orderId)
18647 
      oprot.writeFieldEnd()
18648 
    oprot.writeFieldStop()
18649 
    oprot.writeStructEnd()
18650 
 
3431 rajveer 18651 
  def validate(self):
18652 
    return
18653 
 
18654 
 
2616 chandransh 18655 
  def __repr__(self):
18656 
    L = ['%s=%r' % (key, value)
18657 
      for key, value in self.__dict__.iteritems()]
18658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18659 
 
18660 
  def __eq__(self, other):
18661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18662 
 
18663 
  def __ne__(self, other):
18664 
    return not (self == other)
18665 
 
18666 
class reshipOrder_result:
18667 
  """
18668 
  Attributes:
18669 
   - success
18670 
   - ex
18671 
  """
18672 
 
18673 
  thrift_spec = (
18674 
    (0, TType.I64, 'success', None, None, ), # 0
18675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18676 
  )
18677 
 
18678 
  def __init__(self, success=None, ex=None,):
18679 
    self.success = success
18680 
    self.ex = ex
18681 
 
18682 
  def read(self, iprot):
18683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18685 
      return
18686 
    iprot.readStructBegin()
18687 
    while True:
18688 
      (fname, ftype, fid) = iprot.readFieldBegin()
18689 
      if ftype == TType.STOP:
18690 
        break
18691 
      if fid == 0:
18692 
        if ftype == TType.I64:
18693 
          self.success = iprot.readI64();
18694 
        else:
18695 
          iprot.skip(ftype)
18696 
      elif fid == 1:
18697 
        if ftype == TType.STRUCT:
18698 
          self.ex = TransactionServiceException()
18699 
          self.ex.read(iprot)
18700 
        else:
18701 
          iprot.skip(ftype)
18702 
      else:
18703 
        iprot.skip(ftype)
18704 
      iprot.readFieldEnd()
18705 
    iprot.readStructEnd()
18706 
 
18707 
  def write(self, oprot):
18708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18710 
      return
18711 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18712 
    if self.success is not None:
2616 chandransh 18713 
      oprot.writeFieldBegin('success', TType.I64, 0)
18714 
      oprot.writeI64(self.success)
18715 
      oprot.writeFieldEnd()
3431 rajveer 18716 
    if self.ex is not None:
2616 chandransh 18717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18718 
      self.ex.write(oprot)
18719 
      oprot.writeFieldEnd()
18720 
    oprot.writeFieldStop()
18721 
    oprot.writeStructEnd()
18722 
 
3431 rajveer 18723 
  def validate(self):
18724 
    return
18725 
 
18726 
 
2616 chandransh 18727 
  def __repr__(self):
18728 
    L = ['%s=%r' % (key, value)
18729 
      for key, value in self.__dict__.iteritems()]
18730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18731 
 
18732 
  def __eq__(self, other):
18733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18734 
 
18735 
  def __ne__(self, other):
18736 
    return not (self == other)
18737 
 
18738 
class refundOrder_args:
18739 
  """
18740 
  Attributes:
18741 
   - orderId
3226 chandransh 18742 
   - refundedBy
18743 
   - reason
2616 chandransh 18744 
  """
18745 
 
18746 
  thrift_spec = (
18747 
    None, # 0
18748 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18749 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18750 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18751 
  )
18752 
 
3226 chandransh 18753 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18754 
    self.orderId = orderId
3226 chandransh 18755 
    self.refundedBy = refundedBy
18756 
    self.reason = reason
2616 chandransh 18757 
 
18758 
  def read(self, iprot):
18759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18761 
      return
18762 
    iprot.readStructBegin()
18763 
    while True:
18764 
      (fname, ftype, fid) = iprot.readFieldBegin()
18765 
      if ftype == TType.STOP:
18766 
        break
18767 
      if fid == 1:
18768 
        if ftype == TType.I64:
18769 
          self.orderId = iprot.readI64();
18770 
        else:
18771 
          iprot.skip(ftype)
3226 chandransh 18772 
      elif fid == 2:
18773 
        if ftype == TType.STRING:
18774 
          self.refundedBy = iprot.readString();
18775 
        else:
18776 
          iprot.skip(ftype)
18777 
      elif fid == 3:
18778 
        if ftype == TType.STRING:
18779 
          self.reason = iprot.readString();
18780 
        else:
18781 
          iprot.skip(ftype)
2616 chandransh 18782 
      else:
18783 
        iprot.skip(ftype)
18784 
      iprot.readFieldEnd()
18785 
    iprot.readStructEnd()
18786 
 
18787 
  def write(self, oprot):
18788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18790 
      return
18791 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18792 
    if self.orderId is not None:
2616 chandransh 18793 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18794 
      oprot.writeI64(self.orderId)
18795 
      oprot.writeFieldEnd()
3431 rajveer 18796 
    if self.refundedBy is not None:
3226 chandransh 18797 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18798 
      oprot.writeString(self.refundedBy)
18799 
      oprot.writeFieldEnd()
3431 rajveer 18800 
    if self.reason is not None:
3226 chandransh 18801 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18802 
      oprot.writeString(self.reason)
18803 
      oprot.writeFieldEnd()
2616 chandransh 18804 
    oprot.writeFieldStop()
18805 
    oprot.writeStructEnd()
18806 
 
3431 rajveer 18807 
  def validate(self):
18808 
    return
18809 
 
18810 
 
2616 chandransh 18811 
  def __repr__(self):
18812 
    L = ['%s=%r' % (key, value)
18813 
      for key, value in self.__dict__.iteritems()]
18814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18815 
 
18816 
  def __eq__(self, other):
18817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18818 
 
18819 
  def __ne__(self, other):
18820 
    return not (self == other)
18821 
 
18822 
class refundOrder_result:
18823 
  """
18824 
  Attributes:
18825 
   - success
18826 
   - ex
18827 
  """
18828 
 
18829 
  thrift_spec = (
18830 
    (0, TType.BOOL, 'success', None, None, ), # 0
18831 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18832 
  )
18833 
 
18834 
  def __init__(self, success=None, ex=None,):
18835 
    self.success = success
18836 
    self.ex = ex
18837 
 
18838 
  def read(self, iprot):
18839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18841 
      return
18842 
    iprot.readStructBegin()
18843 
    while True:
18844 
      (fname, ftype, fid) = iprot.readFieldBegin()
18845 
      if ftype == TType.STOP:
18846 
        break
18847 
      if fid == 0:
18848 
        if ftype == TType.BOOL:
18849 
          self.success = iprot.readBool();
18850 
        else:
18851 
          iprot.skip(ftype)
18852 
      elif fid == 1:
18853 
        if ftype == TType.STRUCT:
18854 
          self.ex = TransactionServiceException()
18855 
          self.ex.read(iprot)
18856 
        else:
18857 
          iprot.skip(ftype)
18858 
      else:
18859 
        iprot.skip(ftype)
18860 
      iprot.readFieldEnd()
18861 
    iprot.readStructEnd()
18862 
 
18863 
  def write(self, oprot):
18864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18866 
      return
18867 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18868 
    if self.success is not None:
2616 chandransh 18869 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18870 
      oprot.writeBool(self.success)
18871 
      oprot.writeFieldEnd()
3431 rajveer 18872 
    if self.ex is not None:
2616 chandransh 18873 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18874 
      self.ex.write(oprot)
18875 
      oprot.writeFieldEnd()
18876 
    oprot.writeFieldStop()
18877 
    oprot.writeStructEnd()
18878 
 
3431 rajveer 18879 
  def validate(self):
18880 
    return
18881 
 
18882 
 
2616 chandransh 18883 
  def __repr__(self):
18884 
    L = ['%s=%r' % (key, value)
18885 
      for key, value in self.__dict__.iteritems()]
18886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18887 
 
18888 
  def __eq__(self, other):
18889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18890 
 
18891 
  def __ne__(self, other):
18892 
    return not (self == other)
18893 
 
2690 chandransh 18894 
class getReturnOrders_args:
18895 
  """
18896 
  Attributes:
18897 
   - warehouseId
18898 
   - fromDate
18899 
   - toDate
18900 
  """
2616 chandransh 18901 
 
2690 chandransh 18902 
  thrift_spec = (
18903 
    None, # 0
18904 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18905 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18906 
    (3, TType.I64, 'toDate', None, None, ), # 3
18907 
  )
18908 
 
18909 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18910 
    self.warehouseId = warehouseId
18911 
    self.fromDate = fromDate
18912 
    self.toDate = toDate
18913 
 
18914 
  def read(self, iprot):
18915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18917 
      return
18918 
    iprot.readStructBegin()
18919 
    while True:
18920 
      (fname, ftype, fid) = iprot.readFieldBegin()
18921 
      if ftype == TType.STOP:
18922 
        break
18923 
      if fid == 1:
18924 
        if ftype == TType.I64:
18925 
          self.warehouseId = iprot.readI64();
18926 
        else:
18927 
          iprot.skip(ftype)
18928 
      elif fid == 2:
18929 
        if ftype == TType.I64:
18930 
          self.fromDate = iprot.readI64();
18931 
        else:
18932 
          iprot.skip(ftype)
18933 
      elif fid == 3:
18934 
        if ftype == TType.I64:
18935 
          self.toDate = iprot.readI64();
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      else:
18939 
        iprot.skip(ftype)
18940 
      iprot.readFieldEnd()
18941 
    iprot.readStructEnd()
18942 
 
18943 
  def write(self, oprot):
18944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18946 
      return
18947 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18948 
    if self.warehouseId is not None:
2690 chandransh 18949 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18950 
      oprot.writeI64(self.warehouseId)
18951 
      oprot.writeFieldEnd()
3431 rajveer 18952 
    if self.fromDate is not None:
2690 chandransh 18953 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18954 
      oprot.writeI64(self.fromDate)
18955 
      oprot.writeFieldEnd()
3431 rajveer 18956 
    if self.toDate is not None:
2690 chandransh 18957 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18958 
      oprot.writeI64(self.toDate)
18959 
      oprot.writeFieldEnd()
18960 
    oprot.writeFieldStop()
18961 
    oprot.writeStructEnd()
18962 
 
3431 rajveer 18963 
  def validate(self):
18964 
    return
18965 
 
18966 
 
2690 chandransh 18967 
  def __repr__(self):
18968 
    L = ['%s=%r' % (key, value)
18969 
      for key, value in self.__dict__.iteritems()]
18970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18971 
 
18972 
  def __eq__(self, other):
18973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18974 
 
18975 
  def __ne__(self, other):
18976 
    return not (self == other)
18977 
 
18978 
class getReturnOrders_result:
18979 
  """
18980 
  Attributes:
18981 
   - success
18982 
  """
18983 
 
18984 
  thrift_spec = (
18985 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18986 
  )
18987 
 
18988 
  def __init__(self, success=None,):
18989 
    self.success = success
18990 
 
18991 
  def read(self, iprot):
18992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18994 
      return
18995 
    iprot.readStructBegin()
18996 
    while True:
18997 
      (fname, ftype, fid) = iprot.readFieldBegin()
18998 
      if ftype == TType.STOP:
18999 
        break
19000 
      if fid == 0:
19001 
        if ftype == TType.LIST:
19002 
          self.success = []
6188 rajveer 19003 
          (_etype442, _size439) = iprot.readListBegin()
19004 
          for _i443 in xrange(_size439):
19005 
            _elem444 = ReturnOrder()
19006 
            _elem444.read(iprot)
19007 
            self.success.append(_elem444)
2690 chandransh 19008 
          iprot.readListEnd()
19009 
        else:
19010 
          iprot.skip(ftype)
19011 
      else:
19012 
        iprot.skip(ftype)
19013 
      iprot.readFieldEnd()
19014 
    iprot.readStructEnd()
19015 
 
19016 
  def write(self, oprot):
19017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19019 
      return
19020 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19021 
    if self.success is not None:
2690 chandransh 19022 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19023 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19024 
      for iter445 in self.success:
19025 
        iter445.write(oprot)
2690 chandransh 19026 
      oprot.writeListEnd()
19027 
      oprot.writeFieldEnd()
19028 
    oprot.writeFieldStop()
19029 
    oprot.writeStructEnd()
19030 
 
3431 rajveer 19031 
  def validate(self):
19032 
    return
19033 
 
19034 
 
2690 chandransh 19035 
  def __repr__(self):
19036 
    L = ['%s=%r' % (key, value)
19037 
      for key, value in self.__dict__.iteritems()]
19038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19039 
 
19040 
  def __eq__(self, other):
19041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19042 
 
19043 
  def __ne__(self, other):
19044 
    return not (self == other)
19045 
 
5481 phani.kuma 19046 
class getAllReturnOrders_args:
19047 
  """
19048 
  Attributes:
19049 
   - onlyNotProcessed
19050 
   - fromDate
19051 
   - toDate
19052 
  """
19053 
 
19054 
  thrift_spec = (
19055 
    None, # 0
19056 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19057 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19058 
    (3, TType.I64, 'toDate', None, None, ), # 3
19059 
  )
19060 
 
19061 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19062 
    self.onlyNotProcessed = onlyNotProcessed
19063 
    self.fromDate = fromDate
19064 
    self.toDate = toDate
19065 
 
19066 
  def read(self, iprot):
19067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19069 
      return
19070 
    iprot.readStructBegin()
19071 
    while True:
19072 
      (fname, ftype, fid) = iprot.readFieldBegin()
19073 
      if ftype == TType.STOP:
19074 
        break
19075 
      if fid == 1:
19076 
        if ftype == TType.BOOL:
19077 
          self.onlyNotProcessed = iprot.readBool();
19078 
        else:
19079 
          iprot.skip(ftype)
19080 
      elif fid == 2:
19081 
        if ftype == TType.I64:
19082 
          self.fromDate = iprot.readI64();
19083 
        else:
19084 
          iprot.skip(ftype)
19085 
      elif fid == 3:
19086 
        if ftype == TType.I64:
19087 
          self.toDate = iprot.readI64();
19088 
        else:
19089 
          iprot.skip(ftype)
19090 
      else:
19091 
        iprot.skip(ftype)
19092 
      iprot.readFieldEnd()
19093 
    iprot.readStructEnd()
19094 
 
19095 
  def write(self, oprot):
19096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19098 
      return
19099 
    oprot.writeStructBegin('getAllReturnOrders_args')
19100 
    if self.onlyNotProcessed is not None:
19101 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19102 
      oprot.writeBool(self.onlyNotProcessed)
19103 
      oprot.writeFieldEnd()
19104 
    if self.fromDate is not None:
19105 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19106 
      oprot.writeI64(self.fromDate)
19107 
      oprot.writeFieldEnd()
19108 
    if self.toDate is not None:
19109 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19110 
      oprot.writeI64(self.toDate)
19111 
      oprot.writeFieldEnd()
19112 
    oprot.writeFieldStop()
19113 
    oprot.writeStructEnd()
19114 
 
19115 
  def validate(self):
19116 
    return
19117 
 
19118 
 
19119 
  def __repr__(self):
19120 
    L = ['%s=%r' % (key, value)
19121 
      for key, value in self.__dict__.iteritems()]
19122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19123 
 
19124 
  def __eq__(self, other):
19125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19126 
 
19127 
  def __ne__(self, other):
19128 
    return not (self == other)
19129 
 
19130 
class getAllReturnOrders_result:
19131 
  """
19132 
  Attributes:
19133 
   - success
19134 
  """
19135 
 
19136 
  thrift_spec = (
19137 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19138 
  )
19139 
 
19140 
  def __init__(self, success=None,):
19141 
    self.success = success
19142 
 
19143 
  def read(self, iprot):
19144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19146 
      return
19147 
    iprot.readStructBegin()
19148 
    while True:
19149 
      (fname, ftype, fid) = iprot.readFieldBegin()
19150 
      if ftype == TType.STOP:
19151 
        break
19152 
      if fid == 0:
19153 
        if ftype == TType.LIST:
19154 
          self.success = []
6188 rajveer 19155 
          (_etype449, _size446) = iprot.readListBegin()
19156 
          for _i450 in xrange(_size446):
19157 
            _elem451 = ReturnOrder()
19158 
            _elem451.read(iprot)
19159 
            self.success.append(_elem451)
5481 phani.kuma 19160 
          iprot.readListEnd()
19161 
        else:
19162 
          iprot.skip(ftype)
19163 
      else:
19164 
        iprot.skip(ftype)
19165 
      iprot.readFieldEnd()
19166 
    iprot.readStructEnd()
19167 
 
19168 
  def write(self, oprot):
19169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19171 
      return
19172 
    oprot.writeStructBegin('getAllReturnOrders_result')
19173 
    if self.success is not None:
19174 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19175 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19176 
      for iter452 in self.success:
19177 
        iter452.write(oprot)
5481 phani.kuma 19178 
      oprot.writeListEnd()
19179 
      oprot.writeFieldEnd()
19180 
    oprot.writeFieldStop()
19181 
    oprot.writeStructEnd()
19182 
 
19183 
  def validate(self):
19184 
    return
19185 
 
19186 
 
19187 
  def __repr__(self):
19188 
    L = ['%s=%r' % (key, value)
19189 
      for key, value in self.__dict__.iteritems()]
19190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19191 
 
19192 
  def __eq__(self, other):
19193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19194 
 
19195 
  def __ne__(self, other):
19196 
    return not (self == other)
19197 
 
2700 chandransh 19198 
class getReturnOrder_args:
19199 
  """
19200 
  Attributes:
19201 
   - id
19202 
  """
19203 
 
19204 
  thrift_spec = (
19205 
    None, # 0
19206 
    (1, TType.I64, 'id', None, None, ), # 1
19207 
  )
19208 
 
19209 
  def __init__(self, id=None,):
19210 
    self.id = id
19211 
 
19212 
  def read(self, iprot):
19213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19215 
      return
19216 
    iprot.readStructBegin()
19217 
    while True:
19218 
      (fname, ftype, fid) = iprot.readFieldBegin()
19219 
      if ftype == TType.STOP:
19220 
        break
19221 
      if fid == 1:
19222 
        if ftype == TType.I64:
19223 
          self.id = iprot.readI64();
19224 
        else:
19225 
          iprot.skip(ftype)
19226 
      else:
19227 
        iprot.skip(ftype)
19228 
      iprot.readFieldEnd()
19229 
    iprot.readStructEnd()
19230 
 
19231 
  def write(self, oprot):
19232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19234 
      return
19235 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19236 
    if self.id is not None:
2700 chandransh 19237 
      oprot.writeFieldBegin('id', TType.I64, 1)
19238 
      oprot.writeI64(self.id)
19239 
      oprot.writeFieldEnd()
19240 
    oprot.writeFieldStop()
19241 
    oprot.writeStructEnd()
19242 
 
3431 rajveer 19243 
  def validate(self):
19244 
    return
19245 
 
19246 
 
2700 chandransh 19247 
  def __repr__(self):
19248 
    L = ['%s=%r' % (key, value)
19249 
      for key, value in self.__dict__.iteritems()]
19250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19251 
 
19252 
  def __eq__(self, other):
19253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19254 
 
19255 
  def __ne__(self, other):
19256 
    return not (self == other)
19257 
 
19258 
class getReturnOrder_result:
19259 
  """
19260 
  Attributes:
19261 
   - success
19262 
   - ex
19263 
  """
19264 
 
19265 
  thrift_spec = (
19266 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19268 
  )
19269 
 
19270 
  def __init__(self, success=None, ex=None,):
19271 
    self.success = success
19272 
    self.ex = ex
19273 
 
19274 
  def read(self, iprot):
19275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19277 
      return
19278 
    iprot.readStructBegin()
19279 
    while True:
19280 
      (fname, ftype, fid) = iprot.readFieldBegin()
19281 
      if ftype == TType.STOP:
19282 
        break
19283 
      if fid == 0:
19284 
        if ftype == TType.STRUCT:
19285 
          self.success = ReturnOrder()
19286 
          self.success.read(iprot)
19287 
        else:
19288 
          iprot.skip(ftype)
19289 
      elif fid == 1:
19290 
        if ftype == TType.STRUCT:
19291 
          self.ex = TransactionServiceException()
19292 
          self.ex.read(iprot)
19293 
        else:
19294 
          iprot.skip(ftype)
19295 
      else:
19296 
        iprot.skip(ftype)
19297 
      iprot.readFieldEnd()
19298 
    iprot.readStructEnd()
19299 
 
19300 
  def write(self, oprot):
19301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19303 
      return
19304 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19305 
    if self.success is not None:
2700 chandransh 19306 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19307 
      self.success.write(oprot)
19308 
      oprot.writeFieldEnd()
3431 rajveer 19309 
    if self.ex is not None:
2700 chandransh 19310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19311 
      self.ex.write(oprot)
19312 
      oprot.writeFieldEnd()
19313 
    oprot.writeFieldStop()
19314 
    oprot.writeStructEnd()
19315 
 
3431 rajveer 19316 
  def validate(self):
19317 
    return
19318 
 
19319 
 
2700 chandransh 19320 
  def __repr__(self):
19321 
    L = ['%s=%r' % (key, value)
19322 
      for key, value in self.__dict__.iteritems()]
19323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19324 
 
19325 
  def __eq__(self, other):
19326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19327 
 
19328 
  def __ne__(self, other):
19329 
    return not (self == other)
19330 
 
2690 chandransh 19331 
class processReturn_args:
19332 
  """
19333 
  Attributes:
19334 
   - returnOrderId
19335 
  """
19336 
 
19337 
  thrift_spec = (
19338 
    None, # 0
19339 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19340 
  )
19341 
 
19342 
  def __init__(self, returnOrderId=None,):
19343 
    self.returnOrderId = returnOrderId
19344 
 
19345 
  def read(self, iprot):
19346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19348 
      return
19349 
    iprot.readStructBegin()
19350 
    while True:
19351 
      (fname, ftype, fid) = iprot.readFieldBegin()
19352 
      if ftype == TType.STOP:
19353 
        break
19354 
      if fid == 1:
19355 
        if ftype == TType.I64:
19356 
          self.returnOrderId = iprot.readI64();
19357 
        else:
19358 
          iprot.skip(ftype)
19359 
      else:
19360 
        iprot.skip(ftype)
19361 
      iprot.readFieldEnd()
19362 
    iprot.readStructEnd()
19363 
 
19364 
  def write(self, oprot):
19365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19367 
      return
19368 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19369 
    if self.returnOrderId is not None:
2690 chandransh 19370 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19371 
      oprot.writeI64(self.returnOrderId)
19372 
      oprot.writeFieldEnd()
19373 
    oprot.writeFieldStop()
19374 
    oprot.writeStructEnd()
19375 
 
3431 rajveer 19376 
  def validate(self):
19377 
    return
19378 
 
19379 
 
2690 chandransh 19380 
  def __repr__(self):
19381 
    L = ['%s=%r' % (key, value)
19382 
      for key, value in self.__dict__.iteritems()]
19383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19384 
 
19385 
  def __eq__(self, other):
19386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19387 
 
19388 
  def __ne__(self, other):
19389 
    return not (self == other)
19390 
 
19391 
class processReturn_result:
19392 
  """
19393 
  Attributes:
19394 
   - ex
19395 
  """
19396 
 
19397 
  thrift_spec = (
19398 
    None, # 0
19399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19400 
  )
19401 
 
19402 
  def __init__(self, ex=None,):
19403 
    self.ex = ex
19404 
 
19405 
  def read(self, iprot):
19406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19408 
      return
19409 
    iprot.readStructBegin()
19410 
    while True:
19411 
      (fname, ftype, fid) = iprot.readFieldBegin()
19412 
      if ftype == TType.STOP:
19413 
        break
19414 
      if fid == 1:
19415 
        if ftype == TType.STRUCT:
19416 
          self.ex = TransactionServiceException()
19417 
          self.ex.read(iprot)
19418 
        else:
19419 
          iprot.skip(ftype)
19420 
      else:
19421 
        iprot.skip(ftype)
19422 
      iprot.readFieldEnd()
19423 
    iprot.readStructEnd()
19424 
 
19425 
  def write(self, oprot):
19426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19428 
      return
19429 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19430 
    if self.ex is not None:
2690 chandransh 19431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19432 
      self.ex.write(oprot)
19433 
      oprot.writeFieldEnd()
19434 
    oprot.writeFieldStop()
19435 
    oprot.writeStructEnd()
19436 
 
3431 rajveer 19437 
  def validate(self):
19438 
    return
19439 
 
19440 
 
2690 chandransh 19441 
  def __repr__(self):
19442 
    L = ['%s=%r' % (key, value)
19443 
      for key, value in self.__dict__.iteritems()]
19444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19445 
 
19446 
  def __eq__(self, other):
19447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19448 
 
19449 
  def __ne__(self, other):
19450 
    return not (self == other)
19451 
 
3451 chandransh 19452 
class updateWeight_args:
19453 
  """
19454 
  Attributes:
19455 
   - orderId
19456 
   - weight
19457 
  """
19458 
 
19459 
  thrift_spec = (
19460 
    None, # 0
19461 
    (1, TType.I64, 'orderId', None, None, ), # 1
19462 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19463 
  )
19464 
 
19465 
  def __init__(self, orderId=None, weight=None,):
19466 
    self.orderId = orderId
19467 
    self.weight = weight
19468 
 
19469 
  def read(self, iprot):
19470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19472 
      return
19473 
    iprot.readStructBegin()
19474 
    while True:
19475 
      (fname, ftype, fid) = iprot.readFieldBegin()
19476 
      if ftype == TType.STOP:
19477 
        break
19478 
      if fid == 1:
19479 
        if ftype == TType.I64:
19480 
          self.orderId = iprot.readI64();
19481 
        else:
19482 
          iprot.skip(ftype)
19483 
      elif fid == 2:
19484 
        if ftype == TType.DOUBLE:
19485 
          self.weight = iprot.readDouble();
19486 
        else:
19487 
          iprot.skip(ftype)
19488 
      else:
19489 
        iprot.skip(ftype)
19490 
      iprot.readFieldEnd()
19491 
    iprot.readStructEnd()
19492 
 
19493 
  def write(self, oprot):
19494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19496 
      return
19497 
    oprot.writeStructBegin('updateWeight_args')
19498 
    if self.orderId is not None:
19499 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19500 
      oprot.writeI64(self.orderId)
19501 
      oprot.writeFieldEnd()
19502 
    if self.weight is not None:
19503 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19504 
      oprot.writeDouble(self.weight)
19505 
      oprot.writeFieldEnd()
19506 
    oprot.writeFieldStop()
19507 
    oprot.writeStructEnd()
19508 
 
19509 
  def validate(self):
19510 
    return
19511 
 
19512 
 
19513 
  def __repr__(self):
19514 
    L = ['%s=%r' % (key, value)
19515 
      for key, value in self.__dict__.iteritems()]
19516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19517 
 
19518 
  def __eq__(self, other):
19519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19520 
 
19521 
  def __ne__(self, other):
19522 
    return not (self == other)
19523 
 
19524 
class updateWeight_result:
19525 
  """
19526 
  Attributes:
19527 
   - success
19528 
   - ex
19529 
  """
19530 
 
19531 
  thrift_spec = (
19532 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19533 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19534 
  )
19535 
 
19536 
  def __init__(self, success=None, ex=None,):
19537 
    self.success = success
19538 
    self.ex = ex
19539 
 
19540 
  def read(self, iprot):
19541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19543 
      return
19544 
    iprot.readStructBegin()
19545 
    while True:
19546 
      (fname, ftype, fid) = iprot.readFieldBegin()
19547 
      if ftype == TType.STOP:
19548 
        break
19549 
      if fid == 0:
19550 
        if ftype == TType.STRUCT:
19551 
          self.success = Order()
19552 
          self.success.read(iprot)
19553 
        else:
19554 
          iprot.skip(ftype)
19555 
      elif fid == 1:
19556 
        if ftype == TType.STRUCT:
19557 
          self.ex = TransactionServiceException()
19558 
          self.ex.read(iprot)
19559 
        else:
19560 
          iprot.skip(ftype)
19561 
      else:
19562 
        iprot.skip(ftype)
19563 
      iprot.readFieldEnd()
19564 
    iprot.readStructEnd()
19565 
 
19566 
  def write(self, oprot):
19567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19569 
      return
19570 
    oprot.writeStructBegin('updateWeight_result')
19571 
    if self.success is not None:
19572 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19573 
      self.success.write(oprot)
19574 
      oprot.writeFieldEnd()
19575 
    if self.ex is not None:
19576 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19577 
      self.ex.write(oprot)
19578 
      oprot.writeFieldEnd()
19579 
    oprot.writeFieldStop()
19580 
    oprot.writeStructEnd()
19581 
 
19582 
  def validate(self):
19583 
    return
19584 
 
19585 
 
19586 
  def __repr__(self):
19587 
    L = ['%s=%r' % (key, value)
19588 
      for key, value in self.__dict__.iteritems()]
19589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19590 
 
19591 
  def __eq__(self, other):
19592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19593 
 
19594 
  def __ne__(self, other):
19595 
    return not (self == other)
3469 chandransh 19596 
 
19597 
class changeItem_args:
19598 
  """
19599 
  Attributes:
19600 
   - orderId
19601 
   - itemId
19602 
  """
19603 
 
19604 
  thrift_spec = (
19605 
    None, # 0
19606 
    (1, TType.I64, 'orderId', None, None, ), # 1
19607 
    (2, TType.I64, 'itemId', None, None, ), # 2
19608 
  )
19609 
 
19610 
  def __init__(self, orderId=None, itemId=None,):
19611 
    self.orderId = orderId
19612 
    self.itemId = itemId
19613 
 
19614 
  def read(self, iprot):
19615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19617 
      return
19618 
    iprot.readStructBegin()
19619 
    while True:
19620 
      (fname, ftype, fid) = iprot.readFieldBegin()
19621 
      if ftype == TType.STOP:
19622 
        break
19623 
      if fid == 1:
19624 
        if ftype == TType.I64:
19625 
          self.orderId = iprot.readI64();
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      elif fid == 2:
19629 
        if ftype == TType.I64:
19630 
          self.itemId = iprot.readI64();
19631 
        else:
19632 
          iprot.skip(ftype)
19633 
      else:
19634 
        iprot.skip(ftype)
19635 
      iprot.readFieldEnd()
19636 
    iprot.readStructEnd()
19637 
 
19638 
  def write(self, oprot):
19639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19641 
      return
19642 
    oprot.writeStructBegin('changeItem_args')
19643 
    if self.orderId is not None:
19644 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19645 
      oprot.writeI64(self.orderId)
19646 
      oprot.writeFieldEnd()
19647 
    if self.itemId is not None:
19648 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19649 
      oprot.writeI64(self.itemId)
19650 
      oprot.writeFieldEnd()
19651 
    oprot.writeFieldStop()
19652 
    oprot.writeStructEnd()
19653 
 
19654 
  def validate(self):
19655 
    return
19656 
 
19657 
 
19658 
  def __repr__(self):
19659 
    L = ['%s=%r' % (key, value)
19660 
      for key, value in self.__dict__.iteritems()]
19661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19662 
 
19663 
  def __eq__(self, other):
19664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19665 
 
19666 
  def __ne__(self, other):
19667 
    return not (self == other)
19668 
 
19669 
class changeItem_result:
19670 
  """
19671 
  Attributes:
19672 
   - success
19673 
   - ex
19674 
  """
19675 
 
19676 
  thrift_spec = (
19677 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19679 
  )
19680 
 
19681 
  def __init__(self, success=None, ex=None,):
19682 
    self.success = success
19683 
    self.ex = ex
19684 
 
19685 
  def read(self, iprot):
19686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19688 
      return
19689 
    iprot.readStructBegin()
19690 
    while True:
19691 
      (fname, ftype, fid) = iprot.readFieldBegin()
19692 
      if ftype == TType.STOP:
19693 
        break
19694 
      if fid == 0:
19695 
        if ftype == TType.STRUCT:
19696 
          self.success = Order()
19697 
          self.success.read(iprot)
19698 
        else:
19699 
          iprot.skip(ftype)
19700 
      elif fid == 1:
19701 
        if ftype == TType.STRUCT:
19702 
          self.ex = TransactionServiceException()
19703 
          self.ex.read(iprot)
19704 
        else:
19705 
          iprot.skip(ftype)
19706 
      else:
19707 
        iprot.skip(ftype)
19708 
      iprot.readFieldEnd()
19709 
    iprot.readStructEnd()
19710 
 
19711 
  def write(self, oprot):
19712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19714 
      return
19715 
    oprot.writeStructBegin('changeItem_result')
19716 
    if self.success is not None:
19717 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19718 
      self.success.write(oprot)
19719 
      oprot.writeFieldEnd()
19720 
    if self.ex is not None:
19721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19722 
      self.ex.write(oprot)
19723 
      oprot.writeFieldEnd()
19724 
    oprot.writeFieldStop()
19725 
    oprot.writeStructEnd()
19726 
 
19727 
  def validate(self):
19728 
    return
19729 
 
19730 
 
19731 
  def __repr__(self):
19732 
    L = ['%s=%r' % (key, value)
19733 
      for key, value in self.__dict__.iteritems()]
19734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19735 
 
19736 
  def __eq__(self, other):
19737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19738 
 
19739 
  def __ne__(self, other):
19740 
    return not (self == other)
19741 
 
19742 
class shiftToWarehouse_args:
19743 
  """
19744 
  Attributes:
19745 
   - orderId
19746 
   - warehouseId
19747 
  """
19748 
 
19749 
  thrift_spec = (
19750 
    None, # 0
19751 
    (1, TType.I64, 'orderId', None, None, ), # 1
19752 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19753 
  )
19754 
 
19755 
  def __init__(self, orderId=None, warehouseId=None,):
19756 
    self.orderId = orderId
19757 
    self.warehouseId = warehouseId
19758 
 
19759 
  def read(self, iprot):
19760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19762 
      return
19763 
    iprot.readStructBegin()
19764 
    while True:
19765 
      (fname, ftype, fid) = iprot.readFieldBegin()
19766 
      if ftype == TType.STOP:
19767 
        break
19768 
      if fid == 1:
19769 
        if ftype == TType.I64:
19770 
          self.orderId = iprot.readI64();
19771 
        else:
19772 
          iprot.skip(ftype)
19773 
      elif fid == 2:
19774 
        if ftype == TType.I64:
19775 
          self.warehouseId = iprot.readI64();
19776 
        else:
19777 
          iprot.skip(ftype)
19778 
      else:
19779 
        iprot.skip(ftype)
19780 
      iprot.readFieldEnd()
19781 
    iprot.readStructEnd()
19782 
 
19783 
  def write(self, oprot):
19784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19786 
      return
19787 
    oprot.writeStructBegin('shiftToWarehouse_args')
19788 
    if self.orderId is not None:
19789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19790 
      oprot.writeI64(self.orderId)
19791 
      oprot.writeFieldEnd()
19792 
    if self.warehouseId is not None:
19793 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19794 
      oprot.writeI64(self.warehouseId)
19795 
      oprot.writeFieldEnd()
19796 
    oprot.writeFieldStop()
19797 
    oprot.writeStructEnd()
19798 
 
19799 
  def validate(self):
19800 
    return
19801 
 
19802 
 
19803 
  def __repr__(self):
19804 
    L = ['%s=%r' % (key, value)
19805 
      for key, value in self.__dict__.iteritems()]
19806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19807 
 
19808 
  def __eq__(self, other):
19809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19810 
 
19811 
  def __ne__(self, other):
19812 
    return not (self == other)
19813 
 
19814 
class shiftToWarehouse_result:
19815 
  """
19816 
  Attributes:
19817 
   - success
19818 
   - ex
19819 
  """
19820 
 
19821 
  thrift_spec = (
19822 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19824 
  )
19825 
 
19826 
  def __init__(self, success=None, ex=None,):
19827 
    self.success = success
19828 
    self.ex = ex
19829 
 
19830 
  def read(self, iprot):
19831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19833 
      return
19834 
    iprot.readStructBegin()
19835 
    while True:
19836 
      (fname, ftype, fid) = iprot.readFieldBegin()
19837 
      if ftype == TType.STOP:
19838 
        break
19839 
      if fid == 0:
19840 
        if ftype == TType.STRUCT:
19841 
          self.success = Order()
19842 
          self.success.read(iprot)
19843 
        else:
19844 
          iprot.skip(ftype)
19845 
      elif fid == 1:
19846 
        if ftype == TType.STRUCT:
19847 
          self.ex = TransactionServiceException()
19848 
          self.ex.read(iprot)
19849 
        else:
19850 
          iprot.skip(ftype)
19851 
      else:
19852 
        iprot.skip(ftype)
19853 
      iprot.readFieldEnd()
19854 
    iprot.readStructEnd()
19855 
 
19856 
  def write(self, oprot):
19857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19859 
      return
19860 
    oprot.writeStructBegin('shiftToWarehouse_result')
19861 
    if self.success is not None:
19862 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19863 
      self.success.write(oprot)
19864 
      oprot.writeFieldEnd()
19865 
    if self.ex is not None:
19866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19867 
      self.ex.write(oprot)
19868 
      oprot.writeFieldEnd()
19869 
    oprot.writeFieldStop()
19870 
    oprot.writeStructEnd()
19871 
 
19872 
  def validate(self):
19873 
    return
19874 
 
19875 
 
19876 
  def __repr__(self):
19877 
    L = ['%s=%r' % (key, value)
19878 
      for key, value in self.__dict__.iteritems()]
19879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19880 
 
19881 
  def __eq__(self, other):
19882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19883 
 
19884 
  def __ne__(self, other):
19885 
    return not (self == other)
3553 chandransh 19886 
 
19887 
class addDelayReason_args:
19888 
  """
19889 
  Attributes:
19890 
   - orderId
19891 
   - delayReason
3986 chandransh 19892 
   - furtherDelay
4647 rajveer 19893 
   - delayReasonText
3553 chandransh 19894 
  """
19895 
 
19896 
  thrift_spec = (
19897 
    None, # 0
19898 
    (1, TType.I64, 'orderId', None, None, ), # 1
19899 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19900 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19901 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19902 
  )
19903 
 
4647 rajveer 19904 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19905 
    self.orderId = orderId
19906 
    self.delayReason = delayReason
3986 chandransh 19907 
    self.furtherDelay = furtherDelay
4647 rajveer 19908 
    self.delayReasonText = delayReasonText
3553 chandransh 19909 
 
19910 
  def read(self, iprot):
19911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19913 
      return
19914 
    iprot.readStructBegin()
19915 
    while True:
19916 
      (fname, ftype, fid) = iprot.readFieldBegin()
19917 
      if ftype == TType.STOP:
19918 
        break
19919 
      if fid == 1:
19920 
        if ftype == TType.I64:
19921 
          self.orderId = iprot.readI64();
19922 
        else:
19923 
          iprot.skip(ftype)
19924 
      elif fid == 2:
19925 
        if ftype == TType.I32:
19926 
          self.delayReason = iprot.readI32();
19927 
        else:
19928 
          iprot.skip(ftype)
3986 chandransh 19929 
      elif fid == 3:
19930 
        if ftype == TType.I64:
19931 
          self.furtherDelay = iprot.readI64();
19932 
        else:
19933 
          iprot.skip(ftype)
4647 rajveer 19934 
      elif fid == 4:
19935 
        if ftype == TType.STRING:
19936 
          self.delayReasonText = iprot.readString();
19937 
        else:
19938 
          iprot.skip(ftype)
3553 chandransh 19939 
      else:
19940 
        iprot.skip(ftype)
19941 
      iprot.readFieldEnd()
19942 
    iprot.readStructEnd()
19943 
 
19944 
  def write(self, oprot):
19945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19947 
      return
19948 
    oprot.writeStructBegin('addDelayReason_args')
19949 
    if self.orderId is not None:
19950 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19951 
      oprot.writeI64(self.orderId)
19952 
      oprot.writeFieldEnd()
19953 
    if self.delayReason is not None:
19954 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19955 
      oprot.writeI32(self.delayReason)
19956 
      oprot.writeFieldEnd()
3986 chandransh 19957 
    if self.furtherDelay is not None:
19958 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19959 
      oprot.writeI64(self.furtherDelay)
19960 
      oprot.writeFieldEnd()
4647 rajveer 19961 
    if self.delayReasonText is not None:
19962 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19963 
      oprot.writeString(self.delayReasonText)
19964 
      oprot.writeFieldEnd()
3553 chandransh 19965 
    oprot.writeFieldStop()
19966 
    oprot.writeStructEnd()
19967 
 
19968 
  def validate(self):
19969 
    return
19970 
 
19971 
 
19972 
  def __repr__(self):
19973 
    L = ['%s=%r' % (key, value)
19974 
      for key, value in self.__dict__.iteritems()]
19975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19976 
 
19977 
  def __eq__(self, other):
19978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19979 
 
19980 
  def __ne__(self, other):
19981 
    return not (self == other)
19982 
 
19983 
class addDelayReason_result:
19984 
  """
19985 
  Attributes:
19986 
   - success
19987 
   - ex
19988 
  """
19989 
 
19990 
  thrift_spec = (
19991 
    (0, TType.BOOL, 'success', None, None, ), # 0
19992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19993 
  )
19994 
 
19995 
  def __init__(self, success=None, ex=None,):
19996 
    self.success = success
19997 
    self.ex = ex
19998 
 
19999 
  def read(self, iprot):
20000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20002 
      return
20003 
    iprot.readStructBegin()
20004 
    while True:
20005 
      (fname, ftype, fid) = iprot.readFieldBegin()
20006 
      if ftype == TType.STOP:
20007 
        break
20008 
      if fid == 0:
20009 
        if ftype == TType.BOOL:
20010 
          self.success = iprot.readBool();
20011 
        else:
20012 
          iprot.skip(ftype)
20013 
      elif fid == 1:
20014 
        if ftype == TType.STRUCT:
20015 
          self.ex = TransactionServiceException()
20016 
          self.ex.read(iprot)
20017 
        else:
20018 
          iprot.skip(ftype)
20019 
      else:
20020 
        iprot.skip(ftype)
20021 
      iprot.readFieldEnd()
20022 
    iprot.readStructEnd()
20023 
 
20024 
  def write(self, oprot):
20025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20027 
      return
20028 
    oprot.writeStructBegin('addDelayReason_result')
20029 
    if self.success is not None:
20030 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20031 
      oprot.writeBool(self.success)
20032 
      oprot.writeFieldEnd()
20033 
    if self.ex is not None:
20034 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20035 
      self.ex.write(oprot)
20036 
      oprot.writeFieldEnd()
20037 
    oprot.writeFieldStop()
20038 
    oprot.writeStructEnd()
20039 
 
20040 
  def validate(self):
20041 
    return
20042 
 
20043 
 
20044 
  def __repr__(self):
20045 
    L = ['%s=%r' % (key, value)
20046 
      for key, value in self.__dict__.iteritems()]
20047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20048 
 
20049 
  def __eq__(self, other):
20050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20051 
 
20052 
  def __ne__(self, other):
20053 
    return not (self == other)
3956 chandransh 20054 
 
20055 
class reconcileCodCollection_args:
20056 
  """
20057 
  Attributes:
20058 
   - collectedAmountMap
20059 
   - xferBy
20060 
   - xferTxnId
20061 
   - xferDate
20062 
  """
20063 
 
20064 
  thrift_spec = (
20065 
    None, # 0
20066 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20067 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20068 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20069 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20070 
  )
20071 
 
20072 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20073 
    self.collectedAmountMap = collectedAmountMap
20074 
    self.xferBy = xferBy
20075 
    self.xferTxnId = xferTxnId
20076 
    self.xferDate = xferDate
20077 
 
20078 
  def read(self, iprot):
20079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20081 
      return
20082 
    iprot.readStructBegin()
20083 
    while True:
20084 
      (fname, ftype, fid) = iprot.readFieldBegin()
20085 
      if ftype == TType.STOP:
20086 
        break
20087 
      if fid == 1:
20088 
        if ftype == TType.MAP:
20089 
          self.collectedAmountMap = {}
6188 rajveer 20090 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20091 
          for _i457 in xrange(_size453):
20092 
            _key458 = iprot.readString();
20093 
            _val459 = iprot.readDouble();
20094 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20095 
          iprot.readMapEnd()
20096 
        else:
20097 
          iprot.skip(ftype)
20098 
      elif fid == 2:
20099 
        if ftype == TType.STRING:
20100 
          self.xferBy = iprot.readString();
20101 
        else:
20102 
          iprot.skip(ftype)
20103 
      elif fid == 3:
20104 
        if ftype == TType.STRING:
20105 
          self.xferTxnId = iprot.readString();
20106 
        else:
20107 
          iprot.skip(ftype)
20108 
      elif fid == 4:
20109 
        if ftype == TType.I64:
20110 
          self.xferDate = iprot.readI64();
20111 
        else:
20112 
          iprot.skip(ftype)
20113 
      else:
20114 
        iprot.skip(ftype)
20115 
      iprot.readFieldEnd()
20116 
    iprot.readStructEnd()
20117 
 
20118 
  def write(self, oprot):
20119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20121 
      return
20122 
    oprot.writeStructBegin('reconcileCodCollection_args')
20123 
    if self.collectedAmountMap is not None:
20124 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20125 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20126 
      for kiter460,viter461 in self.collectedAmountMap.items():
20127 
        oprot.writeString(kiter460)
20128 
        oprot.writeDouble(viter461)
3956 chandransh 20129 
      oprot.writeMapEnd()
20130 
      oprot.writeFieldEnd()
20131 
    if self.xferBy is not None:
20132 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20133 
      oprot.writeString(self.xferBy)
20134 
      oprot.writeFieldEnd()
20135 
    if self.xferTxnId is not None:
20136 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20137 
      oprot.writeString(self.xferTxnId)
20138 
      oprot.writeFieldEnd()
20139 
    if self.xferDate is not None:
20140 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20141 
      oprot.writeI64(self.xferDate)
20142 
      oprot.writeFieldEnd()
20143 
    oprot.writeFieldStop()
20144 
    oprot.writeStructEnd()
20145 
 
20146 
  def validate(self):
20147 
    return
20148 
 
20149 
 
20150 
  def __repr__(self):
20151 
    L = ['%s=%r' % (key, value)
20152 
      for key, value in self.__dict__.iteritems()]
20153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20154 
 
20155 
  def __eq__(self, other):
20156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20157 
 
20158 
  def __ne__(self, other):
20159 
    return not (self == other)
20160 
 
20161 
class reconcileCodCollection_result:
20162 
  """
20163 
  Attributes:
20164 
   - success
20165 
   - ex
20166 
  """
20167 
 
20168 
  thrift_spec = (
20169 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20171 
  )
20172 
 
20173 
  def __init__(self, success=None, ex=None,):
20174 
    self.success = success
20175 
    self.ex = ex
20176 
 
20177 
  def read(self, iprot):
20178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20180 
      return
20181 
    iprot.readStructBegin()
20182 
    while True:
20183 
      (fname, ftype, fid) = iprot.readFieldBegin()
20184 
      if ftype == TType.STOP:
20185 
        break
20186 
      if fid == 0:
20187 
        if ftype == TType.MAP:
20188 
          self.success = {}
6188 rajveer 20189 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20190 
          for _i466 in xrange(_size462):
20191 
            _key467 = iprot.readString();
20192 
            _val468 = iprot.readString();
20193 
            self.success[_key467] = _val468
3956 chandransh 20194 
          iprot.readMapEnd()
20195 
        else:
20196 
          iprot.skip(ftype)
20197 
      elif fid == 1:
20198 
        if ftype == TType.STRUCT:
20199 
          self.ex = TransactionServiceException()
20200 
          self.ex.read(iprot)
20201 
        else:
20202 
          iprot.skip(ftype)
20203 
      else:
20204 
        iprot.skip(ftype)
20205 
      iprot.readFieldEnd()
20206 
    iprot.readStructEnd()
20207 
 
20208 
  def write(self, oprot):
20209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20211 
      return
20212 
    oprot.writeStructBegin('reconcileCodCollection_result')
20213 
    if self.success is not None:
20214 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20215 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20216 
      for kiter469,viter470 in self.success.items():
20217 
        oprot.writeString(kiter469)
20218 
        oprot.writeString(viter470)
3956 chandransh 20219 
      oprot.writeMapEnd()
20220 
      oprot.writeFieldEnd()
20221 
    if self.ex is not None:
20222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20223 
      self.ex.write(oprot)
20224 
      oprot.writeFieldEnd()
20225 
    oprot.writeFieldStop()
20226 
    oprot.writeStructEnd()
20227 
 
20228 
  def validate(self):
20229 
    return
20230 
 
20231 
 
20232 
  def __repr__(self):
20233 
    L = ['%s=%r' % (key, value)
20234 
      for key, value in self.__dict__.iteritems()]
20235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20236 
 
20237 
  def __eq__(self, other):
20238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20239 
 
20240 
  def __ne__(self, other):
20241 
    return not (self == other)
4008 mandeep.dh 20242 
 
20243 
class getTransactionsRequiringExtraProcessing_args:
20244 
  """
20245 
  Attributes:
20246 
   - category
20247 
  """
20248 
 
20249 
  thrift_spec = (
20250 
    None, # 0
20251 
    (1, TType.I32, 'category', None, None, ), # 1
20252 
  )
20253 
 
20254 
  def __init__(self, category=None,):
20255 
    self.category = category
20256 
 
20257 
  def read(self, iprot):
20258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20260 
      return
20261 
    iprot.readStructBegin()
20262 
    while True:
20263 
      (fname, ftype, fid) = iprot.readFieldBegin()
20264 
      if ftype == TType.STOP:
20265 
        break
20266 
      if fid == 1:
20267 
        if ftype == TType.I32:
20268 
          self.category = iprot.readI32();
20269 
        else:
20270 
          iprot.skip(ftype)
20271 
      else:
20272 
        iprot.skip(ftype)
20273 
      iprot.readFieldEnd()
20274 
    iprot.readStructEnd()
20275 
 
20276 
  def write(self, oprot):
20277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20279 
      return
20280 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20281 
    if self.category is not None:
20282 
      oprot.writeFieldBegin('category', TType.I32, 1)
20283 
      oprot.writeI32(self.category)
20284 
      oprot.writeFieldEnd()
20285 
    oprot.writeFieldStop()
20286 
    oprot.writeStructEnd()
20287 
 
20288 
  def validate(self):
20289 
    return
20290 
 
20291 
 
20292 
  def __repr__(self):
20293 
    L = ['%s=%r' % (key, value)
20294 
      for key, value in self.__dict__.iteritems()]
20295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20296 
 
20297 
  def __eq__(self, other):
20298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20299 
 
20300 
  def __ne__(self, other):
20301 
    return not (self == other)
20302 
 
20303 
class getTransactionsRequiringExtraProcessing_result:
20304 
  """
20305 
  Attributes:
20306 
   - success
20307 
  """
20308 
 
20309 
  thrift_spec = (
20310 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20311 
  )
20312 
 
20313 
  def __init__(self, success=None,):
20314 
    self.success = success
20315 
 
20316 
  def read(self, iprot):
20317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20319 
      return
20320 
    iprot.readStructBegin()
20321 
    while True:
20322 
      (fname, ftype, fid) = iprot.readFieldBegin()
20323 
      if ftype == TType.STOP:
20324 
        break
20325 
      if fid == 0:
20326 
        if ftype == TType.LIST:
20327 
          self.success = []
6188 rajveer 20328 
          (_etype474, _size471) = iprot.readListBegin()
20329 
          for _i475 in xrange(_size471):
20330 
            _elem476 = iprot.readI64();
20331 
            self.success.append(_elem476)
4008 mandeep.dh 20332 
          iprot.readListEnd()
20333 
        else:
20334 
          iprot.skip(ftype)
20335 
      else:
20336 
        iprot.skip(ftype)
20337 
      iprot.readFieldEnd()
20338 
    iprot.readStructEnd()
20339 
 
20340 
  def write(self, oprot):
20341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20343 
      return
20344 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20345 
    if self.success is not None:
20346 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20347 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20348 
      for iter477 in self.success:
20349 
        oprot.writeI64(iter477)
4008 mandeep.dh 20350 
      oprot.writeListEnd()
20351 
      oprot.writeFieldEnd()
20352 
    oprot.writeFieldStop()
20353 
    oprot.writeStructEnd()
20354 
 
20355 
  def validate(self):
20356 
    return
20357 
 
20358 
 
20359 
  def __repr__(self):
20360 
    L = ['%s=%r' % (key, value)
20361 
      for key, value in self.__dict__.iteritems()]
20362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20363 
 
20364 
  def __eq__(self, other):
20365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20366 
 
20367 
  def __ne__(self, other):
20368 
    return not (self == other)
20369 
 
20370 
class markTransactionAsProcessed_args:
20371 
  """
20372 
  Attributes:
20373 
   - transactionId
20374 
   - category
20375 
  """
20376 
 
20377 
  thrift_spec = (
20378 
    None, # 0
20379 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20380 
    (2, TType.I32, 'category', None, None, ), # 2
20381 
  )
20382 
 
20383 
  def __init__(self, transactionId=None, category=None,):
20384 
    self.transactionId = transactionId
20385 
    self.category = category
20386 
 
20387 
  def read(self, iprot):
20388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20390 
      return
20391 
    iprot.readStructBegin()
20392 
    while True:
20393 
      (fname, ftype, fid) = iprot.readFieldBegin()
20394 
      if ftype == TType.STOP:
20395 
        break
20396 
      if fid == 1:
20397 
        if ftype == TType.I64:
20398 
          self.transactionId = iprot.readI64();
20399 
        else:
20400 
          iprot.skip(ftype)
20401 
      elif fid == 2:
20402 
        if ftype == TType.I32:
20403 
          self.category = iprot.readI32();
20404 
        else:
20405 
          iprot.skip(ftype)
20406 
      else:
20407 
        iprot.skip(ftype)
20408 
      iprot.readFieldEnd()
20409 
    iprot.readStructEnd()
20410 
 
20411 
  def write(self, oprot):
20412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20414 
      return
20415 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20416 
    if self.transactionId is not None:
20417 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20418 
      oprot.writeI64(self.transactionId)
20419 
      oprot.writeFieldEnd()
20420 
    if self.category is not None:
20421 
      oprot.writeFieldBegin('category', TType.I32, 2)
20422 
      oprot.writeI32(self.category)
20423 
      oprot.writeFieldEnd()
20424 
    oprot.writeFieldStop()
20425 
    oprot.writeStructEnd()
20426 
 
20427 
  def validate(self):
20428 
    return
20429 
 
20430 
 
20431 
  def __repr__(self):
20432 
    L = ['%s=%r' % (key, value)
20433 
      for key, value in self.__dict__.iteritems()]
20434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20435 
 
20436 
  def __eq__(self, other):
20437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20438 
 
20439 
  def __ne__(self, other):
20440 
    return not (self == other)
20441 
 
20442 
class markTransactionAsProcessed_result:
20443 
 
20444 
  thrift_spec = (
20445 
  )
20446 
 
20447 
  def read(self, iprot):
20448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20450 
      return
20451 
    iprot.readStructBegin()
20452 
    while True:
20453 
      (fname, ftype, fid) = iprot.readFieldBegin()
20454 
      if ftype == TType.STOP:
20455 
        break
20456 
      else:
20457 
        iprot.skip(ftype)
20458 
      iprot.readFieldEnd()
20459 
    iprot.readStructEnd()
20460 
 
20461 
  def write(self, oprot):
20462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20464 
      return
20465 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20466 
    oprot.writeFieldStop()
20467 
    oprot.writeStructEnd()
20468 
 
20469 
  def validate(self):
20470 
    return
20471 
 
20472 
 
20473 
  def __repr__(self):
20474 
    L = ['%s=%r' % (key, value)
20475 
      for key, value in self.__dict__.iteritems()]
20476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20477 
 
20478 
  def __eq__(self, other):
20479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20480 
 
20481 
  def __ne__(self, other):
20482 
    return not (self == other)
4018 chandransh 20483 
 
20484 
class getItemWiseRiskyOrdersCount_args:
20485 
 
20486 
  thrift_spec = (
20487 
  )
20488 
 
20489 
  def read(self, iprot):
20490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20492 
      return
20493 
    iprot.readStructBegin()
20494 
    while True:
20495 
      (fname, ftype, fid) = iprot.readFieldBegin()
20496 
      if ftype == TType.STOP:
20497 
        break
20498 
      else:
20499 
        iprot.skip(ftype)
20500 
      iprot.readFieldEnd()
20501 
    iprot.readStructEnd()
20502 
 
20503 
  def write(self, oprot):
20504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20506 
      return
20507 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20508 
    oprot.writeFieldStop()
20509 
    oprot.writeStructEnd()
20510 
 
20511 
  def validate(self):
20512 
    return
20513 
 
20514 
 
20515 
  def __repr__(self):
20516 
    L = ['%s=%r' % (key, value)
20517 
      for key, value in self.__dict__.iteritems()]
20518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20519 
 
20520 
  def __eq__(self, other):
20521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20522 
 
20523 
  def __ne__(self, other):
20524 
    return not (self == other)
20525 
 
20526 
class getItemWiseRiskyOrdersCount_result:
20527 
  """
20528 
  Attributes:
20529 
   - success
20530 
  """
20531 
 
20532 
  thrift_spec = (
20533 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20534 
  )
20535 
 
20536 
  def __init__(self, success=None,):
20537 
    self.success = success
20538 
 
20539 
  def read(self, iprot):
20540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20542 
      return
20543 
    iprot.readStructBegin()
20544 
    while True:
20545 
      (fname, ftype, fid) = iprot.readFieldBegin()
20546 
      if ftype == TType.STOP:
20547 
        break
20548 
      if fid == 0:
20549 
        if ftype == TType.MAP:
20550 
          self.success = {}
6188 rajveer 20551 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20552 
          for _i482 in xrange(_size478):
20553 
            _key483 = iprot.readI64();
20554 
            _val484 = iprot.readI64();
20555 
            self.success[_key483] = _val484
4018 chandransh 20556 
          iprot.readMapEnd()
20557 
        else:
20558 
          iprot.skip(ftype)
20559 
      else:
20560 
        iprot.skip(ftype)
20561 
      iprot.readFieldEnd()
20562 
    iprot.readStructEnd()
20563 
 
20564 
  def write(self, oprot):
20565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20567 
      return
20568 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20569 
    if self.success is not None:
20570 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20571 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20572 
      for kiter485,viter486 in self.success.items():
20573 
        oprot.writeI64(kiter485)
20574 
        oprot.writeI64(viter486)
4018 chandransh 20575 
      oprot.writeMapEnd()
20576 
      oprot.writeFieldEnd()
20577 
    oprot.writeFieldStop()
20578 
    oprot.writeStructEnd()
20579 
 
20580 
  def validate(self):
20581 
    return
20582 
 
20583 
 
20584 
  def __repr__(self):
20585 
    L = ['%s=%r' % (key, value)
20586 
      for key, value in self.__dict__.iteritems()]
20587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20588 
 
20589 
  def __eq__(self, other):
20590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20591 
 
20592 
  def __ne__(self, other):
20593 
    return not (self == other)
4247 rajveer 20594 
 
4295 varun.gupt 20595 
class getOrdersForItemIds_args:
20596 
  """
20597 
  Attributes:
20598 
   - itemIds
20599 
  """
20600 
 
20601 
  thrift_spec = (
20602 
    None, # 0
20603 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20604 
  )
20605 
 
20606 
  def __init__(self, itemIds=None,):
20607 
    self.itemIds = itemIds
20608 
 
20609 
  def read(self, iprot):
20610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20612 
      return
20613 
    iprot.readStructBegin()
20614 
    while True:
20615 
      (fname, ftype, fid) = iprot.readFieldBegin()
20616 
      if ftype == TType.STOP:
20617 
        break
20618 
      if fid == 1:
20619 
        if ftype == TType.LIST:
20620 
          self.itemIds = []
6188 rajveer 20621 
          (_etype490, _size487) = iprot.readListBegin()
20622 
          for _i491 in xrange(_size487):
20623 
            _elem492 = iprot.readI64();
20624 
            self.itemIds.append(_elem492)
4295 varun.gupt 20625 
          iprot.readListEnd()
20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      else:
20629 
        iprot.skip(ftype)
20630 
      iprot.readFieldEnd()
20631 
    iprot.readStructEnd()
20632 
 
20633 
  def write(self, oprot):
20634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20636 
      return
20637 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20638 
    if self.itemIds is not None:
20639 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20640 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20641 
      for iter493 in self.itemIds:
20642 
        oprot.writeI64(iter493)
4295 varun.gupt 20643 
      oprot.writeListEnd()
20644 
      oprot.writeFieldEnd()
20645 
    oprot.writeFieldStop()
20646 
    oprot.writeStructEnd()
20647 
 
20648 
  def validate(self):
20649 
    return
20650 
 
20651 
 
20652 
  def __repr__(self):
20653 
    L = ['%s=%r' % (key, value)
20654 
      for key, value in self.__dict__.iteritems()]
20655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20656 
 
20657 
  def __eq__(self, other):
20658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20659 
 
20660 
  def __ne__(self, other):
20661 
    return not (self == other)
20662 
 
20663 
class getOrdersForItemIds_result:
20664 
  """
20665 
  Attributes:
20666 
   - success
20667 
  """
20668 
 
20669 
  thrift_spec = (
20670 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20671 
  )
20672 
 
20673 
  def __init__(self, success=None,):
20674 
    self.success = success
20675 
 
20676 
  def read(self, iprot):
20677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20679 
      return
20680 
    iprot.readStructBegin()
20681 
    while True:
20682 
      (fname, ftype, fid) = iprot.readFieldBegin()
20683 
      if ftype == TType.STOP:
20684 
        break
20685 
      if fid == 0:
20686 
        if ftype == TType.LIST:
20687 
          self.success = []
6188 rajveer 20688 
          (_etype497, _size494) = iprot.readListBegin()
20689 
          for _i498 in xrange(_size494):
20690 
            _elem499 = Order()
20691 
            _elem499.read(iprot)
20692 
            self.success.append(_elem499)
4295 varun.gupt 20693 
          iprot.readListEnd()
20694 
        else:
20695 
          iprot.skip(ftype)
20696 
      else:
20697 
        iprot.skip(ftype)
20698 
      iprot.readFieldEnd()
20699 
    iprot.readStructEnd()
20700 
 
20701 
  def write(self, oprot):
20702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20704 
      return
20705 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20706 
    if self.success is not None:
20707 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20708 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20709 
      for iter500 in self.success:
20710 
        iter500.write(oprot)
4295 varun.gupt 20711 
      oprot.writeListEnd()
20712 
      oprot.writeFieldEnd()
20713 
    oprot.writeFieldStop()
20714 
    oprot.writeStructEnd()
20715 
 
20716 
  def validate(self):
20717 
    return
20718 
 
20719 
 
20720 
  def __repr__(self):
20721 
    L = ['%s=%r' % (key, value)
20722 
      for key, value in self.__dict__.iteritems()]
20723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20724 
 
20725 
  def __eq__(self, other):
20726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20727 
 
20728 
  def __ne__(self, other):
20729 
    return not (self == other)
20730 
 
4247 rajveer 20731 
class markOrderCancellationRequestReceived_args:
20732 
  """
20733 
  Attributes:
20734 
   - orderId
20735 
  """
20736 
 
20737 
  thrift_spec = (
20738 
    None, # 0
20739 
    (1, TType.I64, 'orderId', None, None, ), # 1
20740 
  )
20741 
 
20742 
  def __init__(self, orderId=None,):
20743 
    self.orderId = orderId
20744 
 
20745 
  def read(self, iprot):
20746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20748 
      return
20749 
    iprot.readStructBegin()
20750 
    while True:
20751 
      (fname, ftype, fid) = iprot.readFieldBegin()
20752 
      if ftype == TType.STOP:
20753 
        break
20754 
      if fid == 1:
20755 
        if ftype == TType.I64:
20756 
          self.orderId = iprot.readI64();
20757 
        else:
20758 
          iprot.skip(ftype)
20759 
      else:
20760 
        iprot.skip(ftype)
20761 
      iprot.readFieldEnd()
20762 
    iprot.readStructEnd()
20763 
 
20764 
  def write(self, oprot):
20765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20767 
      return
20768 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20769 
    if self.orderId is not None:
20770 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20771 
      oprot.writeI64(self.orderId)
20772 
      oprot.writeFieldEnd()
20773 
    oprot.writeFieldStop()
20774 
    oprot.writeStructEnd()
20775 
 
20776 
  def validate(self):
20777 
    return
20778 
 
20779 
 
20780 
  def __repr__(self):
20781 
    L = ['%s=%r' % (key, value)
20782 
      for key, value in self.__dict__.iteritems()]
20783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20784 
 
20785 
  def __eq__(self, other):
20786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20787 
 
20788 
  def __ne__(self, other):
20789 
    return not (self == other)
20790 
 
20791 
class markOrderCancellationRequestReceived_result:
20792 
  """
20793 
  Attributes:
20794 
   - ex
20795 
  """
20796 
 
20797 
  thrift_spec = (
20798 
    None, # 0
20799 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20800 
  )
20801 
 
20802 
  def __init__(self, ex=None,):
20803 
    self.ex = ex
20804 
 
20805 
  def read(self, iprot):
20806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20808 
      return
20809 
    iprot.readStructBegin()
20810 
    while True:
20811 
      (fname, ftype, fid) = iprot.readFieldBegin()
20812 
      if ftype == TType.STOP:
20813 
        break
20814 
      if fid == 1:
20815 
        if ftype == TType.STRUCT:
20816 
          self.ex = TransactionServiceException()
20817 
          self.ex.read(iprot)
20818 
        else:
20819 
          iprot.skip(ftype)
20820 
      else:
20821 
        iprot.skip(ftype)
20822 
      iprot.readFieldEnd()
20823 
    iprot.readStructEnd()
20824 
 
20825 
  def write(self, oprot):
20826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20828 
      return
20829 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20830 
    if self.ex is not None:
20831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20832 
      self.ex.write(oprot)
20833 
      oprot.writeFieldEnd()
20834 
    oprot.writeFieldStop()
20835 
    oprot.writeStructEnd()
20836 
 
20837 
  def validate(self):
20838 
    return
20839 
 
20840 
 
20841 
  def __repr__(self):
20842 
    L = ['%s=%r' % (key, value)
20843 
      for key, value in self.__dict__.iteritems()]
20844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20845 
 
20846 
  def __eq__(self, other):
20847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20848 
 
20849 
  def __ne__(self, other):
20850 
    return not (self == other)
20851 
 
20852 
class markOrderCancellationRequestConfirmed_args:
20853 
  """
20854 
  Attributes:
20855 
   - orderId
20856 
  """
20857 
 
20858 
  thrift_spec = (
20859 
    None, # 0
20860 
    (1, TType.I64, 'orderId', None, None, ), # 1
20861 
  )
20862 
 
20863 
  def __init__(self, orderId=None,):
20864 
    self.orderId = orderId
20865 
 
20866 
  def read(self, iprot):
20867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20869 
      return
20870 
    iprot.readStructBegin()
20871 
    while True:
20872 
      (fname, ftype, fid) = iprot.readFieldBegin()
20873 
      if ftype == TType.STOP:
20874 
        break
20875 
      if fid == 1:
20876 
        if ftype == TType.I64:
20877 
          self.orderId = iprot.readI64();
20878 
        else:
20879 
          iprot.skip(ftype)
20880 
      else:
20881 
        iprot.skip(ftype)
20882 
      iprot.readFieldEnd()
20883 
    iprot.readStructEnd()
20884 
 
20885 
  def write(self, oprot):
20886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20888 
      return
20889 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20890 
    if self.orderId is not None:
20891 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20892 
      oprot.writeI64(self.orderId)
20893 
      oprot.writeFieldEnd()
20894 
    oprot.writeFieldStop()
20895 
    oprot.writeStructEnd()
20896 
 
20897 
  def validate(self):
20898 
    return
20899 
 
20900 
 
20901 
  def __repr__(self):
20902 
    L = ['%s=%r' % (key, value)
20903 
      for key, value in self.__dict__.iteritems()]
20904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20905 
 
20906 
  def __eq__(self, other):
20907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20908 
 
20909 
  def __ne__(self, other):
20910 
    return not (self == other)
20911 
 
20912 
class markOrderCancellationRequestConfirmed_result:
20913 
  """
20914 
  Attributes:
20915 
   - ex
20916 
  """
20917 
 
20918 
  thrift_spec = (
20919 
    None, # 0
20920 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20921 
  )
20922 
 
20923 
  def __init__(self, ex=None,):
20924 
    self.ex = ex
20925 
 
20926 
  def read(self, iprot):
20927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20929 
      return
20930 
    iprot.readStructBegin()
20931 
    while True:
20932 
      (fname, ftype, fid) = iprot.readFieldBegin()
20933 
      if ftype == TType.STOP:
20934 
        break
20935 
      if fid == 1:
20936 
        if ftype == TType.STRUCT:
20937 
          self.ex = TransactionServiceException()
20938 
          self.ex.read(iprot)
20939 
        else:
20940 
          iprot.skip(ftype)
20941 
      else:
20942 
        iprot.skip(ftype)
20943 
      iprot.readFieldEnd()
20944 
    iprot.readStructEnd()
20945 
 
20946 
  def write(self, oprot):
20947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20949 
      return
20950 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20951 
    if self.ex is not None:
20952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20953 
      self.ex.write(oprot)
20954 
      oprot.writeFieldEnd()
20955 
    oprot.writeFieldStop()
20956 
    oprot.writeStructEnd()
20957 
 
20958 
  def validate(self):
20959 
    return
20960 
 
20961 
 
20962 
  def __repr__(self):
20963 
    L = ['%s=%r' % (key, value)
20964 
      for key, value in self.__dict__.iteritems()]
20965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20966 
 
20967 
  def __eq__(self, other):
20968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20969 
 
20970 
  def __ne__(self, other):
20971 
    return not (self == other)
20972 
 
20973 
class markOrderCancellationRequestDenied_args:
20974 
  """
20975 
  Attributes:
20976 
   - orderId
20977 
  """
20978 
 
20979 
  thrift_spec = (
20980 
    None, # 0
20981 
    (1, TType.I64, 'orderId', None, None, ), # 1
20982 
  )
20983 
 
20984 
  def __init__(self, orderId=None,):
20985 
    self.orderId = orderId
20986 
 
20987 
  def read(self, iprot):
20988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20990 
      return
20991 
    iprot.readStructBegin()
20992 
    while True:
20993 
      (fname, ftype, fid) = iprot.readFieldBegin()
20994 
      if ftype == TType.STOP:
20995 
        break
20996 
      if fid == 1:
20997 
        if ftype == TType.I64:
20998 
          self.orderId = iprot.readI64();
20999 
        else:
21000 
          iprot.skip(ftype)
21001 
      else:
21002 
        iprot.skip(ftype)
21003 
      iprot.readFieldEnd()
21004 
    iprot.readStructEnd()
21005 
 
21006 
  def write(self, oprot):
21007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21009 
      return
21010 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21011 
    if self.orderId is not None:
21012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21013 
      oprot.writeI64(self.orderId)
21014 
      oprot.writeFieldEnd()
21015 
    oprot.writeFieldStop()
21016 
    oprot.writeStructEnd()
21017 
 
21018 
  def validate(self):
21019 
    return
21020 
 
21021 
 
21022 
  def __repr__(self):
21023 
    L = ['%s=%r' % (key, value)
21024 
      for key, value in self.__dict__.iteritems()]
21025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21026 
 
21027 
  def __eq__(self, other):
21028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21029 
 
21030 
  def __ne__(self, other):
21031 
    return not (self == other)
21032 
 
21033 
class markOrderCancellationRequestDenied_result:
21034 
  """
21035 
  Attributes:
21036 
   - ex
21037 
  """
21038 
 
21039 
  thrift_spec = (
21040 
    None, # 0
21041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21042 
  )
21043 
 
21044 
  def __init__(self, ex=None,):
21045 
    self.ex = ex
21046 
 
21047 
  def read(self, iprot):
21048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21050 
      return
21051 
    iprot.readStructBegin()
21052 
    while True:
21053 
      (fname, ftype, fid) = iprot.readFieldBegin()
21054 
      if ftype == TType.STOP:
21055 
        break
21056 
      if fid == 1:
21057 
        if ftype == TType.STRUCT:
21058 
          self.ex = TransactionServiceException()
21059 
          self.ex.read(iprot)
21060 
        else:
21061 
          iprot.skip(ftype)
21062 
      else:
21063 
        iprot.skip(ftype)
21064 
      iprot.readFieldEnd()
21065 
    iprot.readStructEnd()
21066 
 
21067 
  def write(self, oprot):
21068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21070 
      return
21071 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21072 
    if self.ex is not None:
21073 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21074 
      self.ex.write(oprot)
21075 
      oprot.writeFieldEnd()
21076 
    oprot.writeFieldStop()
21077 
    oprot.writeStructEnd()
21078 
 
21079 
  def validate(self):
21080 
    return
21081 
 
21082 
 
21083 
  def __repr__(self):
21084 
    L = ['%s=%r' % (key, value)
21085 
      for key, value in self.__dict__.iteritems()]
21086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21087 
 
21088 
  def __eq__(self, other):
21089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21090 
 
21091 
  def __ne__(self, other):
21092 
    return not (self == other)
21093 
 
4258 rajveer 21094 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21095 
  """
21096 
  Attributes:
4258 rajveer 21097 
   - transactionId
4247 rajveer 21098 
  """
21099 
 
21100 
  thrift_spec = (
21101 
    None, # 0
4258 rajveer 21102 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21103 
  )
21104 
 
4258 rajveer 21105 
  def __init__(self, transactionId=None,):
21106 
    self.transactionId = transactionId
4247 rajveer 21107 
 
21108 
  def read(self, iprot):
21109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21111 
      return
21112 
    iprot.readStructBegin()
21113 
    while True:
21114 
      (fname, ftype, fid) = iprot.readFieldBegin()
21115 
      if ftype == TType.STOP:
21116 
        break
21117 
      if fid == 1:
21118 
        if ftype == TType.I64:
4258 rajveer 21119 
          self.transactionId = iprot.readI64();
4247 rajveer 21120 
        else:
21121 
          iprot.skip(ftype)
21122 
      else:
21123 
        iprot.skip(ftype)
21124 
      iprot.readFieldEnd()
21125 
    iprot.readStructEnd()
21126 
 
21127 
  def write(self, oprot):
21128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21130 
      return
4258 rajveer 21131 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21132 
    if self.transactionId is not None:
21133 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21134 
      oprot.writeI64(self.transactionId)
4247 rajveer 21135 
      oprot.writeFieldEnd()
21136 
    oprot.writeFieldStop()
21137 
    oprot.writeStructEnd()
21138 
 
21139 
  def validate(self):
21140 
    return
21141 
 
21142 
 
21143 
  def __repr__(self):
21144 
    L = ['%s=%r' % (key, value)
21145 
      for key, value in self.__dict__.iteritems()]
21146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21147 
 
21148 
  def __eq__(self, other):
21149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21150 
 
21151 
  def __ne__(self, other):
21152 
    return not (self == other)
21153 
 
4258 rajveer 21154 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21155 
  """
21156 
  Attributes:
21157 
   - ex
21158 
  """
21159 
 
21160 
  thrift_spec = (
21161 
    None, # 0
21162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21163 
  )
21164 
 
21165 
  def __init__(self, ex=None,):
21166 
    self.ex = ex
21167 
 
21168 
  def read(self, iprot):
21169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21171 
      return
21172 
    iprot.readStructBegin()
21173 
    while True:
21174 
      (fname, ftype, fid) = iprot.readFieldBegin()
21175 
      if ftype == TType.STOP:
21176 
        break
21177 
      if fid == 1:
21178 
        if ftype == TType.STRUCT:
21179 
          self.ex = TransactionServiceException()
21180 
          self.ex.read(iprot)
21181 
        else:
21182 
          iprot.skip(ftype)
21183 
      else:
21184 
        iprot.skip(ftype)
21185 
      iprot.readFieldEnd()
21186 
    iprot.readStructEnd()
21187 
 
21188 
  def write(self, oprot):
21189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21191 
      return
4258 rajveer 21192 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21193 
    if self.ex is not None:
21194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21195 
      self.ex.write(oprot)
21196 
      oprot.writeFieldEnd()
21197 
    oprot.writeFieldStop()
21198 
    oprot.writeStructEnd()
21199 
 
21200 
  def validate(self):
21201 
    return
21202 
 
21203 
 
21204 
  def __repr__(self):
21205 
    L = ['%s=%r' % (key, value)
21206 
      for key, value in self.__dict__.iteritems()]
21207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21208 
 
21209 
  def __eq__(self, other):
21210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21211 
 
21212 
  def __ne__(self, other):
21213 
    return not (self == other)
4259 anupam.sin 21214 
 
21215 
class refundTransaction_args:
21216 
  """
21217 
  Attributes:
21218 
   - transactionId
21219 
   - refundedBy
21220 
   - reason
21221 
  """
21222 
 
21223 
  thrift_spec = (
21224 
    None, # 0
21225 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21226 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21227 
    (3, TType.STRING, 'reason', None, None, ), # 3
21228 
  )
21229 
 
21230 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21231 
    self.transactionId = transactionId
21232 
    self.refundedBy = refundedBy
21233 
    self.reason = reason
21234 
 
21235 
  def read(self, iprot):
21236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21238 
      return
21239 
    iprot.readStructBegin()
21240 
    while True:
21241 
      (fname, ftype, fid) = iprot.readFieldBegin()
21242 
      if ftype == TType.STOP:
21243 
        break
21244 
      if fid == 1:
21245 
        if ftype == TType.I64:
21246 
          self.transactionId = iprot.readI64();
21247 
        else:
21248 
          iprot.skip(ftype)
21249 
      elif fid == 2:
21250 
        if ftype == TType.STRING:
21251 
          self.refundedBy = iprot.readString();
21252 
        else:
21253 
          iprot.skip(ftype)
21254 
      elif fid == 3:
21255 
        if ftype == TType.STRING:
21256 
          self.reason = iprot.readString();
21257 
        else:
21258 
          iprot.skip(ftype)
21259 
      else:
21260 
        iprot.skip(ftype)
21261 
      iprot.readFieldEnd()
21262 
    iprot.readStructEnd()
21263 
 
21264 
  def write(self, oprot):
21265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21267 
      return
21268 
    oprot.writeStructBegin('refundTransaction_args')
21269 
    if self.transactionId is not None:
21270 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21271 
      oprot.writeI64(self.transactionId)
21272 
      oprot.writeFieldEnd()
21273 
    if self.refundedBy is not None:
21274 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21275 
      oprot.writeString(self.refundedBy)
21276 
      oprot.writeFieldEnd()
21277 
    if self.reason is not None:
21278 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21279 
      oprot.writeString(self.reason)
21280 
      oprot.writeFieldEnd()
21281 
    oprot.writeFieldStop()
21282 
    oprot.writeStructEnd()
21283 
 
21284 
  def validate(self):
21285 
    return
21286 
 
21287 
 
21288 
  def __repr__(self):
21289 
    L = ['%s=%r' % (key, value)
21290 
      for key, value in self.__dict__.iteritems()]
21291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21292 
 
21293 
  def __eq__(self, other):
21294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21295 
 
21296 
  def __ne__(self, other):
21297 
    return not (self == other)
21298 
 
21299 
class refundTransaction_result:
21300 
  """
21301 
  Attributes:
21302 
   - ex
21303 
  """
21304 
 
21305 
  thrift_spec = (
21306 
    None, # 0
21307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21308 
  )
21309 
 
21310 
  def __init__(self, ex=None,):
21311 
    self.ex = ex
21312 
 
21313 
  def read(self, iprot):
21314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21316 
      return
21317 
    iprot.readStructBegin()
21318 
    while True:
21319 
      (fname, ftype, fid) = iprot.readFieldBegin()
21320 
      if ftype == TType.STOP:
21321 
        break
21322 
      if fid == 1:
21323 
        if ftype == TType.STRUCT:
21324 
          self.ex = TransactionServiceException()
21325 
          self.ex.read(iprot)
21326 
        else:
21327 
          iprot.skip(ftype)
21328 
      else:
21329 
        iprot.skip(ftype)
21330 
      iprot.readFieldEnd()
21331 
    iprot.readStructEnd()
21332 
 
21333 
  def write(self, oprot):
21334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21336 
      return
21337 
    oprot.writeStructBegin('refundTransaction_result')
21338 
    if self.ex is not None:
21339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21340 
      self.ex.write(oprot)
21341 
      oprot.writeFieldEnd()
21342 
    oprot.writeFieldStop()
21343 
    oprot.writeStructEnd()
21344 
 
21345 
  def validate(self):
21346 
    return
21347 
 
21348 
 
21349 
  def __repr__(self):
21350 
    L = ['%s=%r' % (key, value)
21351 
      for key, value in self.__dict__.iteritems()]
21352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21353 
 
21354 
  def __eq__(self, other):
21355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21356 
 
21357 
  def __ne__(self, other):
21358 
    return not (self == other)
4285 rajveer 21359 
 
4324 mandeep.dh 21360 
class updateShipmentAddress_args:
21361 
  """
21362 
  Attributes:
21363 
   - orderId
21364 
   - addressId
21365 
  """
21366 
 
21367 
  thrift_spec = (
21368 
    None, # 0
21369 
    (1, TType.I64, 'orderId', None, None, ), # 1
21370 
    (2, TType.I64, 'addressId', None, None, ), # 2
21371 
  )
21372 
 
21373 
  def __init__(self, orderId=None, addressId=None,):
21374 
    self.orderId = orderId
21375 
    self.addressId = addressId
21376 
 
21377 
  def read(self, iprot):
21378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21380 
      return
21381 
    iprot.readStructBegin()
21382 
    while True:
21383 
      (fname, ftype, fid) = iprot.readFieldBegin()
21384 
      if ftype == TType.STOP:
21385 
        break
21386 
      if fid == 1:
21387 
        if ftype == TType.I64:
21388 
          self.orderId = iprot.readI64();
21389 
        else:
21390 
          iprot.skip(ftype)
21391 
      elif fid == 2:
21392 
        if ftype == TType.I64:
21393 
          self.addressId = iprot.readI64();
21394 
        else:
21395 
          iprot.skip(ftype)
21396 
      else:
21397 
        iprot.skip(ftype)
21398 
      iprot.readFieldEnd()
21399 
    iprot.readStructEnd()
21400 
 
21401 
  def write(self, oprot):
21402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21404 
      return
21405 
    oprot.writeStructBegin('updateShipmentAddress_args')
21406 
    if self.orderId is not None:
21407 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21408 
      oprot.writeI64(self.orderId)
21409 
      oprot.writeFieldEnd()
21410 
    if self.addressId is not None:
21411 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21412 
      oprot.writeI64(self.addressId)
21413 
      oprot.writeFieldEnd()
21414 
    oprot.writeFieldStop()
21415 
    oprot.writeStructEnd()
21416 
 
21417 
  def validate(self):
21418 
    return
21419 
 
21420 
 
21421 
  def __repr__(self):
21422 
    L = ['%s=%r' % (key, value)
21423 
      for key, value in self.__dict__.iteritems()]
21424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21425 
 
21426 
  def __eq__(self, other):
21427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21428 
 
21429 
  def __ne__(self, other):
21430 
    return not (self == other)
21431 
 
21432 
class updateShipmentAddress_result:
21433 
  """
21434 
  Attributes:
21435 
   - ex
21436 
  """
21437 
 
21438 
  thrift_spec = (
21439 
    None, # 0
21440 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21441 
  )
21442 
 
21443 
  def __init__(self, ex=None,):
21444 
    self.ex = ex
21445 
 
21446 
  def read(self, iprot):
21447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21449 
      return
21450 
    iprot.readStructBegin()
21451 
    while True:
21452 
      (fname, ftype, fid) = iprot.readFieldBegin()
21453 
      if ftype == TType.STOP:
21454 
        break
21455 
      if fid == 1:
21456 
        if ftype == TType.STRUCT:
21457 
          self.ex = TransactionServiceException()
21458 
          self.ex.read(iprot)
21459 
        else:
21460 
          iprot.skip(ftype)
21461 
      else:
21462 
        iprot.skip(ftype)
21463 
      iprot.readFieldEnd()
21464 
    iprot.readStructEnd()
21465 
 
21466 
  def write(self, oprot):
21467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21469 
      return
21470 
    oprot.writeStructBegin('updateShipmentAddress_result')
21471 
    if self.ex is not None:
21472 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21473 
      self.ex.write(oprot)
21474 
      oprot.writeFieldEnd()
21475 
    oprot.writeFieldStop()
21476 
    oprot.writeStructEnd()
21477 
 
21478 
  def validate(self):
21479 
    return
21480 
 
21481 
 
21482 
  def __repr__(self):
21483 
    L = ['%s=%r' % (key, value)
21484 
      for key, value in self.__dict__.iteritems()]
21485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21486 
 
21487 
  def __eq__(self, other):
21488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21489 
 
21490 
  def __ne__(self, other):
21491 
    return not (self == other)
21492 
 
4285 rajveer 21493 
class acceptOrdersForItemId_args:
21494 
  """
21495 
  Attributes:
21496 
   - itemId
21497 
   - inventory
21498 
  """
21499 
 
21500 
  thrift_spec = (
21501 
    None, # 0
21502 
    (1, TType.I64, 'itemId', None, None, ), # 1
21503 
    (2, TType.I64, 'inventory', None, None, ), # 2
21504 
  )
21505 
 
21506 
  def __init__(self, itemId=None, inventory=None,):
21507 
    self.itemId = itemId
21508 
    self.inventory = inventory
21509 
 
21510 
  def read(self, iprot):
21511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21513 
      return
21514 
    iprot.readStructBegin()
21515 
    while True:
21516 
      (fname, ftype, fid) = iprot.readFieldBegin()
21517 
      if ftype == TType.STOP:
21518 
        break
21519 
      if fid == 1:
21520 
        if ftype == TType.I64:
21521 
          self.itemId = iprot.readI64();
21522 
        else:
21523 
          iprot.skip(ftype)
21524 
      elif fid == 2:
21525 
        if ftype == TType.I64:
21526 
          self.inventory = iprot.readI64();
21527 
        else:
21528 
          iprot.skip(ftype)
21529 
      else:
21530 
        iprot.skip(ftype)
21531 
      iprot.readFieldEnd()
21532 
    iprot.readStructEnd()
21533 
 
21534 
  def write(self, oprot):
21535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21537 
      return
21538 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21539 
    if self.itemId is not None:
21540 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21541 
      oprot.writeI64(self.itemId)
21542 
      oprot.writeFieldEnd()
21543 
    if self.inventory is not None:
21544 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21545 
      oprot.writeI64(self.inventory)
21546 
      oprot.writeFieldEnd()
21547 
    oprot.writeFieldStop()
21548 
    oprot.writeStructEnd()
21549 
 
21550 
  def validate(self):
21551 
    return
21552 
 
21553 
 
21554 
  def __repr__(self):
21555 
    L = ['%s=%r' % (key, value)
21556 
      for key, value in self.__dict__.iteritems()]
21557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21558 
 
21559 
  def __eq__(self, other):
21560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21561 
 
21562 
  def __ne__(self, other):
21563 
    return not (self == other)
21564 
 
21565 
class acceptOrdersForItemId_result:
21566 
  """
21567 
  Attributes:
21568 
   - success
21569 
   - ex
21570 
  """
21571 
 
21572 
  thrift_spec = (
21573 
    (0, TType.BOOL, 'success', None, None, ), # 0
21574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21575 
  )
21576 
 
21577 
  def __init__(self, success=None, ex=None,):
21578 
    self.success = success
21579 
    self.ex = ex
21580 
 
21581 
  def read(self, iprot):
21582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21584 
      return
21585 
    iprot.readStructBegin()
21586 
    while True:
21587 
      (fname, ftype, fid) = iprot.readFieldBegin()
21588 
      if ftype == TType.STOP:
21589 
        break
21590 
      if fid == 0:
21591 
        if ftype == TType.BOOL:
21592 
          self.success = iprot.readBool();
21593 
        else:
21594 
          iprot.skip(ftype)
21595 
      elif fid == 1:
21596 
        if ftype == TType.STRUCT:
21597 
          self.ex = TransactionServiceException()
21598 
          self.ex.read(iprot)
21599 
        else:
21600 
          iprot.skip(ftype)
21601 
      else:
21602 
        iprot.skip(ftype)
21603 
      iprot.readFieldEnd()
21604 
    iprot.readStructEnd()
21605 
 
21606 
  def write(self, oprot):
21607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21609 
      return
21610 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21611 
    if self.success is not None:
21612 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21613 
      oprot.writeBool(self.success)
21614 
      oprot.writeFieldEnd()
21615 
    if self.ex is not None:
21616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21617 
      self.ex.write(oprot)
21618 
      oprot.writeFieldEnd()
21619 
    oprot.writeFieldStop()
21620 
    oprot.writeStructEnd()
21621 
 
21622 
  def validate(self):
21623 
    return
21624 
 
21625 
 
21626 
  def __repr__(self):
21627 
    L = ['%s=%r' % (key, value)
21628 
      for key, value in self.__dict__.iteritems()]
21629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21630 
 
21631 
  def __eq__(self, other):
21632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21633 
 
21634 
  def __ne__(self, other):
21635 
    return not (self == other)
4303 rajveer 21636 
 
21637 
class markOrdersAsPORaised_args:
21638 
  """
21639 
  Attributes:
21640 
   - vendorId
21641 
   - itemId
21642 
   - quantity
21643 
   - estimate
4369 rajveer 21644 
   - isReminder
4303 rajveer 21645 
  """
21646 
 
21647 
  thrift_spec = (
21648 
    None, # 0
21649 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21650 
    (2, TType.I64, 'itemId', None, None, ), # 2
21651 
    (3, TType.I64, 'quantity', None, None, ), # 3
21652 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21653 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21654 
  )
21655 
 
4369 rajveer 21656 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21657 
    self.vendorId = vendorId
21658 
    self.itemId = itemId
21659 
    self.quantity = quantity
21660 
    self.estimate = estimate
4369 rajveer 21661 
    self.isReminder = isReminder
4303 rajveer 21662 
 
21663 
  def read(self, iprot):
21664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21666 
      return
21667 
    iprot.readStructBegin()
21668 
    while True:
21669 
      (fname, ftype, fid) = iprot.readFieldBegin()
21670 
      if ftype == TType.STOP:
21671 
        break
21672 
      if fid == 1:
21673 
        if ftype == TType.I64:
21674 
          self.vendorId = iprot.readI64();
21675 
        else:
21676 
          iprot.skip(ftype)
21677 
      elif fid == 2:
21678 
        if ftype == TType.I64:
21679 
          self.itemId = iprot.readI64();
21680 
        else:
21681 
          iprot.skip(ftype)
21682 
      elif fid == 3:
21683 
        if ftype == TType.I64:
21684 
          self.quantity = iprot.readI64();
21685 
        else:
21686 
          iprot.skip(ftype)
21687 
      elif fid == 4:
21688 
        if ftype == TType.I64:
21689 
          self.estimate = iprot.readI64();
21690 
        else:
21691 
          iprot.skip(ftype)
4369 rajveer 21692 
      elif fid == 5:
21693 
        if ftype == TType.BOOL:
21694 
          self.isReminder = iprot.readBool();
21695 
        else:
21696 
          iprot.skip(ftype)
4303 rajveer 21697 
      else:
21698 
        iprot.skip(ftype)
21699 
      iprot.readFieldEnd()
21700 
    iprot.readStructEnd()
21701 
 
21702 
  def write(self, oprot):
21703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21705 
      return
21706 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21707 
    if self.vendorId is not None:
21708 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21709 
      oprot.writeI64(self.vendorId)
21710 
      oprot.writeFieldEnd()
21711 
    if self.itemId is not None:
21712 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21713 
      oprot.writeI64(self.itemId)
21714 
      oprot.writeFieldEnd()
21715 
    if self.quantity is not None:
21716 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21717 
      oprot.writeI64(self.quantity)
21718 
      oprot.writeFieldEnd()
21719 
    if self.estimate is not None:
21720 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21721 
      oprot.writeI64(self.estimate)
21722 
      oprot.writeFieldEnd()
4369 rajveer 21723 
    if self.isReminder is not None:
21724 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21725 
      oprot.writeBool(self.isReminder)
21726 
      oprot.writeFieldEnd()
4303 rajveer 21727 
    oprot.writeFieldStop()
21728 
    oprot.writeStructEnd()
21729 
 
21730 
  def validate(self):
21731 
    return
21732 
 
21733 
 
21734 
  def __repr__(self):
21735 
    L = ['%s=%r' % (key, value)
21736 
      for key, value in self.__dict__.iteritems()]
21737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21738 
 
21739 
  def __eq__(self, other):
21740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21741 
 
21742 
  def __ne__(self, other):
21743 
    return not (self == other)
21744 
 
21745 
class markOrdersAsPORaised_result:
21746 
  """
21747 
  Attributes:
21748 
   - ex
21749 
  """
21750 
 
21751 
  thrift_spec = (
21752 
    None, # 0
21753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21754 
  )
21755 
 
21756 
  def __init__(self, ex=None,):
21757 
    self.ex = ex
21758 
 
21759 
  def read(self, iprot):
21760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21762 
      return
21763 
    iprot.readStructBegin()
21764 
    while True:
21765 
      (fname, ftype, fid) = iprot.readFieldBegin()
21766 
      if ftype == TType.STOP:
21767 
        break
21768 
      if fid == 1:
21769 
        if ftype == TType.STRUCT:
21770 
          self.ex = TransactionServiceException()
21771 
          self.ex.read(iprot)
21772 
        else:
21773 
          iprot.skip(ftype)
21774 
      else:
21775 
        iprot.skip(ftype)
21776 
      iprot.readFieldEnd()
21777 
    iprot.readStructEnd()
21778 
 
21779 
  def write(self, oprot):
21780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21782 
      return
21783 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21784 
    if self.ex is not None:
21785 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21786 
      self.ex.write(oprot)
21787 
      oprot.writeFieldEnd()
21788 
    oprot.writeFieldStop()
21789 
    oprot.writeStructEnd()
21790 
 
21791 
  def validate(self):
21792 
    return
21793 
 
21794 
 
21795 
  def __repr__(self):
21796 
    L = ['%s=%r' % (key, value)
21797 
      for key, value in self.__dict__.iteritems()]
21798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21799 
 
21800 
  def __eq__(self, other):
21801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21802 
 
21803 
  def __ne__(self, other):
21804 
    return not (self == other)
21805 
 
21806 
class markOrdersAsReversalInitiated_args:
21807 
  """
21808 
  Attributes:
21809 
   - vendorId
21810 
   - itemId
21811 
   - quantity
21812 
   - estimate
4369 rajveer 21813 
   - isReminder
4303 rajveer 21814 
  """
21815 
 
21816 
  thrift_spec = (
21817 
    None, # 0
21818 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21819 
    (2, TType.I64, 'itemId', None, None, ), # 2
21820 
    (3, TType.I64, 'quantity', None, None, ), # 3
21821 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21822 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21823 
  )
21824 
 
4369 rajveer 21825 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21826 
    self.vendorId = vendorId
21827 
    self.itemId = itemId
21828 
    self.quantity = quantity
21829 
    self.estimate = estimate
4369 rajveer 21830 
    self.isReminder = isReminder
4303 rajveer 21831 
 
21832 
  def read(self, iprot):
21833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21835 
      return
21836 
    iprot.readStructBegin()
21837 
    while True:
21838 
      (fname, ftype, fid) = iprot.readFieldBegin()
21839 
      if ftype == TType.STOP:
21840 
        break
21841 
      if fid == 1:
21842 
        if ftype == TType.I64:
21843 
          self.vendorId = iprot.readI64();
21844 
        else:
21845 
          iprot.skip(ftype)
21846 
      elif fid == 2:
21847 
        if ftype == TType.I64:
21848 
          self.itemId = iprot.readI64();
21849 
        else:
21850 
          iprot.skip(ftype)
21851 
      elif fid == 3:
21852 
        if ftype == TType.I64:
21853 
          self.quantity = iprot.readI64();
21854 
        else:
21855 
          iprot.skip(ftype)
21856 
      elif fid == 4:
21857 
        if ftype == TType.I64:
21858 
          self.estimate = iprot.readI64();
21859 
        else:
21860 
          iprot.skip(ftype)
4369 rajveer 21861 
      elif fid == 5:
21862 
        if ftype == TType.BOOL:
21863 
          self.isReminder = iprot.readBool();
21864 
        else:
21865 
          iprot.skip(ftype)
4303 rajveer 21866 
      else:
21867 
        iprot.skip(ftype)
21868 
      iprot.readFieldEnd()
21869 
    iprot.readStructEnd()
21870 
 
21871 
  def write(self, oprot):
21872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21874 
      return
21875 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21876 
    if self.vendorId is not None:
21877 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21878 
      oprot.writeI64(self.vendorId)
21879 
      oprot.writeFieldEnd()
21880 
    if self.itemId is not None:
21881 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21882 
      oprot.writeI64(self.itemId)
21883 
      oprot.writeFieldEnd()
21884 
    if self.quantity is not None:
21885 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21886 
      oprot.writeI64(self.quantity)
21887 
      oprot.writeFieldEnd()
21888 
    if self.estimate is not None:
21889 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21890 
      oprot.writeI64(self.estimate)
21891 
      oprot.writeFieldEnd()
4369 rajveer 21892 
    if self.isReminder is not None:
21893 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21894 
      oprot.writeBool(self.isReminder)
21895 
      oprot.writeFieldEnd()
4303 rajveer 21896 
    oprot.writeFieldStop()
21897 
    oprot.writeStructEnd()
21898 
 
21899 
  def validate(self):
21900 
    return
21901 
 
21902 
 
21903 
  def __repr__(self):
21904 
    L = ['%s=%r' % (key, value)
21905 
      for key, value in self.__dict__.iteritems()]
21906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21907 
 
21908 
  def __eq__(self, other):
21909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21910 
 
21911 
  def __ne__(self, other):
21912 
    return not (self == other)
21913 
 
21914 
class markOrdersAsReversalInitiated_result:
21915 
  """
21916 
  Attributes:
21917 
   - ex
21918 
  """
21919 
 
21920 
  thrift_spec = (
21921 
    None, # 0
21922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21923 
  )
21924 
 
21925 
  def __init__(self, ex=None,):
21926 
    self.ex = ex
21927 
 
21928 
  def read(self, iprot):
21929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21931 
      return
21932 
    iprot.readStructBegin()
21933 
    while True:
21934 
      (fname, ftype, fid) = iprot.readFieldBegin()
21935 
      if ftype == TType.STOP:
21936 
        break
21937 
      if fid == 1:
21938 
        if ftype == TType.STRUCT:
21939 
          self.ex = TransactionServiceException()
21940 
          self.ex.read(iprot)
21941 
        else:
21942 
          iprot.skip(ftype)
21943 
      else:
21944 
        iprot.skip(ftype)
21945 
      iprot.readFieldEnd()
21946 
    iprot.readStructEnd()
21947 
 
21948 
  def write(self, oprot):
21949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21951 
      return
21952 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21953 
    if self.ex is not None:
21954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21955 
      self.ex.write(oprot)
21956 
      oprot.writeFieldEnd()
21957 
    oprot.writeFieldStop()
21958 
    oprot.writeStructEnd()
21959 
 
21960 
  def validate(self):
21961 
    return
21962 
 
21963 
 
21964 
  def __repr__(self):
21965 
    L = ['%s=%r' % (key, value)
21966 
      for key, value in self.__dict__.iteritems()]
21967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21968 
 
21969 
  def __eq__(self, other):
21970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21971 
 
21972 
  def __ne__(self, other):
21973 
    return not (self == other)
21974 
 
21975 
class markOrdersAsNotAvailabke_args:
21976 
  """
21977 
  Attributes:
21978 
   - vendorId
21979 
   - itemId
21980 
   - quantity
21981 
   - estimate
4369 rajveer 21982 
   - isReminder
4303 rajveer 21983 
  """
21984 
 
21985 
  thrift_spec = (
21986 
    None, # 0
21987 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21988 
    (2, TType.I64, 'itemId', None, None, ), # 2
21989 
    (3, TType.I64, 'quantity', None, None, ), # 3
21990 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21991 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21992 
  )
21993 
 
4369 rajveer 21994 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21995 
    self.vendorId = vendorId
21996 
    self.itemId = itemId
21997 
    self.quantity = quantity
21998 
    self.estimate = estimate
4369 rajveer 21999 
    self.isReminder = isReminder
4303 rajveer 22000 
 
22001 
  def read(self, iprot):
22002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22004 
      return
22005 
    iprot.readStructBegin()
22006 
    while True:
22007 
      (fname, ftype, fid) = iprot.readFieldBegin()
22008 
      if ftype == TType.STOP:
22009 
        break
22010 
      if fid == 1:
22011 
        if ftype == TType.I64:
22012 
          self.vendorId = iprot.readI64();
22013 
        else:
22014 
          iprot.skip(ftype)
22015 
      elif fid == 2:
22016 
        if ftype == TType.I64:
22017 
          self.itemId = iprot.readI64();
22018 
        else:
22019 
          iprot.skip(ftype)
22020 
      elif fid == 3:
22021 
        if ftype == TType.I64:
22022 
          self.quantity = iprot.readI64();
22023 
        else:
22024 
          iprot.skip(ftype)
22025 
      elif fid == 4:
22026 
        if ftype == TType.I64:
22027 
          self.estimate = iprot.readI64();
22028 
        else:
22029 
          iprot.skip(ftype)
4369 rajveer 22030 
      elif fid == 5:
22031 
        if ftype == TType.BOOL:
22032 
          self.isReminder = iprot.readBool();
22033 
        else:
22034 
          iprot.skip(ftype)
4303 rajveer 22035 
      else:
22036 
        iprot.skip(ftype)
22037 
      iprot.readFieldEnd()
22038 
    iprot.readStructEnd()
22039 
 
22040 
  def write(self, oprot):
22041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22043 
      return
22044 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22045 
    if self.vendorId is not None:
22046 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22047 
      oprot.writeI64(self.vendorId)
22048 
      oprot.writeFieldEnd()
22049 
    if self.itemId is not None:
22050 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22051 
      oprot.writeI64(self.itemId)
22052 
      oprot.writeFieldEnd()
22053 
    if self.quantity is not None:
22054 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22055 
      oprot.writeI64(self.quantity)
22056 
      oprot.writeFieldEnd()
22057 
    if self.estimate is not None:
22058 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22059 
      oprot.writeI64(self.estimate)
22060 
      oprot.writeFieldEnd()
4369 rajveer 22061 
    if self.isReminder is not None:
22062 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22063 
      oprot.writeBool(self.isReminder)
22064 
      oprot.writeFieldEnd()
4303 rajveer 22065 
    oprot.writeFieldStop()
22066 
    oprot.writeStructEnd()
22067 
 
22068 
  def validate(self):
22069 
    return
22070 
 
22071 
 
22072 
  def __repr__(self):
22073 
    L = ['%s=%r' % (key, value)
22074 
      for key, value in self.__dict__.iteritems()]
22075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22076 
 
22077 
  def __eq__(self, other):
22078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22079 
 
22080 
  def __ne__(self, other):
22081 
    return not (self == other)
22082 
 
22083 
class markOrdersAsNotAvailabke_result:
22084 
  """
22085 
  Attributes:
22086 
   - ex
22087 
  """
22088 
 
22089 
  thrift_spec = (
22090 
    None, # 0
22091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22092 
  )
22093 
 
22094 
  def __init__(self, ex=None,):
22095 
    self.ex = ex
22096 
 
22097 
  def read(self, iprot):
22098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22100 
      return
22101 
    iprot.readStructBegin()
22102 
    while True:
22103 
      (fname, ftype, fid) = iprot.readFieldBegin()
22104 
      if ftype == TType.STOP:
22105 
        break
22106 
      if fid == 1:
22107 
        if ftype == TType.STRUCT:
22108 
          self.ex = TransactionServiceException()
22109 
          self.ex.read(iprot)
22110 
        else:
22111 
          iprot.skip(ftype)
22112 
      else:
22113 
        iprot.skip(ftype)
22114 
      iprot.readFieldEnd()
22115 
    iprot.readStructEnd()
22116 
 
22117 
  def write(self, oprot):
22118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22120 
      return
22121 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22122 
    if self.ex is not None:
22123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22124 
      self.ex.write(oprot)
22125 
      oprot.writeFieldEnd()
22126 
    oprot.writeFieldStop()
22127 
    oprot.writeStructEnd()
22128 
 
22129 
  def validate(self):
22130 
    return
22131 
 
22132 
 
22133 
  def __repr__(self):
22134 
    L = ['%s=%r' % (key, value)
22135 
      for key, value in self.__dict__.iteritems()]
22136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22137 
 
22138 
  def __eq__(self, other):
22139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22140 
 
22141 
  def __ne__(self, other):
22142 
    return not (self == other)
4369 rajveer 22143 
 
22144 
class markOrdersAsTimeout_args:
22145 
  """
22146 
  Attributes:
22147 
   - vendorId
22148 
  """
22149 
 
22150 
  thrift_spec = (
22151 
    None, # 0
22152 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22153 
  )
22154 
 
22155 
  def __init__(self, vendorId=None,):
22156 
    self.vendorId = vendorId
22157 
 
22158 
  def read(self, iprot):
22159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22161 
      return
22162 
    iprot.readStructBegin()
22163 
    while True:
22164 
      (fname, ftype, fid) = iprot.readFieldBegin()
22165 
      if ftype == TType.STOP:
22166 
        break
22167 
      if fid == 1:
22168 
        if ftype == TType.I64:
22169 
          self.vendorId = iprot.readI64();
22170 
        else:
22171 
          iprot.skip(ftype)
22172 
      else:
22173 
        iprot.skip(ftype)
22174 
      iprot.readFieldEnd()
22175 
    iprot.readStructEnd()
22176 
 
22177 
  def write(self, oprot):
22178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22180 
      return
22181 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22182 
    if self.vendorId is not None:
22183 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22184 
      oprot.writeI64(self.vendorId)
22185 
      oprot.writeFieldEnd()
22186 
    oprot.writeFieldStop()
22187 
    oprot.writeStructEnd()
22188 
 
22189 
  def validate(self):
22190 
    return
22191 
 
22192 
 
22193 
  def __repr__(self):
22194 
    L = ['%s=%r' % (key, value)
22195 
      for key, value in self.__dict__.iteritems()]
22196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22197 
 
22198 
  def __eq__(self, other):
22199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22200 
 
22201 
  def __ne__(self, other):
22202 
    return not (self == other)
22203 
 
22204 
class markOrdersAsTimeout_result:
22205 
  """
22206 
  Attributes:
22207 
   - success
22208 
   - ex
22209 
  """
22210 
 
22211 
  thrift_spec = (
22212 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22214 
  )
22215 
 
22216 
  def __init__(self, success=None, ex=None,):
22217 
    self.success = success
22218 
    self.ex = ex
22219 
 
22220 
  def read(self, iprot):
22221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22223 
      return
22224 
    iprot.readStructBegin()
22225 
    while True:
22226 
      (fname, ftype, fid) = iprot.readFieldBegin()
22227 
      if ftype == TType.STOP:
22228 
        break
22229 
      if fid == 0:
22230 
        if ftype == TType.MAP:
22231 
          self.success = {}
6188 rajveer 22232 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22233 
          for _i505 in xrange(_size501):
22234 
            _key506 = iprot.readI32();
22235 
            _val507 = TimeoutSummary()
22236 
            _val507.read(iprot)
22237 
            self.success[_key506] = _val507
4369 rajveer 22238 
          iprot.readMapEnd()
22239 
        else:
22240 
          iprot.skip(ftype)
22241 
      elif fid == 1:
22242 
        if ftype == TType.STRUCT:
22243 
          self.ex = TransactionServiceException()
22244 
          self.ex.read(iprot)
22245 
        else:
22246 
          iprot.skip(ftype)
22247 
      else:
22248 
        iprot.skip(ftype)
22249 
      iprot.readFieldEnd()
22250 
    iprot.readStructEnd()
22251 
 
22252 
  def write(self, oprot):
22253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22255 
      return
22256 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22257 
    if self.success is not None:
22258 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22259 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22260 
      for kiter508,viter509 in self.success.items():
22261 
        oprot.writeI32(kiter508)
22262 
        viter509.write(oprot)
4369 rajveer 22263 
      oprot.writeMapEnd()
22264 
      oprot.writeFieldEnd()
22265 
    if self.ex is not None:
22266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22267 
      self.ex.write(oprot)
22268 
      oprot.writeFieldEnd()
22269 
    oprot.writeFieldStop()
22270 
    oprot.writeStructEnd()
22271 
 
22272 
  def validate(self):
22273 
    return
22274 
 
22275 
 
22276 
  def __repr__(self):
22277 
    L = ['%s=%r' % (key, value)
22278 
      for key, value in self.__dict__.iteritems()]
22279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22280 
 
22281 
  def __eq__(self, other):
22282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22283 
 
22284 
  def __ne__(self, other):
22285 
    return not (self == other)
4386 anupam.sin 22286 
 
4662 rajveer 22287 
class markOrderAsLostInTransit_args:
22288 
  """
22289 
  Attributes:
22290 
   - orderId
22291 
  """
22292 
 
22293 
  thrift_spec = (
22294 
    None, # 0
22295 
    (1, TType.I64, 'orderId', None, None, ), # 1
22296 
  )
22297 
 
22298 
  def __init__(self, orderId=None,):
22299 
    self.orderId = orderId
22300 
 
22301 
  def read(self, iprot):
22302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22304 
      return
22305 
    iprot.readStructBegin()
22306 
    while True:
22307 
      (fname, ftype, fid) = iprot.readFieldBegin()
22308 
      if ftype == TType.STOP:
22309 
        break
22310 
      if fid == 1:
22311 
        if ftype == TType.I64:
22312 
          self.orderId = iprot.readI64();
22313 
        else:
22314 
          iprot.skip(ftype)
22315 
      else:
22316 
        iprot.skip(ftype)
22317 
      iprot.readFieldEnd()
22318 
    iprot.readStructEnd()
22319 
 
22320 
  def write(self, oprot):
22321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22323 
      return
22324 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22325 
    if self.orderId is not None:
22326 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22327 
      oprot.writeI64(self.orderId)
22328 
      oprot.writeFieldEnd()
22329 
    oprot.writeFieldStop()
22330 
    oprot.writeStructEnd()
22331 
 
22332 
  def validate(self):
22333 
    return
22334 
 
22335 
 
22336 
  def __repr__(self):
22337 
    L = ['%s=%r' % (key, value)
22338 
      for key, value in self.__dict__.iteritems()]
22339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22340 
 
22341 
  def __eq__(self, other):
22342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22343 
 
22344 
  def __ne__(self, other):
22345 
    return not (self == other)
22346 
 
22347 
class markOrderAsLostInTransit_result:
22348 
  """
22349 
  Attributes:
22350 
   - success
22351 
   - ex
22352 
  """
22353 
 
22354 
  thrift_spec = (
22355 
    (0, TType.BOOL, 'success', None, None, ), # 0
22356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22357 
  )
22358 
 
22359 
  def __init__(self, success=None, ex=None,):
22360 
    self.success = success
22361 
    self.ex = ex
22362 
 
22363 
  def read(self, iprot):
22364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22366 
      return
22367 
    iprot.readStructBegin()
22368 
    while True:
22369 
      (fname, ftype, fid) = iprot.readFieldBegin()
22370 
      if ftype == TType.STOP:
22371 
        break
22372 
      if fid == 0:
22373 
        if ftype == TType.BOOL:
22374 
          self.success = iprot.readBool();
22375 
        else:
22376 
          iprot.skip(ftype)
22377 
      elif fid == 1:
22378 
        if ftype == TType.STRUCT:
22379 
          self.ex = TransactionServiceException()
22380 
          self.ex.read(iprot)
22381 
        else:
22382 
          iprot.skip(ftype)
22383 
      else:
22384 
        iprot.skip(ftype)
22385 
      iprot.readFieldEnd()
22386 
    iprot.readStructEnd()
22387 
 
22388 
  def write(self, oprot):
22389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22391 
      return
22392 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22393 
    if self.success is not None:
22394 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22395 
      oprot.writeBool(self.success)
22396 
      oprot.writeFieldEnd()
22397 
    if self.ex is not None:
22398 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22399 
      self.ex.write(oprot)
22400 
      oprot.writeFieldEnd()
22401 
    oprot.writeFieldStop()
22402 
    oprot.writeStructEnd()
22403 
 
22404 
  def validate(self):
22405 
    return
22406 
 
22407 
 
22408 
  def __repr__(self):
22409 
    L = ['%s=%r' % (key, value)
22410 
      for key, value in self.__dict__.iteritems()]
22411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22412 
 
22413 
  def __eq__(self, other):
22414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22415 
 
22416 
  def __ne__(self, other):
22417 
    return not (self == other)
22418 
 
4386 anupam.sin 22419 
class getOrderForAwb_args:
22420 
  """
22421 
  Attributes:
22422 
   - awb
22423 
  """
22424 
 
22425 
  thrift_spec = (
22426 
    None, # 0
22427 
    (1, TType.STRING, 'awb', None, None, ), # 1
22428 
  )
22429 
 
22430 
  def __init__(self, awb=None,):
22431 
    self.awb = awb
22432 
 
22433 
  def read(self, iprot):
22434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22436 
      return
22437 
    iprot.readStructBegin()
22438 
    while True:
22439 
      (fname, ftype, fid) = iprot.readFieldBegin()
22440 
      if ftype == TType.STOP:
22441 
        break
22442 
      if fid == 1:
22443 
        if ftype == TType.STRING:
22444 
          self.awb = iprot.readString();
22445 
        else:
22446 
          iprot.skip(ftype)
22447 
      else:
22448 
        iprot.skip(ftype)
22449 
      iprot.readFieldEnd()
22450 
    iprot.readStructEnd()
22451 
 
22452 
  def write(self, oprot):
22453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22455 
      return
22456 
    oprot.writeStructBegin('getOrderForAwb_args')
22457 
    if self.awb is not None:
22458 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22459 
      oprot.writeString(self.awb)
22460 
      oprot.writeFieldEnd()
22461 
    oprot.writeFieldStop()
22462 
    oprot.writeStructEnd()
22463 
 
22464 
  def validate(self):
22465 
    return
22466 
 
22467 
 
22468 
  def __repr__(self):
22469 
    L = ['%s=%r' % (key, value)
22470 
      for key, value in self.__dict__.iteritems()]
22471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22472 
 
22473 
  def __eq__(self, other):
22474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22475 
 
22476 
  def __ne__(self, other):
22477 
    return not (self == other)
22478 
 
22479 
class getOrderForAwb_result:
22480 
  """
22481 
  Attributes:
22482 
   - success
22483 
   - ex
22484 
  """
22485 
 
22486 
  thrift_spec = (
22487 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22489 
  )
22490 
 
22491 
  def __init__(self, success=None, ex=None,):
22492 
    self.success = success
22493 
    self.ex = ex
22494 
 
22495 
  def read(self, iprot):
22496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22498 
      return
22499 
    iprot.readStructBegin()
22500 
    while True:
22501 
      (fname, ftype, fid) = iprot.readFieldBegin()
22502 
      if ftype == TType.STOP:
22503 
        break
22504 
      if fid == 0:
22505 
        if ftype == TType.STRUCT:
22506 
          self.success = Order()
22507 
          self.success.read(iprot)
22508 
        else:
22509 
          iprot.skip(ftype)
22510 
      elif fid == 1:
22511 
        if ftype == TType.STRUCT:
22512 
          self.ex = TransactionServiceException()
22513 
          self.ex.read(iprot)
22514 
        else:
22515 
          iprot.skip(ftype)
22516 
      else:
22517 
        iprot.skip(ftype)
22518 
      iprot.readFieldEnd()
22519 
    iprot.readStructEnd()
22520 
 
22521 
  def write(self, oprot):
22522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22524 
      return
22525 
    oprot.writeStructBegin('getOrderForAwb_result')
22526 
    if self.success is not None:
22527 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22528 
      self.success.write(oprot)
22529 
      oprot.writeFieldEnd()
22530 
    if self.ex is not None:
22531 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22532 
      self.ex.write(oprot)
22533 
      oprot.writeFieldEnd()
22534 
    oprot.writeFieldStop()
22535 
    oprot.writeStructEnd()
22536 
 
22537 
  def validate(self):
22538 
    return
22539 
 
22540 
 
22541 
  def __repr__(self):
22542 
    L = ['%s=%r' % (key, value)
22543 
      for key, value in self.__dict__.iteritems()]
22544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22545 
 
22546 
  def __eq__(self, other):
22547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22548 
 
22549 
  def __ne__(self, other):
22550 
    return not (self == other)
4506 phani.kuma 22551 
 
22552 
class getOrdersForProviderForStatus_args:
22553 
  """
22554 
  Attributes:
22555 
   - logistics_provider_id
4910 phani.kuma 22556 
   - order_status_list
4506 phani.kuma 22557 
  """
22558 
 
22559 
  thrift_spec = (
22560 
    None, # 0
22561 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22562 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22563 
  )
22564 
 
4910 phani.kuma 22565 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22566 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22567 
    self.order_status_list = order_status_list
4506 phani.kuma 22568 
 
22569 
  def read(self, iprot):
22570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22572 
      return
22573 
    iprot.readStructBegin()
22574 
    while True:
22575 
      (fname, ftype, fid) = iprot.readFieldBegin()
22576 
      if ftype == TType.STOP:
22577 
        break
22578 
      if fid == 1:
22579 
        if ftype == TType.I64:
22580 
          self.logistics_provider_id = iprot.readI64();
22581 
        else:
22582 
          iprot.skip(ftype)
22583 
      elif fid == 2:
4910 phani.kuma 22584 
        if ftype == TType.LIST:
22585 
          self.order_status_list = []
6188 rajveer 22586 
          (_etype513, _size510) = iprot.readListBegin()
22587 
          for _i514 in xrange(_size510):
22588 
            _elem515 = iprot.readI32();
22589 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22590 
          iprot.readListEnd()
4506 phani.kuma 22591 
        else:
22592 
          iprot.skip(ftype)
22593 
      else:
22594 
        iprot.skip(ftype)
22595 
      iprot.readFieldEnd()
22596 
    iprot.readStructEnd()
22597 
 
22598 
  def write(self, oprot):
22599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22601 
      return
22602 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22603 
    if self.logistics_provider_id is not None:
22604 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22605 
      oprot.writeI64(self.logistics_provider_id)
22606 
      oprot.writeFieldEnd()
4910 phani.kuma 22607 
    if self.order_status_list is not None:
22608 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22609 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22610 
      for iter516 in self.order_status_list:
22611 
        oprot.writeI32(iter516)
4910 phani.kuma 22612 
      oprot.writeListEnd()
4506 phani.kuma 22613 
      oprot.writeFieldEnd()
22614 
    oprot.writeFieldStop()
22615 
    oprot.writeStructEnd()
22616 
 
22617 
  def validate(self):
22618 
    return
22619 
 
22620 
 
22621 
  def __repr__(self):
22622 
    L = ['%s=%r' % (key, value)
22623 
      for key, value in self.__dict__.iteritems()]
22624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22625 
 
22626 
  def __eq__(self, other):
22627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22628 
 
22629 
  def __ne__(self, other):
22630 
    return not (self == other)
22631 
 
22632 
class getOrdersForProviderForStatus_result:
22633 
  """
22634 
  Attributes:
22635 
   - success
22636 
   - ex
22637 
  """
22638 
 
22639 
  thrift_spec = (
22640 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22642 
  )
22643 
 
22644 
  def __init__(self, success=None, ex=None,):
22645 
    self.success = success
22646 
    self.ex = ex
22647 
 
22648 
  def read(self, iprot):
22649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22651 
      return
22652 
    iprot.readStructBegin()
22653 
    while True:
22654 
      (fname, ftype, fid) = iprot.readFieldBegin()
22655 
      if ftype == TType.STOP:
22656 
        break
22657 
      if fid == 0:
22658 
        if ftype == TType.LIST:
22659 
          self.success = []
6188 rajveer 22660 
          (_etype520, _size517) = iprot.readListBegin()
22661 
          for _i521 in xrange(_size517):
22662 
            _elem522 = Order()
22663 
            _elem522.read(iprot)
22664 
            self.success.append(_elem522)
4506 phani.kuma 22665 
          iprot.readListEnd()
22666 
        else:
22667 
          iprot.skip(ftype)
22668 
      elif fid == 1:
22669 
        if ftype == TType.STRUCT:
22670 
          self.ex = TransactionServiceException()
22671 
          self.ex.read(iprot)
22672 
        else:
22673 
          iprot.skip(ftype)
22674 
      else:
22675 
        iprot.skip(ftype)
22676 
      iprot.readFieldEnd()
22677 
    iprot.readStructEnd()
22678 
 
22679 
  def write(self, oprot):
22680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22682 
      return
22683 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22684 
    if self.success is not None:
22685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22687 
      for iter523 in self.success:
22688 
        iter523.write(oprot)
4506 phani.kuma 22689 
      oprot.writeListEnd()
22690 
      oprot.writeFieldEnd()
22691 
    if self.ex is not None:
22692 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22693 
      self.ex.write(oprot)
22694 
      oprot.writeFieldEnd()
22695 
    oprot.writeFieldStop()
22696 
    oprot.writeStructEnd()
22697 
 
22698 
  def validate(self):
22699 
    return
22700 
 
22701 
 
22702 
  def __repr__(self):
22703 
    L = ['%s=%r' % (key, value)
22704 
      for key, value in self.__dict__.iteritems()]
22705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22706 
 
22707 
  def __eq__(self, other):
22708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22709 
 
22710 
  def __ne__(self, other):
22711 
    return not (self == other)
4600 varun.gupt 22712 
 
22713 
class getBilledOrdersForVendor_args:
22714 
  """
22715 
  Attributes:
22716 
   - vendorId
22717 
   - billingDateFrom
22718 
   - billingDateTo
22719 
  """
22720 
 
22721 
  thrift_spec = (
22722 
    None, # 0
22723 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22724 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22725 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22726 
  )
22727 
 
22728 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22729 
    self.vendorId = vendorId
22730 
    self.billingDateFrom = billingDateFrom
22731 
    self.billingDateTo = billingDateTo
22732 
 
22733 
  def read(self, iprot):
22734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22736 
      return
22737 
    iprot.readStructBegin()
22738 
    while True:
22739 
      (fname, ftype, fid) = iprot.readFieldBegin()
22740 
      if ftype == TType.STOP:
22741 
        break
22742 
      if fid == 1:
22743 
        if ftype == TType.I64:
22744 
          self.vendorId = iprot.readI64();
22745 
        else:
22746 
          iprot.skip(ftype)
22747 
      elif fid == 2:
22748 
        if ftype == TType.I64:
22749 
          self.billingDateFrom = iprot.readI64();
22750 
        else:
22751 
          iprot.skip(ftype)
22752 
      elif fid == 3:
22753 
        if ftype == TType.I64:
22754 
          self.billingDateTo = iprot.readI64();
22755 
        else:
22756 
          iprot.skip(ftype)
22757 
      else:
22758 
        iprot.skip(ftype)
22759 
      iprot.readFieldEnd()
22760 
    iprot.readStructEnd()
22761 
 
22762 
  def write(self, oprot):
22763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22765 
      return
22766 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22767 
    if self.vendorId is not None:
22768 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22769 
      oprot.writeI64(self.vendorId)
22770 
      oprot.writeFieldEnd()
22771 
    if self.billingDateFrom is not None:
22772 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22773 
      oprot.writeI64(self.billingDateFrom)
22774 
      oprot.writeFieldEnd()
22775 
    if self.billingDateTo is not None:
22776 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22777 
      oprot.writeI64(self.billingDateTo)
22778 
      oprot.writeFieldEnd()
22779 
    oprot.writeFieldStop()
22780 
    oprot.writeStructEnd()
22781 
 
22782 
  def validate(self):
22783 
    return
22784 
 
22785 
 
22786 
  def __repr__(self):
22787 
    L = ['%s=%r' % (key, value)
22788 
      for key, value in self.__dict__.iteritems()]
22789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22790 
 
22791 
  def __eq__(self, other):
22792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22793 
 
22794 
  def __ne__(self, other):
22795 
    return not (self == other)
22796 
 
22797 
class getBilledOrdersForVendor_result:
22798 
  """
22799 
  Attributes:
22800 
   - success
22801 
   - ex
22802 
  """
22803 
 
22804 
  thrift_spec = (
22805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22807 
  )
22808 
 
22809 
  def __init__(self, success=None, ex=None,):
22810 
    self.success = success
22811 
    self.ex = ex
22812 
 
22813 
  def read(self, iprot):
22814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22816 
      return
22817 
    iprot.readStructBegin()
22818 
    while True:
22819 
      (fname, ftype, fid) = iprot.readFieldBegin()
22820 
      if ftype == TType.STOP:
22821 
        break
22822 
      if fid == 0:
22823 
        if ftype == TType.LIST:
22824 
          self.success = []
6188 rajveer 22825 
          (_etype527, _size524) = iprot.readListBegin()
22826 
          for _i528 in xrange(_size524):
22827 
            _elem529 = Order()
22828 
            _elem529.read(iprot)
22829 
            self.success.append(_elem529)
4600 varun.gupt 22830 
          iprot.readListEnd()
22831 
        else:
22832 
          iprot.skip(ftype)
22833 
      elif fid == 1:
22834 
        if ftype == TType.STRUCT:
22835 
          self.ex = TransactionServiceException()
22836 
          self.ex.read(iprot)
22837 
        else:
22838 
          iprot.skip(ftype)
22839 
      else:
22840 
        iprot.skip(ftype)
22841 
      iprot.readFieldEnd()
22842 
    iprot.readStructEnd()
22843 
 
22844 
  def write(self, oprot):
22845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22847 
      return
22848 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22849 
    if self.success is not None:
22850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22852 
      for iter530 in self.success:
22853 
        iter530.write(oprot)
4600 varun.gupt 22854 
      oprot.writeListEnd()
22855 
      oprot.writeFieldEnd()
22856 
    if self.ex is not None:
22857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22858 
      self.ex.write(oprot)
22859 
      oprot.writeFieldEnd()
22860 
    oprot.writeFieldStop()
22861 
    oprot.writeStructEnd()
22862 
 
22863 
  def validate(self):
22864 
    return
22865 
 
22866 
 
22867 
  def __repr__(self):
22868 
    L = ['%s=%r' % (key, value)
22869 
      for key, value in self.__dict__.iteritems()]
22870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22871 
 
22872 
  def __eq__(self, other):
22873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22874 
 
22875 
  def __ne__(self, other):
22876 
    return not (self == other)
22877 
 
4607 rajveer 22878 
class getSlippedSippingDateOrders_args:
22879 
 
22880 
  thrift_spec = (
22881 
  )
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 
      else:
22893 
        iprot.skip(ftype)
22894 
      iprot.readFieldEnd()
22895 
    iprot.readStructEnd()
22896 
 
22897 
  def write(self, oprot):
22898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22900 
      return
22901 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22902 
    oprot.writeFieldStop()
22903 
    oprot.writeStructEnd()
22904 
 
22905 
  def validate(self):
22906 
    return
22907 
 
22908 
 
22909 
  def __repr__(self):
22910 
    L = ['%s=%r' % (key, value)
22911 
      for key, value in self.__dict__.iteritems()]
22912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22913 
 
22914 
  def __eq__(self, other):
22915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22916 
 
22917 
  def __ne__(self, other):
22918 
    return not (self == other)
22919 
 
22920 
class getSlippedSippingDateOrders_result:
22921 
  """
22922 
  Attributes:
22923 
   - success
22924 
   - ex
22925 
  """
22926 
 
22927 
  thrift_spec = (
22928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22929 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22930 
  )
22931 
 
22932 
  def __init__(self, success=None, ex=None,):
22933 
    self.success = success
22934 
    self.ex = ex
22935 
 
22936 
  def read(self, iprot):
22937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22939 
      return
22940 
    iprot.readStructBegin()
22941 
    while True:
22942 
      (fname, ftype, fid) = iprot.readFieldBegin()
22943 
      if ftype == TType.STOP:
22944 
        break
22945 
      if fid == 0:
22946 
        if ftype == TType.LIST:
22947 
          self.success = []
6188 rajveer 22948 
          (_etype534, _size531) = iprot.readListBegin()
22949 
          for _i535 in xrange(_size531):
22950 
            _elem536 = Order()
22951 
            _elem536.read(iprot)
22952 
            self.success.append(_elem536)
4607 rajveer 22953 
          iprot.readListEnd()
22954 
        else:
22955 
          iprot.skip(ftype)
22956 
      elif fid == 1:
22957 
        if ftype == TType.STRUCT:
22958 
          self.ex = TransactionServiceException()
22959 
          self.ex.read(iprot)
22960 
        else:
22961 
          iprot.skip(ftype)
22962 
      else:
22963 
        iprot.skip(ftype)
22964 
      iprot.readFieldEnd()
22965 
    iprot.readStructEnd()
22966 
 
22967 
  def write(self, oprot):
22968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22970 
      return
22971 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22972 
    if self.success is not None:
22973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22975 
      for iter537 in self.success:
22976 
        iter537.write(oprot)
4607 rajveer 22977 
      oprot.writeListEnd()
22978 
      oprot.writeFieldEnd()
22979 
    if self.ex is not None:
22980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22981 
      self.ex.write(oprot)
22982 
      oprot.writeFieldEnd()
22983 
    oprot.writeFieldStop()
22984 
    oprot.writeStructEnd()
22985 
 
22986 
  def validate(self):
22987 
    return
22988 
 
22989 
 
22990 
  def __repr__(self):
22991 
    L = ['%s=%r' % (key, value)
22992 
      for key, value in self.__dict__.iteritems()]
22993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22994 
 
22995 
  def __eq__(self, other):
22996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22997 
 
22998 
  def __ne__(self, other):
22999 
    return not (self == other)
23000 
 
4709 rajveer 23001 
class getCancelledOrders_args:
23002 
  """
23003 
  Attributes:
23004 
   - cancelDateFrom
23005 
   - cancelDateTo
23006 
  """
23007 
 
23008 
  thrift_spec = (
23009 
    None, # 0
23010 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23011 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23012 
  )
23013 
 
23014 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23015 
    self.cancelDateFrom = cancelDateFrom
23016 
    self.cancelDateTo = cancelDateTo
23017 
 
23018 
  def read(self, iprot):
23019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23021 
      return
23022 
    iprot.readStructBegin()
23023 
    while True:
23024 
      (fname, ftype, fid) = iprot.readFieldBegin()
23025 
      if ftype == TType.STOP:
23026 
        break
23027 
      if fid == 1:
23028 
        if ftype == TType.I64:
23029 
          self.cancelDateFrom = iprot.readI64();
23030 
        else:
23031 
          iprot.skip(ftype)
23032 
      elif fid == 2:
23033 
        if ftype == TType.I64:
23034 
          self.cancelDateTo = iprot.readI64();
23035 
        else:
23036 
          iprot.skip(ftype)
23037 
      else:
23038 
        iprot.skip(ftype)
23039 
      iprot.readFieldEnd()
23040 
    iprot.readStructEnd()
23041 
 
23042 
  def write(self, oprot):
23043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23045 
      return
23046 
    oprot.writeStructBegin('getCancelledOrders_args')
23047 
    if self.cancelDateFrom is not None:
23048 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23049 
      oprot.writeI64(self.cancelDateFrom)
23050 
      oprot.writeFieldEnd()
23051 
    if self.cancelDateTo is not None:
23052 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23053 
      oprot.writeI64(self.cancelDateTo)
23054 
      oprot.writeFieldEnd()
23055 
    oprot.writeFieldStop()
23056 
    oprot.writeStructEnd()
23057 
 
23058 
  def validate(self):
23059 
    return
23060 
 
23061 
 
23062 
  def __repr__(self):
23063 
    L = ['%s=%r' % (key, value)
23064 
      for key, value in self.__dict__.iteritems()]
23065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23066 
 
23067 
  def __eq__(self, other):
23068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23069 
 
23070 
  def __ne__(self, other):
23071 
    return not (self == other)
23072 
 
23073 
class getCancelledOrders_result:
23074 
  """
23075 
  Attributes:
23076 
   - success
23077 
   - ex
23078 
  """
23079 
 
23080 
  thrift_spec = (
23081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23083 
  )
23084 
 
23085 
  def __init__(self, success=None, ex=None,):
23086 
    self.success = success
23087 
    self.ex = ex
23088 
 
23089 
  def read(self, iprot):
23090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23092 
      return
23093 
    iprot.readStructBegin()
23094 
    while True:
23095 
      (fname, ftype, fid) = iprot.readFieldBegin()
23096 
      if ftype == TType.STOP:
23097 
        break
23098 
      if fid == 0:
23099 
        if ftype == TType.LIST:
23100 
          self.success = []
6188 rajveer 23101 
          (_etype541, _size538) = iprot.readListBegin()
23102 
          for _i542 in xrange(_size538):
23103 
            _elem543 = Order()
23104 
            _elem543.read(iprot)
23105 
            self.success.append(_elem543)
4709 rajveer 23106 
          iprot.readListEnd()
23107 
        else:
23108 
          iprot.skip(ftype)
23109 
      elif fid == 1:
23110 
        if ftype == TType.STRUCT:
23111 
          self.ex = TransactionServiceException()
23112 
          self.ex.read(iprot)
23113 
        else:
23114 
          iprot.skip(ftype)
23115 
      else:
23116 
        iprot.skip(ftype)
23117 
      iprot.readFieldEnd()
23118 
    iprot.readStructEnd()
23119 
 
23120 
  def write(self, oprot):
23121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23123 
      return
23124 
    oprot.writeStructBegin('getCancelledOrders_result')
23125 
    if self.success is not None:
23126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23128 
      for iter544 in self.success:
23129 
        iter544.write(oprot)
4709 rajveer 23130 
      oprot.writeListEnd()
23131 
      oprot.writeFieldEnd()
23132 
    if self.ex is not None:
23133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23134 
      self.ex.write(oprot)
23135 
      oprot.writeFieldEnd()
23136 
    oprot.writeFieldStop()
23137 
    oprot.writeStructEnd()
23138 
 
23139 
  def validate(self):
23140 
    return
23141 
 
23142 
 
23143 
  def __repr__(self):
23144 
    L = ['%s=%r' % (key, value)
23145 
      for key, value in self.__dict__.iteritems()]
23146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23147 
 
23148 
  def __eq__(self, other):
23149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23150 
 
23151 
  def __ne__(self, other):
23152 
    return not (self == other)
23153 
 
4600 varun.gupt 23154 
class saveBluedartSettlements_args:
23155 
  """
23156 
  Attributes:
23157 
   - mapAWBAndAmount
23158 
  """
23159 
 
23160 
  thrift_spec = (
23161 
    None, # 0
23162 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23163 
  )
23164 
 
23165 
  def __init__(self, mapAWBAndAmount=None,):
23166 
    self.mapAWBAndAmount = mapAWBAndAmount
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.MAP:
23179 
          self.mapAWBAndAmount = {}
6188 rajveer 23180 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23181 
          for _i549 in xrange(_size545):
23182 
            _key550 = iprot.readI64();
23183 
            _val551 = iprot.readDouble();
23184 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23185 
          iprot.readMapEnd()
23186 
        else:
23187 
          iprot.skip(ftype)
23188 
      else:
23189 
        iprot.skip(ftype)
23190 
      iprot.readFieldEnd()
23191 
    iprot.readStructEnd()
23192 
 
23193 
  def write(self, oprot):
23194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23196 
      return
23197 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23198 
    if self.mapAWBAndAmount is not None:
23199 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23200 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23201 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23202 
        oprot.writeI64(kiter552)
23203 
        oprot.writeDouble(viter553)
4600 varun.gupt 23204 
      oprot.writeMapEnd()
23205 
      oprot.writeFieldEnd()
23206 
    oprot.writeFieldStop()
23207 
    oprot.writeStructEnd()
23208 
 
23209 
  def validate(self):
23210 
    return
23211 
 
23212 
 
23213 
  def __repr__(self):
23214 
    L = ['%s=%r' % (key, value)
23215 
      for key, value in self.__dict__.iteritems()]
23216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23217 
 
23218 
  def __eq__(self, other):
23219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23220 
 
23221 
  def __ne__(self, other):
23222 
    return not (self == other)
23223 
 
23224 
class saveBluedartSettlements_result:
23225 
  """
23226 
  Attributes:
23227 
   - ex
23228 
  """
23229 
 
23230 
  thrift_spec = (
23231 
    None, # 0
23232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23233 
  )
23234 
 
23235 
  def __init__(self, ex=None,):
23236 
    self.ex = ex
23237 
 
23238 
  def read(self, iprot):
23239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23241 
      return
23242 
    iprot.readStructBegin()
23243 
    while True:
23244 
      (fname, ftype, fid) = iprot.readFieldBegin()
23245 
      if ftype == TType.STOP:
23246 
        break
23247 
      if fid == 1:
23248 
        if ftype == TType.STRUCT:
23249 
          self.ex = TransactionServiceException()
23250 
          self.ex.read(iprot)
23251 
        else:
23252 
          iprot.skip(ftype)
23253 
      else:
23254 
        iprot.skip(ftype)
23255 
      iprot.readFieldEnd()
23256 
    iprot.readStructEnd()
23257 
 
23258 
  def write(self, oprot):
23259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23261 
      return
23262 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23263 
    if self.ex is not None:
23264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23265 
      self.ex.write(oprot)
23266 
      oprot.writeFieldEnd()
23267 
    oprot.writeFieldStop()
23268 
    oprot.writeStructEnd()
23269 
 
23270 
  def validate(self):
23271 
    return
23272 
 
23273 
 
23274 
  def __repr__(self):
23275 
    L = ['%s=%r' % (key, value)
23276 
      for key, value in self.__dict__.iteritems()]
23277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23278 
 
23279 
  def __eq__(self, other):
23280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23281 
 
23282 
  def __ne__(self, other):
23283 
    return not (self == other)
23284 
 
23285 
class savePaymentSettlements_args:
23286 
  """
23287 
  Attributes:
23288 
   - settlementDate
23289 
   - paymentGatewayId
4905 varun.gupt 23290 
   - referenceId
4600 varun.gupt 23291 
   - serviceTax
23292 
   - otherCharges
23293 
   - netCollection
23294 
  """
23295 
 
23296 
  thrift_spec = (
23297 
    None, # 0
23298 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23299 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23300 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23301 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23302 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23303 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23304 
  )
23305 
 
4905 varun.gupt 23306 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23307 
    self.settlementDate = settlementDate
23308 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23309 
    self.referenceId = referenceId
4600 varun.gupt 23310 
    self.serviceTax = serviceTax
23311 
    self.otherCharges = otherCharges
23312 
    self.netCollection = netCollection
23313 
 
23314 
  def read(self, iprot):
23315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23317 
      return
23318 
    iprot.readStructBegin()
23319 
    while True:
23320 
      (fname, ftype, fid) = iprot.readFieldBegin()
23321 
      if ftype == TType.STOP:
23322 
        break
23323 
      if fid == 1:
23324 
        if ftype == TType.I64:
23325 
          self.settlementDate = iprot.readI64();
23326 
        else:
23327 
          iprot.skip(ftype)
23328 
      elif fid == 2:
23329 
        if ftype == TType.I64:
23330 
          self.paymentGatewayId = iprot.readI64();
23331 
        else:
23332 
          iprot.skip(ftype)
23333 
      elif fid == 3:
23334 
        if ftype == TType.I64:
4905 varun.gupt 23335 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23336 
        else:
23337 
          iprot.skip(ftype)
23338 
      elif fid == 4:
23339 
        if ftype == TType.DOUBLE:
23340 
          self.serviceTax = iprot.readDouble();
23341 
        else:
23342 
          iprot.skip(ftype)
23343 
      elif fid == 5:
23344 
        if ftype == TType.DOUBLE:
23345 
          self.otherCharges = iprot.readDouble();
23346 
        else:
23347 
          iprot.skip(ftype)
23348 
      elif fid == 6:
23349 
        if ftype == TType.DOUBLE:
23350 
          self.netCollection = iprot.readDouble();
23351 
        else:
23352 
          iprot.skip(ftype)
23353 
      else:
23354 
        iprot.skip(ftype)
23355 
      iprot.readFieldEnd()
23356 
    iprot.readStructEnd()
23357 
 
23358 
  def write(self, oprot):
23359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23361 
      return
23362 
    oprot.writeStructBegin('savePaymentSettlements_args')
23363 
    if self.settlementDate is not None:
23364 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23365 
      oprot.writeI64(self.settlementDate)
23366 
      oprot.writeFieldEnd()
23367 
    if self.paymentGatewayId is not None:
23368 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23369 
      oprot.writeI64(self.paymentGatewayId)
23370 
      oprot.writeFieldEnd()
4905 varun.gupt 23371 
    if self.referenceId is not None:
23372 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23373 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23374 
      oprot.writeFieldEnd()
23375 
    if self.serviceTax is not None:
23376 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23377 
      oprot.writeDouble(self.serviceTax)
23378 
      oprot.writeFieldEnd()
23379 
    if self.otherCharges is not None:
23380 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23381 
      oprot.writeDouble(self.otherCharges)
23382 
      oprot.writeFieldEnd()
23383 
    if self.netCollection is not None:
23384 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23385 
      oprot.writeDouble(self.netCollection)
23386 
      oprot.writeFieldEnd()
23387 
    oprot.writeFieldStop()
23388 
    oprot.writeStructEnd()
23389 
 
23390 
  def validate(self):
23391 
    return
23392 
 
23393 
 
23394 
  def __repr__(self):
23395 
    L = ['%s=%r' % (key, value)
23396 
      for key, value in self.__dict__.iteritems()]
23397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23398 
 
23399 
  def __eq__(self, other):
23400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23401 
 
23402 
  def __ne__(self, other):
23403 
    return not (self == other)
23404 
 
23405 
class savePaymentSettlements_result:
23406 
  """
23407 
  Attributes:
23408 
   - ex
23409 
  """
23410 
 
23411 
  thrift_spec = (
23412 
    None, # 0
23413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23414 
  )
23415 
 
23416 
  def __init__(self, ex=None,):
23417 
    self.ex = ex
23418 
 
23419 
  def read(self, iprot):
23420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23422 
      return
23423 
    iprot.readStructBegin()
23424 
    while True:
23425 
      (fname, ftype, fid) = iprot.readFieldBegin()
23426 
      if ftype == TType.STOP:
23427 
        break
23428 
      if fid == 1:
23429 
        if ftype == TType.STRUCT:
23430 
          self.ex = TransactionServiceException()
23431 
          self.ex.read(iprot)
23432 
        else:
23433 
          iprot.skip(ftype)
23434 
      else:
23435 
        iprot.skip(ftype)
23436 
      iprot.readFieldEnd()
23437 
    iprot.readStructEnd()
23438 
 
23439 
  def write(self, oprot):
23440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23442 
      return
23443 
    oprot.writeStructBegin('savePaymentSettlements_result')
23444 
    if self.ex is not None:
23445 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23446 
      self.ex.write(oprot)
23447 
      oprot.writeFieldEnd()
23448 
    oprot.writeFieldStop()
23449 
    oprot.writeStructEnd()
23450 
 
23451 
  def validate(self):
23452 
    return
23453 
 
23454 
 
23455 
  def __repr__(self):
23456 
    L = ['%s=%r' % (key, value)
23457 
      for key, value in self.__dict__.iteritems()]
23458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23459 
 
23460 
  def __eq__(self, other):
23461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23462 
 
23463 
  def __ne__(self, other):
23464 
    return not (self == other)
23465 
 
23466 
class saveEBSSettlementSummary_args:
23467 
  """
23468 
  Attributes:
23469 
   - settlementId
23470 
   - settlementDate
23471 
   - transactionDateFrom
23472 
   - transactionDateTo
23473 
   - amount
23474 
  """
23475 
 
23476 
  thrift_spec = (
23477 
    None, # 0
23478 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23479 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23480 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23481 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23482 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23483 
  )
23484 
 
23485 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23486 
    self.settlementId = settlementId
23487 
    self.settlementDate = settlementDate
23488 
    self.transactionDateFrom = transactionDateFrom
23489 
    self.transactionDateTo = transactionDateTo
23490 
    self.amount = amount
23491 
 
23492 
  def read(self, iprot):
23493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23495 
      return
23496 
    iprot.readStructBegin()
23497 
    while True:
23498 
      (fname, ftype, fid) = iprot.readFieldBegin()
23499 
      if ftype == TType.STOP:
23500 
        break
23501 
      if fid == 1:
23502 
        if ftype == TType.I64:
23503 
          self.settlementId = iprot.readI64();
23504 
        else:
23505 
          iprot.skip(ftype)
23506 
      elif fid == 2:
23507 
        if ftype == TType.I64:
23508 
          self.settlementDate = iprot.readI64();
23509 
        else:
23510 
          iprot.skip(ftype)
23511 
      elif fid == 3:
23512 
        if ftype == TType.I64:
23513 
          self.transactionDateFrom = iprot.readI64();
23514 
        else:
23515 
          iprot.skip(ftype)
23516 
      elif fid == 4:
23517 
        if ftype == TType.I64:
23518 
          self.transactionDateTo = iprot.readI64();
23519 
        else:
23520 
          iprot.skip(ftype)
23521 
      elif fid == 5:
23522 
        if ftype == TType.DOUBLE:
23523 
          self.amount = iprot.readDouble();
23524 
        else:
23525 
          iprot.skip(ftype)
23526 
      else:
23527 
        iprot.skip(ftype)
23528 
      iprot.readFieldEnd()
23529 
    iprot.readStructEnd()
23530 
 
23531 
  def write(self, oprot):
23532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23534 
      return
23535 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23536 
    if self.settlementId is not None:
23537 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23538 
      oprot.writeI64(self.settlementId)
23539 
      oprot.writeFieldEnd()
23540 
    if self.settlementDate is not None:
23541 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23542 
      oprot.writeI64(self.settlementDate)
23543 
      oprot.writeFieldEnd()
23544 
    if self.transactionDateFrom is not None:
23545 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23546 
      oprot.writeI64(self.transactionDateFrom)
23547 
      oprot.writeFieldEnd()
23548 
    if self.transactionDateTo is not None:
23549 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23550 
      oprot.writeI64(self.transactionDateTo)
23551 
      oprot.writeFieldEnd()
23552 
    if self.amount is not None:
23553 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23554 
      oprot.writeDouble(self.amount)
23555 
      oprot.writeFieldEnd()
23556 
    oprot.writeFieldStop()
23557 
    oprot.writeStructEnd()
23558 
 
23559 
  def validate(self):
23560 
    return
23561 
 
23562 
 
23563 
  def __repr__(self):
23564 
    L = ['%s=%r' % (key, value)
23565 
      for key, value in self.__dict__.iteritems()]
23566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23567 
 
23568 
  def __eq__(self, other):
23569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23570 
 
23571 
  def __ne__(self, other):
23572 
    return not (self == other)
23573 
 
23574 
class saveEBSSettlementSummary_result:
23575 
  """
23576 
  Attributes:
23577 
   - ex
23578 
  """
23579 
 
23580 
  thrift_spec = (
23581 
    None, # 0
23582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23583 
  )
23584 
 
23585 
  def __init__(self, ex=None,):
23586 
    self.ex = ex
23587 
 
23588 
  def read(self, iprot):
23589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23591 
      return
23592 
    iprot.readStructBegin()
23593 
    while True:
23594 
      (fname, ftype, fid) = iprot.readFieldBegin()
23595 
      if ftype == TType.STOP:
23596 
        break
23597 
      if fid == 1:
23598 
        if ftype == TType.STRUCT:
23599 
          self.ex = TransactionServiceException()
23600 
          self.ex.read(iprot)
23601 
        else:
23602 
          iprot.skip(ftype)
23603 
      else:
23604 
        iprot.skip(ftype)
23605 
      iprot.readFieldEnd()
23606 
    iprot.readStructEnd()
23607 
 
23608 
  def write(self, oprot):
23609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23611 
      return
23612 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23613 
    if self.ex is not None:
23614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23615 
      self.ex.write(oprot)
23616 
      oprot.writeFieldEnd()
23617 
    oprot.writeFieldStop()
23618 
    oprot.writeStructEnd()
23619 
 
23620 
  def validate(self):
23621 
    return
23622 
 
23623 
 
23624 
  def __repr__(self):
23625 
    L = ['%s=%r' % (key, value)
23626 
      for key, value in self.__dict__.iteritems()]
23627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23628 
 
23629 
  def __eq__(self, other):
23630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23631 
 
23632 
  def __ne__(self, other):
23633 
    return not (self == other)
23634 
 
5386 phani.kuma 23635 
class getSettlementForPrepaid_args:
4600 varun.gupt 23636 
  """
23637 
  Attributes:
5189 varun.gupt 23638 
   - referenceId
23639 
   - isRefund
4600 varun.gupt 23640 
  """
23641 
 
23642 
  thrift_spec = (
23643 
    None, # 0
5189 varun.gupt 23644 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23645 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23646 
  )
23647 
 
5386 phani.kuma 23648 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23649 
    self.referenceId = referenceId
23650 
    self.isRefund = isRefund
4600 varun.gupt 23651 
 
23652 
  def read(self, iprot):
23653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23655 
      return
23656 
    iprot.readStructBegin()
23657 
    while True:
23658 
      (fname, ftype, fid) = iprot.readFieldBegin()
23659 
      if ftype == TType.STOP:
23660 
        break
23661 
      if fid == 1:
23662 
        if ftype == TType.I64:
5189 varun.gupt 23663 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23664 
        else:
23665 
          iprot.skip(ftype)
5189 varun.gupt 23666 
      elif fid == 2:
23667 
        if ftype == TType.BOOL:
23668 
          self.isRefund = iprot.readBool();
23669 
        else:
23670 
          iprot.skip(ftype)
4600 varun.gupt 23671 
      else:
23672 
        iprot.skip(ftype)
23673 
      iprot.readFieldEnd()
23674 
    iprot.readStructEnd()
23675 
 
23676 
  def write(self, oprot):
23677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23679 
      return
5386 phani.kuma 23680 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23681 
    if self.referenceId is not None:
23682 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23683 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23684 
      oprot.writeFieldEnd()
5386 phani.kuma 23685 
    if self.isRefund is not None:
23686 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23687 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23688 
      oprot.writeFieldEnd()
5386 phani.kuma 23689 
    oprot.writeFieldStop()
23690 
    oprot.writeStructEnd()
23691 
 
23692 
  def validate(self):
23693 
    return
23694 
 
23695 
 
23696 
  def __repr__(self):
23697 
    L = ['%s=%r' % (key, value)
23698 
      for key, value in self.__dict__.iteritems()]
23699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23700 
 
23701 
  def __eq__(self, other):
23702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23703 
 
23704 
  def __ne__(self, other):
23705 
    return not (self == other)
23706 
 
23707 
class getSettlementForPrepaid_result:
23708 
  """
23709 
  Attributes:
23710 
   - success
23711 
   - ex
23712 
  """
23713 
 
23714 
  thrift_spec = (
23715 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23716 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23717 
  )
23718 
 
23719 
  def __init__(self, success=None, ex=None,):
23720 
    self.success = success
23721 
    self.ex = ex
23722 
 
23723 
  def read(self, iprot):
23724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23726 
      return
23727 
    iprot.readStructBegin()
23728 
    while True:
23729 
      (fname, ftype, fid) = iprot.readFieldBegin()
23730 
      if ftype == TType.STOP:
23731 
        break
23732 
      if fid == 0:
23733 
        if ftype == TType.STRUCT:
23734 
          self.success = PaymentSettlement()
23735 
          self.success.read(iprot)
23736 
        else:
23737 
          iprot.skip(ftype)
23738 
      elif fid == 1:
23739 
        if ftype == TType.STRUCT:
23740 
          self.ex = TransactionServiceException()
23741 
          self.ex.read(iprot)
23742 
        else:
23743 
          iprot.skip(ftype)
23744 
      else:
23745 
        iprot.skip(ftype)
23746 
      iprot.readFieldEnd()
23747 
    iprot.readStructEnd()
23748 
 
23749 
  def write(self, oprot):
23750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23752 
      return
23753 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23754 
    if self.success is not None:
23755 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23756 
      self.success.write(oprot)
23757 
      oprot.writeFieldEnd()
23758 
    if self.ex is not None:
23759 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23760 
      self.ex.write(oprot)
23761 
      oprot.writeFieldEnd()
23762 
    oprot.writeFieldStop()
23763 
    oprot.writeStructEnd()
23764 
 
23765 
  def validate(self):
23766 
    return
23767 
 
23768 
 
23769 
  def __repr__(self):
23770 
    L = ['%s=%r' % (key, value)
23771 
      for key, value in self.__dict__.iteritems()]
23772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23773 
 
23774 
  def __eq__(self, other):
23775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23776 
 
23777 
  def __ne__(self, other):
23778 
    return not (self == other)
23779 
 
23780 
class getSettlementForCod_args:
23781 
  """
23782 
  Attributes:
23783 
   - orderId
23784 
   - isRefund
23785 
  """
23786 
 
23787 
  thrift_spec = (
23788 
    None, # 0
23789 
    (1, TType.I64, 'orderId', None, None, ), # 1
23790 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23791 
  )
23792 
 
23793 
  def __init__(self, orderId=None, isRefund=None,):
23794 
    self.orderId = orderId
23795 
    self.isRefund = isRefund
23796 
 
23797 
  def read(self, iprot):
23798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23800 
      return
23801 
    iprot.readStructBegin()
23802 
    while True:
23803 
      (fname, ftype, fid) = iprot.readFieldBegin()
23804 
      if ftype == TType.STOP:
23805 
        break
23806 
      if fid == 1:
23807 
        if ftype == TType.I64:
23808 
          self.orderId = iprot.readI64();
23809 
        else:
23810 
          iprot.skip(ftype)
23811 
      elif fid == 2:
23812 
        if ftype == TType.BOOL:
23813 
          self.isRefund = iprot.readBool();
23814 
        else:
23815 
          iprot.skip(ftype)
23816 
      else:
23817 
        iprot.skip(ftype)
23818 
      iprot.readFieldEnd()
23819 
    iprot.readStructEnd()
23820 
 
23821 
  def write(self, oprot):
23822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23824 
      return
23825 
    oprot.writeStructBegin('getSettlementForCod_args')
23826 
    if self.orderId is not None:
23827 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23828 
      oprot.writeI64(self.orderId)
23829 
      oprot.writeFieldEnd()
5189 varun.gupt 23830 
    if self.isRefund is not None:
5386 phani.kuma 23831 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23832 
      oprot.writeBool(self.isRefund)
23833 
      oprot.writeFieldEnd()
4600 varun.gupt 23834 
    oprot.writeFieldStop()
23835 
    oprot.writeStructEnd()
23836 
 
23837 
  def validate(self):
23838 
    return
23839 
 
23840 
 
23841 
  def __repr__(self):
23842 
    L = ['%s=%r' % (key, value)
23843 
      for key, value in self.__dict__.iteritems()]
23844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23845 
 
23846 
  def __eq__(self, other):
23847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23848 
 
23849 
  def __ne__(self, other):
23850 
    return not (self == other)
23851 
 
5386 phani.kuma 23852 
class getSettlementForCod_result:
4600 varun.gupt 23853 
  """
23854 
  Attributes:
23855 
   - success
23856 
   - ex
23857 
  """
23858 
 
23859 
  thrift_spec = (
23860 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23862 
  )
23863 
 
23864 
  def __init__(self, success=None, ex=None,):
23865 
    self.success = success
23866 
    self.ex = ex
23867 
 
23868 
  def read(self, iprot):
23869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23871 
      return
23872 
    iprot.readStructBegin()
23873 
    while True:
23874 
      (fname, ftype, fid) = iprot.readFieldBegin()
23875 
      if ftype == TType.STOP:
23876 
        break
23877 
      if fid == 0:
23878 
        if ftype == TType.STRUCT:
23879 
          self.success = PaymentSettlement()
23880 
          self.success.read(iprot)
23881 
        else:
23882 
          iprot.skip(ftype)
23883 
      elif fid == 1:
23884 
        if ftype == TType.STRUCT:
23885 
          self.ex = TransactionServiceException()
23886 
          self.ex.read(iprot)
23887 
        else:
23888 
          iprot.skip(ftype)
23889 
      else:
23890 
        iprot.skip(ftype)
23891 
      iprot.readFieldEnd()
23892 
    iprot.readStructEnd()
23893 
 
23894 
  def write(self, oprot):
23895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23897 
      return
5386 phani.kuma 23898 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23899 
    if self.success is not None:
23900 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23901 
      self.success.write(oprot)
23902 
      oprot.writeFieldEnd()
23903 
    if self.ex is not None:
23904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23905 
      self.ex.write(oprot)
23906 
      oprot.writeFieldEnd()
23907 
    oprot.writeFieldStop()
23908 
    oprot.writeStructEnd()
23909 
 
23910 
  def validate(self):
23911 
    return
23912 
 
23913 
 
23914 
  def __repr__(self):
23915 
    L = ['%s=%r' % (key, value)
23916 
      for key, value in self.__dict__.iteritems()]
23917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23918 
 
23919 
  def __eq__(self, other):
23920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23921 
 
23922 
  def __ne__(self, other):
23923 
    return not (self == other)
23924 
 
23925 
class getEBSSettlementSummaries_args:
23926 
 
23927 
  thrift_spec = (
23928 
  )
23929 
 
23930 
  def read(self, iprot):
23931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23933 
      return
23934 
    iprot.readStructBegin()
23935 
    while True:
23936 
      (fname, ftype, fid) = iprot.readFieldBegin()
23937 
      if ftype == TType.STOP:
23938 
        break
23939 
      else:
23940 
        iprot.skip(ftype)
23941 
      iprot.readFieldEnd()
23942 
    iprot.readStructEnd()
23943 
 
23944 
  def write(self, oprot):
23945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23947 
      return
23948 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23949 
    oprot.writeFieldStop()
23950 
    oprot.writeStructEnd()
23951 
 
23952 
  def validate(self):
23953 
    return
23954 
 
23955 
 
23956 
  def __repr__(self):
23957 
    L = ['%s=%r' % (key, value)
23958 
      for key, value in self.__dict__.iteritems()]
23959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23960 
 
23961 
  def __eq__(self, other):
23962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23963 
 
23964 
  def __ne__(self, other):
23965 
    return not (self == other)
23966 
 
23967 
class getEBSSettlementSummaries_result:
23968 
  """
23969 
  Attributes:
23970 
   - success
23971 
   - ex
23972 
  """
23973 
 
23974 
  thrift_spec = (
23975 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23977 
  )
23978 
 
23979 
  def __init__(self, success=None, ex=None,):
23980 
    self.success = success
23981 
    self.ex = ex
23982 
 
23983 
  def read(self, iprot):
23984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23986 
      return
23987 
    iprot.readStructBegin()
23988 
    while True:
23989 
      (fname, ftype, fid) = iprot.readFieldBegin()
23990 
      if ftype == TType.STOP:
23991 
        break
23992 
      if fid == 0:
23993 
        if ftype == TType.MAP:
23994 
          self.success = {}
6188 rajveer 23995 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23996 
          for _i558 in xrange(_size554):
23997 
            _key559 = iprot.readI64();
23998 
            _val560 = iprot.readString();
23999 
            self.success[_key559] = _val560
4600 varun.gupt 24000 
          iprot.readMapEnd()
24001 
        else:
24002 
          iprot.skip(ftype)
24003 
      elif fid == 1:
24004 
        if ftype == TType.STRUCT:
24005 
          self.ex = TransactionServiceException()
24006 
          self.ex.read(iprot)
24007 
        else:
24008 
          iprot.skip(ftype)
24009 
      else:
24010 
        iprot.skip(ftype)
24011 
      iprot.readFieldEnd()
24012 
    iprot.readStructEnd()
24013 
 
24014 
  def write(self, oprot):
24015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24017 
      return
24018 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24019 
    if self.success is not None:
24020 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24021 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24022 
      for kiter561,viter562 in self.success.items():
24023 
        oprot.writeI64(kiter561)
24024 
        oprot.writeString(viter562)
4600 varun.gupt 24025 
      oprot.writeMapEnd()
24026 
      oprot.writeFieldEnd()
24027 
    if self.ex is not None:
24028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24029 
      self.ex.write(oprot)
24030 
      oprot.writeFieldEnd()
24031 
    oprot.writeFieldStop()
24032 
    oprot.writeStructEnd()
24033 
 
24034 
  def validate(self):
24035 
    return
24036 
 
24037 
 
24038 
  def __repr__(self):
24039 
    L = ['%s=%r' % (key, value)
24040 
      for key, value in self.__dict__.iteritems()]
24041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24042 
 
24043 
  def __eq__(self, other):
24044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24045 
 
24046 
  def __ne__(self, other):
24047 
    return not (self == other)
24048 
 
24049 
class markEBSSettlementUploaded_args:
24050 
  """
24051 
  Attributes:
24052 
   - settlementId
24053 
  """
24054 
 
24055 
  thrift_spec = (
24056 
    None, # 0
24057 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24058 
  )
24059 
 
24060 
  def __init__(self, settlementId=None,):
24061 
    self.settlementId = settlementId
24062 
 
24063 
  def read(self, iprot):
24064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24066 
      return
24067 
    iprot.readStructBegin()
24068 
    while True:
24069 
      (fname, ftype, fid) = iprot.readFieldBegin()
24070 
      if ftype == TType.STOP:
24071 
        break
24072 
      if fid == 1:
24073 
        if ftype == TType.I64:
24074 
          self.settlementId = iprot.readI64();
24075 
        else:
24076 
          iprot.skip(ftype)
24077 
      else:
24078 
        iprot.skip(ftype)
24079 
      iprot.readFieldEnd()
24080 
    iprot.readStructEnd()
24081 
 
24082 
  def write(self, oprot):
24083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24085 
      return
24086 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24087 
    if self.settlementId is not None:
24088 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24089 
      oprot.writeI64(self.settlementId)
24090 
      oprot.writeFieldEnd()
24091 
    oprot.writeFieldStop()
24092 
    oprot.writeStructEnd()
24093 
 
24094 
  def validate(self):
24095 
    return
24096 
 
24097 
 
24098 
  def __repr__(self):
24099 
    L = ['%s=%r' % (key, value)
24100 
      for key, value in self.__dict__.iteritems()]
24101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24102 
 
24103 
  def __eq__(self, other):
24104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24105 
 
24106 
  def __ne__(self, other):
24107 
    return not (self == other)
24108 
 
24109 
class markEBSSettlementUploaded_result:
24110 
  """
24111 
  Attributes:
24112 
   - ex
24113 
  """
24114 
 
24115 
  thrift_spec = (
24116 
    None, # 0
24117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24118 
  )
24119 
 
24120 
  def __init__(self, ex=None,):
24121 
    self.ex = ex
24122 
 
24123 
  def read(self, iprot):
24124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24126 
      return
24127 
    iprot.readStructBegin()
24128 
    while True:
24129 
      (fname, ftype, fid) = iprot.readFieldBegin()
24130 
      if ftype == TType.STOP:
24131 
        break
24132 
      if fid == 1:
24133 
        if ftype == TType.STRUCT:
24134 
          self.ex = TransactionServiceException()
24135 
          self.ex.read(iprot)
24136 
        else:
24137 
          iprot.skip(ftype)
24138 
      else:
24139 
        iprot.skip(ftype)
24140 
      iprot.readFieldEnd()
24141 
    iprot.readStructEnd()
24142 
 
24143 
  def write(self, oprot):
24144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24146 
      return
24147 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24148 
    if self.ex is not None:
24149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24150 
      self.ex.write(oprot)
24151 
      oprot.writeFieldEnd()
24152 
    oprot.writeFieldStop()
24153 
    oprot.writeStructEnd()
24154 
 
24155 
  def validate(self):
24156 
    return
24157 
 
24158 
 
24159 
  def __repr__(self):
24160 
    L = ['%s=%r' % (key, value)
24161 
      for key, value in self.__dict__.iteritems()]
24162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24163 
 
24164 
  def __eq__(self, other):
24165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24166 
 
24167 
  def __ne__(self, other):
24168 
    return not (self == other)
24169 
 
24170 
class getEBSSettlementDate_args:
24171 
  """
24172 
  Attributes:
24173 
   - settlementId
24174 
  """
24175 
 
24176 
  thrift_spec = (
24177 
    None, # 0
24178 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24179 
  )
24180 
 
24181 
  def __init__(self, settlementId=None,):
24182 
    self.settlementId = settlementId
24183 
 
24184 
  def read(self, iprot):
24185 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24186 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24187 
      return
24188 
    iprot.readStructBegin()
24189 
    while True:
24190 
      (fname, ftype, fid) = iprot.readFieldBegin()
24191 
      if ftype == TType.STOP:
24192 
        break
24193 
      if fid == 1:
24194 
        if ftype == TType.I64:
24195 
          self.settlementId = iprot.readI64();
24196 
        else:
24197 
          iprot.skip(ftype)
24198 
      else:
24199 
        iprot.skip(ftype)
24200 
      iprot.readFieldEnd()
24201 
    iprot.readStructEnd()
24202 
 
24203 
  def write(self, oprot):
24204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24206 
      return
24207 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24208 
    if self.settlementId is not None:
24209 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24210 
      oprot.writeI64(self.settlementId)
24211 
      oprot.writeFieldEnd()
24212 
    oprot.writeFieldStop()
24213 
    oprot.writeStructEnd()
24214 
 
24215 
  def validate(self):
24216 
    return
24217 
 
24218 
 
24219 
  def __repr__(self):
24220 
    L = ['%s=%r' % (key, value)
24221 
      for key, value in self.__dict__.iteritems()]
24222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24223 
 
24224 
  def __eq__(self, other):
24225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24226 
 
24227 
  def __ne__(self, other):
24228 
    return not (self == other)
24229 
 
24230 
class getEBSSettlementDate_result:
24231 
  """
24232 
  Attributes:
24233 
   - success
24234 
   - ex
24235 
  """
24236 
 
24237 
  thrift_spec = (
24238 
    (0, TType.I64, 'success', None, None, ), # 0
24239 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24240 
  )
24241 
 
24242 
  def __init__(self, success=None, ex=None,):
24243 
    self.success = success
24244 
    self.ex = ex
24245 
 
24246 
  def read(self, iprot):
24247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24249 
      return
24250 
    iprot.readStructBegin()
24251 
    while True:
24252 
      (fname, ftype, fid) = iprot.readFieldBegin()
24253 
      if ftype == TType.STOP:
24254 
        break
24255 
      if fid == 0:
24256 
        if ftype == TType.I64:
24257 
          self.success = iprot.readI64();
24258 
        else:
24259 
          iprot.skip(ftype)
24260 
      elif fid == 1:
24261 
        if ftype == TType.STRUCT:
24262 
          self.ex = TransactionServiceException()
24263 
          self.ex.read(iprot)
24264 
        else:
24265 
          iprot.skip(ftype)
24266 
      else:
24267 
        iprot.skip(ftype)
24268 
      iprot.readFieldEnd()
24269 
    iprot.readStructEnd()
24270 
 
24271 
  def write(self, oprot):
24272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24274 
      return
24275 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24276 
    if self.success is not None:
24277 
      oprot.writeFieldBegin('success', TType.I64, 0)
24278 
      oprot.writeI64(self.success)
24279 
      oprot.writeFieldEnd()
24280 
    if self.ex is not None:
24281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24282 
      self.ex.write(oprot)
24283 
      oprot.writeFieldEnd()
24284 
    oprot.writeFieldStop()
24285 
    oprot.writeStructEnd()
24286 
 
24287 
  def validate(self):
24288 
    return
24289 
 
24290 
 
24291 
  def __repr__(self):
24292 
    L = ['%s=%r' % (key, value)
24293 
      for key, value in self.__dict__.iteritems()]
24294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24295 
 
24296 
  def __eq__(self, other):
24297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24298 
 
24299 
  def __ne__(self, other):
24300 
    return not (self == other)
4715 varun.gupt 24301 
 
24302 
class getSettlementsByDate_args:
24303 
  """
24304 
  Attributes:
24305 
   - settlementDateFrom
24306 
   - settlementDateTo
24307 
   - isRefund
24308 
  """
24309 
 
24310 
  thrift_spec = (
24311 
    None, # 0
24312 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24313 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24314 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24315 
  )
24316 
 
24317 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24318 
    self.settlementDateFrom = settlementDateFrom
24319 
    self.settlementDateTo = settlementDateTo
24320 
    self.isRefund = isRefund
24321 
 
24322 
  def read(self, iprot):
24323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24325 
      return
24326 
    iprot.readStructBegin()
24327 
    while True:
24328 
      (fname, ftype, fid) = iprot.readFieldBegin()
24329 
      if ftype == TType.STOP:
24330 
        break
24331 
      if fid == 1:
24332 
        if ftype == TType.I64:
24333 
          self.settlementDateFrom = iprot.readI64();
24334 
        else:
24335 
          iprot.skip(ftype)
24336 
      elif fid == 2:
24337 
        if ftype == TType.I64:
24338 
          self.settlementDateTo = iprot.readI64();
24339 
        else:
24340 
          iprot.skip(ftype)
24341 
      elif fid == 3:
24342 
        if ftype == TType.BOOL:
24343 
          self.isRefund = iprot.readBool();
24344 
        else:
24345 
          iprot.skip(ftype)
24346 
      else:
24347 
        iprot.skip(ftype)
24348 
      iprot.readFieldEnd()
24349 
    iprot.readStructEnd()
24350 
 
24351 
  def write(self, oprot):
24352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24354 
      return
24355 
    oprot.writeStructBegin('getSettlementsByDate_args')
24356 
    if self.settlementDateFrom is not None:
24357 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24358 
      oprot.writeI64(self.settlementDateFrom)
24359 
      oprot.writeFieldEnd()
24360 
    if self.settlementDateTo is not None:
24361 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24362 
      oprot.writeI64(self.settlementDateTo)
24363 
      oprot.writeFieldEnd()
24364 
    if self.isRefund is not None:
24365 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24366 
      oprot.writeBool(self.isRefund)
24367 
      oprot.writeFieldEnd()
24368 
    oprot.writeFieldStop()
24369 
    oprot.writeStructEnd()
24370 
 
24371 
  def validate(self):
24372 
    return
24373 
 
24374 
 
24375 
  def __repr__(self):
24376 
    L = ['%s=%r' % (key, value)
24377 
      for key, value in self.__dict__.iteritems()]
24378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24379 
 
24380 
  def __eq__(self, other):
24381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24382 
 
24383 
  def __ne__(self, other):
24384 
    return not (self == other)
24385 
 
24386 
class getSettlementsByDate_result:
24387 
  """
24388 
  Attributes:
24389 
   - success
24390 
   - ex
24391 
  """
24392 
 
24393 
  thrift_spec = (
24394 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24396 
  )
24397 
 
24398 
  def __init__(self, success=None, ex=None,):
24399 
    self.success = success
24400 
    self.ex = ex
24401 
 
24402 
  def read(self, iprot):
24403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24405 
      return
24406 
    iprot.readStructBegin()
24407 
    while True:
24408 
      (fname, ftype, fid) = iprot.readFieldBegin()
24409 
      if ftype == TType.STOP:
24410 
        break
24411 
      if fid == 0:
24412 
        if ftype == TType.LIST:
24413 
          self.success = []
6188 rajveer 24414 
          (_etype566, _size563) = iprot.readListBegin()
24415 
          for _i567 in xrange(_size563):
24416 
            _elem568 = PaymentSettlement()
24417 
            _elem568.read(iprot)
24418 
            self.success.append(_elem568)
4715 varun.gupt 24419 
          iprot.readListEnd()
24420 
        else:
24421 
          iprot.skip(ftype)
24422 
      elif fid == 1:
24423 
        if ftype == TType.STRUCT:
24424 
          self.ex = TransactionServiceException()
24425 
          self.ex.read(iprot)
24426 
        else:
24427 
          iprot.skip(ftype)
24428 
      else:
24429 
        iprot.skip(ftype)
24430 
      iprot.readFieldEnd()
24431 
    iprot.readStructEnd()
24432 
 
24433 
  def write(self, oprot):
24434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24436 
      return
24437 
    oprot.writeStructBegin('getSettlementsByDate_result')
24438 
    if self.success is not None:
24439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24441 
      for iter569 in self.success:
24442 
        iter569.write(oprot)
4715 varun.gupt 24443 
      oprot.writeListEnd()
24444 
      oprot.writeFieldEnd()
24445 
    if self.ex is not None:
24446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24447 
      self.ex.write(oprot)
24448 
      oprot.writeFieldEnd()
24449 
    oprot.writeFieldStop()
24450 
    oprot.writeStructEnd()
24451 
 
24452 
  def validate(self):
24453 
    return
24454 
 
24455 
 
24456 
  def __repr__(self):
24457 
    L = ['%s=%r' % (key, value)
24458 
      for key, value in self.__dict__.iteritems()]
24459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24460 
 
24461 
  def __eq__(self, other):
24462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24463 
 
24464 
  def __ne__(self, other):
24465 
    return not (self == other)
24466 
 
24467 
class getReshippedOrderIds_args:
24468 
  """
24469 
  Attributes:
24470 
   - orderIds
24471 
  """
24472 
 
24473 
  thrift_spec = (
24474 
    None, # 0
24475 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24476 
  )
24477 
 
24478 
  def __init__(self, orderIds=None,):
24479 
    self.orderIds = orderIds
24480 
 
24481 
  def read(self, iprot):
24482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24484 
      return
24485 
    iprot.readStructBegin()
24486 
    while True:
24487 
      (fname, ftype, fid) = iprot.readFieldBegin()
24488 
      if ftype == TType.STOP:
24489 
        break
24490 
      if fid == 1:
24491 
        if ftype == TType.LIST:
24492 
          self.orderIds = []
6188 rajveer 24493 
          (_etype573, _size570) = iprot.readListBegin()
24494 
          for _i574 in xrange(_size570):
24495 
            _elem575 = iprot.readI64();
24496 
            self.orderIds.append(_elem575)
4715 varun.gupt 24497 
          iprot.readListEnd()
24498 
        else:
24499 
          iprot.skip(ftype)
24500 
      else:
24501 
        iprot.skip(ftype)
24502 
      iprot.readFieldEnd()
24503 
    iprot.readStructEnd()
24504 
 
24505 
  def write(self, oprot):
24506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24508 
      return
24509 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24510 
    if self.orderIds is not None:
24511 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24512 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24513 
      for iter576 in self.orderIds:
24514 
        oprot.writeI64(iter576)
4715 varun.gupt 24515 
      oprot.writeListEnd()
24516 
      oprot.writeFieldEnd()
24517 
    oprot.writeFieldStop()
24518 
    oprot.writeStructEnd()
24519 
 
24520 
  def validate(self):
24521 
    return
24522 
 
24523 
 
24524 
  def __repr__(self):
24525 
    L = ['%s=%r' % (key, value)
24526 
      for key, value in self.__dict__.iteritems()]
24527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24528 
 
24529 
  def __eq__(self, other):
24530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24531 
 
24532 
  def __ne__(self, other):
24533 
    return not (self == other)
24534 
 
24535 
class getReshippedOrderIds_result:
24536 
  """
24537 
  Attributes:
24538 
   - success
24539 
   - ex
24540 
  """
24541 
 
24542 
  thrift_spec = (
24543 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24545 
  )
24546 
 
24547 
  def __init__(self, success=None, ex=None,):
24548 
    self.success = success
24549 
    self.ex = ex
24550 
 
24551 
  def read(self, iprot):
24552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24554 
      return
24555 
    iprot.readStructBegin()
24556 
    while True:
24557 
      (fname, ftype, fid) = iprot.readFieldBegin()
24558 
      if ftype == TType.STOP:
24559 
        break
24560 
      if fid == 0:
24561 
        if ftype == TType.LIST:
24562 
          self.success = []
6188 rajveer 24563 
          (_etype580, _size577) = iprot.readListBegin()
24564 
          for _i581 in xrange(_size577):
24565 
            _elem582 = iprot.readI64();
24566 
            self.success.append(_elem582)
4715 varun.gupt 24567 
          iprot.readListEnd()
24568 
        else:
24569 
          iprot.skip(ftype)
24570 
      elif fid == 1:
24571 
        if ftype == TType.STRUCT:
24572 
          self.ex = TransactionServiceException()
24573 
          self.ex.read(iprot)
24574 
        else:
24575 
          iprot.skip(ftype)
24576 
      else:
24577 
        iprot.skip(ftype)
24578 
      iprot.readFieldEnd()
24579 
    iprot.readStructEnd()
24580 
 
24581 
  def write(self, oprot):
24582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24584 
      return
24585 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24586 
    if self.success is not None:
24587 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24588 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24589 
      for iter583 in self.success:
24590 
        oprot.writeI64(iter583)
4715 varun.gupt 24591 
      oprot.writeListEnd()
24592 
      oprot.writeFieldEnd()
24593 
    if self.ex is not None:
24594 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24595 
      self.ex.write(oprot)
24596 
      oprot.writeFieldEnd()
24597 
    oprot.writeFieldStop()
24598 
    oprot.writeStructEnd()
24599 
 
24600 
  def validate(self):
24601 
    return
24602 
 
24603 
 
24604 
  def __repr__(self):
24605 
    L = ['%s=%r' % (key, value)
24606 
      for key, value in self.__dict__.iteritems()]
24607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24608 
 
24609 
  def __eq__(self, other):
24610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24611 
 
24612 
  def __ne__(self, other):
24613 
    return not (self == other)
4757 mandeep.dh 24614 
 
5481 phani.kuma 24615 
class getBilledOrders_args:
4875 varun.gupt 24616 
  """
24617 
  Attributes:
24618 
   - vendorId
5481 phani.kuma 24619 
   - onlyVendorNotPaid
24620 
   - billingDateFrom
24621 
   - billingDateTo
4875 varun.gupt 24622 
  """
24623 
 
24624 
  thrift_spec = (
24625 
    None, # 0
24626 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24627 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24628 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24629 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24630 
  )
24631 
 
5481 phani.kuma 24632 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24633 
    self.vendorId = vendorId
5481 phani.kuma 24634 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24635 
    self.billingDateFrom = billingDateFrom
24636 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24637 
 
24638 
  def read(self, iprot):
24639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24641 
      return
24642 
    iprot.readStructBegin()
24643 
    while True:
24644 
      (fname, ftype, fid) = iprot.readFieldBegin()
24645 
      if ftype == TType.STOP:
24646 
        break
24647 
      if fid == 1:
24648 
        if ftype == TType.I64:
24649 
          self.vendorId = iprot.readI64();
24650 
        else:
24651 
          iprot.skip(ftype)
5481 phani.kuma 24652 
      elif fid == 2:
24653 
        if ftype == TType.BOOL:
24654 
          self.onlyVendorNotPaid = iprot.readBool();
24655 
        else:
24656 
          iprot.skip(ftype)
24657 
      elif fid == 3:
24658 
        if ftype == TType.I64:
24659 
          self.billingDateFrom = iprot.readI64();
24660 
        else:
24661 
          iprot.skip(ftype)
24662 
      elif fid == 4:
24663 
        if ftype == TType.I64:
24664 
          self.billingDateTo = iprot.readI64();
24665 
        else:
24666 
          iprot.skip(ftype)
4875 varun.gupt 24667 
      else:
24668 
        iprot.skip(ftype)
24669 
      iprot.readFieldEnd()
24670 
    iprot.readStructEnd()
24671 
 
24672 
  def write(self, oprot):
24673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24675 
      return
5481 phani.kuma 24676 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24677 
    if self.vendorId is not None:
24678 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24679 
      oprot.writeI64(self.vendorId)
24680 
      oprot.writeFieldEnd()
5481 phani.kuma 24681 
    if self.onlyVendorNotPaid is not None:
24682 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24683 
      oprot.writeBool(self.onlyVendorNotPaid)
24684 
      oprot.writeFieldEnd()
24685 
    if self.billingDateFrom is not None:
24686 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24687 
      oprot.writeI64(self.billingDateFrom)
24688 
      oprot.writeFieldEnd()
24689 
    if self.billingDateTo is not None:
24690 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24691 
      oprot.writeI64(self.billingDateTo)
24692 
      oprot.writeFieldEnd()
4875 varun.gupt 24693 
    oprot.writeFieldStop()
24694 
    oprot.writeStructEnd()
24695 
 
24696 
  def validate(self):
24697 
    return
24698 
 
24699 
 
24700 
  def __repr__(self):
24701 
    L = ['%s=%r' % (key, value)
24702 
      for key, value in self.__dict__.iteritems()]
24703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24704 
 
24705 
  def __eq__(self, other):
24706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24707 
 
24708 
  def __ne__(self, other):
24709 
    return not (self == other)
24710 
 
5481 phani.kuma 24711 
class getBilledOrders_result:
4875 varun.gupt 24712 
  """
24713 
  Attributes:
24714 
   - success
24715 
   - ex
24716 
  """
24717 
 
24718 
  thrift_spec = (
24719 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24721 
  )
24722 
 
24723 
  def __init__(self, success=None, ex=None,):
24724 
    self.success = success
24725 
    self.ex = ex
24726 
 
24727 
  def read(self, iprot):
24728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24730 
      return
24731 
    iprot.readStructBegin()
24732 
    while True:
24733 
      (fname, ftype, fid) = iprot.readFieldBegin()
24734 
      if ftype == TType.STOP:
24735 
        break
24736 
      if fid == 0:
24737 
        if ftype == TType.LIST:
24738 
          self.success = []
6188 rajveer 24739 
          (_etype587, _size584) = iprot.readListBegin()
24740 
          for _i588 in xrange(_size584):
24741 
            _elem589 = Order()
24742 
            _elem589.read(iprot)
24743 
            self.success.append(_elem589)
4875 varun.gupt 24744 
          iprot.readListEnd()
24745 
        else:
24746 
          iprot.skip(ftype)
24747 
      elif fid == 1:
24748 
        if ftype == TType.STRUCT:
24749 
          self.ex = TransactionServiceException()
24750 
          self.ex.read(iprot)
24751 
        else:
24752 
          iprot.skip(ftype)
24753 
      else:
24754 
        iprot.skip(ftype)
24755 
      iprot.readFieldEnd()
24756 
    iprot.readStructEnd()
24757 
 
24758 
  def write(self, oprot):
24759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24761 
      return
5481 phani.kuma 24762 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24763 
    if self.success is not None:
24764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24766 
      for iter590 in self.success:
24767 
        iter590.write(oprot)
4875 varun.gupt 24768 
      oprot.writeListEnd()
24769 
      oprot.writeFieldEnd()
24770 
    if self.ex is not None:
24771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24772 
      self.ex.write(oprot)
24773 
      oprot.writeFieldEnd()
24774 
    oprot.writeFieldStop()
24775 
    oprot.writeStructEnd()
24776 
 
24777 
  def validate(self):
24778 
    return
24779 
 
24780 
 
24781 
  def __repr__(self):
24782 
    L = ['%s=%r' % (key, value)
24783 
      for key, value in self.__dict__.iteritems()]
24784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24785 
 
24786 
  def __eq__(self, other):
24787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24788 
 
24789 
  def __ne__(self, other):
24790 
    return not (self == other)
5031 varun.gupt 24791 
 
24792 
class getStatusDistributionOfOrders_args:
24793 
  """
24794 
  Attributes:
24795 
   - startDate
24796 
   - endDate
24797 
  """
24798 
 
24799 
  thrift_spec = (
24800 
    None, # 0
24801 
    (1, TType.I64, 'startDate', None, None, ), # 1
24802 
    (2, TType.I64, 'endDate', None, None, ), # 2
24803 
  )
24804 
 
24805 
  def __init__(self, startDate=None, endDate=None,):
24806 
    self.startDate = startDate
24807 
    self.endDate = endDate
24808 
 
24809 
  def read(self, iprot):
24810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24812 
      return
24813 
    iprot.readStructBegin()
24814 
    while True:
24815 
      (fname, ftype, fid) = iprot.readFieldBegin()
24816 
      if ftype == TType.STOP:
24817 
        break
24818 
      if fid == 1:
24819 
        if ftype == TType.I64:
24820 
          self.startDate = iprot.readI64();
24821 
        else:
24822 
          iprot.skip(ftype)
24823 
      elif fid == 2:
24824 
        if ftype == TType.I64:
24825 
          self.endDate = iprot.readI64();
24826 
        else:
24827 
          iprot.skip(ftype)
24828 
      else:
24829 
        iprot.skip(ftype)
24830 
      iprot.readFieldEnd()
24831 
    iprot.readStructEnd()
24832 
 
24833 
  def write(self, oprot):
24834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24836 
      return
24837 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24838 
    if self.startDate is not None:
24839 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24840 
      oprot.writeI64(self.startDate)
24841 
      oprot.writeFieldEnd()
24842 
    if self.endDate is not None:
24843 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24844 
      oprot.writeI64(self.endDate)
24845 
      oprot.writeFieldEnd()
24846 
    oprot.writeFieldStop()
24847 
    oprot.writeStructEnd()
24848 
 
24849 
  def validate(self):
24850 
    return
24851 
 
24852 
 
24853 
  def __repr__(self):
24854 
    L = ['%s=%r' % (key, value)
24855 
      for key, value in self.__dict__.iteritems()]
24856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24857 
 
24858 
  def __eq__(self, other):
24859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24860 
 
24861 
  def __ne__(self, other):
24862 
    return not (self == other)
24863 
 
24864 
class getStatusDistributionOfOrders_result:
24865 
  """
24866 
  Attributes:
24867 
   - success
24868 
   - ex
24869 
  """
24870 
 
24871 
  thrift_spec = (
24872 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24874 
  )
24875 
 
24876 
  def __init__(self, success=None, ex=None,):
24877 
    self.success = success
24878 
    self.ex = ex
24879 
 
24880 
  def read(self, iprot):
24881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24883 
      return
24884 
    iprot.readStructBegin()
24885 
    while True:
24886 
      (fname, ftype, fid) = iprot.readFieldBegin()
24887 
      if ftype == TType.STOP:
24888 
        break
24889 
      if fid == 0:
24890 
        if ftype == TType.MAP:
24891 
          self.success = {}
6188 rajveer 24892 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24893 
          for _i595 in xrange(_size591):
24894 
            _key596 = iprot.readI64();
24895 
            _val597 = iprot.readI64();
24896 
            self.success[_key596] = _val597
5031 varun.gupt 24897 
          iprot.readMapEnd()
24898 
        else:
24899 
          iprot.skip(ftype)
24900 
      elif fid == 1:
24901 
        if ftype == TType.STRUCT:
24902 
          self.ex = TransactionServiceException()
24903 
          self.ex.read(iprot)
24904 
        else:
24905 
          iprot.skip(ftype)
24906 
      else:
24907 
        iprot.skip(ftype)
24908 
      iprot.readFieldEnd()
24909 
    iprot.readStructEnd()
24910 
 
24911 
  def write(self, oprot):
24912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24914 
      return
24915 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24916 
    if self.success is not None:
24917 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24918 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24919 
      for kiter598,viter599 in self.success.items():
24920 
        oprot.writeI64(kiter598)
24921 
        oprot.writeI64(viter599)
5031 varun.gupt 24922 
      oprot.writeMapEnd()
24923 
      oprot.writeFieldEnd()
24924 
    if self.ex is not None:
24925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24926 
      self.ex.write(oprot)
24927 
      oprot.writeFieldEnd()
24928 
    oprot.writeFieldStop()
24929 
    oprot.writeStructEnd()
24930 
 
24931 
  def validate(self):
24932 
    return
24933 
 
24934 
 
24935 
  def __repr__(self):
24936 
    L = ['%s=%r' % (key, value)
24937 
      for key, value in self.__dict__.iteritems()]
24938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24939 
 
24940 
  def __eq__(self, other):
24941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24942 
 
24943 
  def __ne__(self, other):
24944 
    return not (self == other)
5067 varun.gupt 24945 
 
24946 
class getOrderIdsForStatus_args:
24947 
  """
24948 
  Attributes:
24949 
   - status
24950 
   - startDatetime
24951 
   - endDatetime
24952 
  """
24953 
 
24954 
  thrift_spec = (
24955 
    None, # 0
24956 
    (1, TType.I64, 'status', None, None, ), # 1
24957 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24958 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24959 
  )
24960 
 
24961 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24962 
    self.status = status
24963 
    self.startDatetime = startDatetime
24964 
    self.endDatetime = endDatetime
24965 
 
24966 
  def read(self, iprot):
24967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24969 
      return
24970 
    iprot.readStructBegin()
24971 
    while True:
24972 
      (fname, ftype, fid) = iprot.readFieldBegin()
24973 
      if ftype == TType.STOP:
24974 
        break
24975 
      if fid == 1:
24976 
        if ftype == TType.I64:
24977 
          self.status = iprot.readI64();
24978 
        else:
24979 
          iprot.skip(ftype)
24980 
      elif fid == 2:
24981 
        if ftype == TType.I64:
24982 
          self.startDatetime = iprot.readI64();
24983 
        else:
24984 
          iprot.skip(ftype)
24985 
      elif fid == 3:
24986 
        if ftype == TType.I64:
24987 
          self.endDatetime = iprot.readI64();
24988 
        else:
24989 
          iprot.skip(ftype)
24990 
      else:
24991 
        iprot.skip(ftype)
24992 
      iprot.readFieldEnd()
24993 
    iprot.readStructEnd()
24994 
 
24995 
  def write(self, oprot):
24996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24998 
      return
24999 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25000 
    if self.status is not None:
25001 
      oprot.writeFieldBegin('status', TType.I64, 1)
25002 
      oprot.writeI64(self.status)
25003 
      oprot.writeFieldEnd()
25004 
    if self.startDatetime is not None:
25005 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25006 
      oprot.writeI64(self.startDatetime)
25007 
      oprot.writeFieldEnd()
25008 
    if self.endDatetime is not None:
25009 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25010 
      oprot.writeI64(self.endDatetime)
25011 
      oprot.writeFieldEnd()
25012 
    oprot.writeFieldStop()
25013 
    oprot.writeStructEnd()
25014 
 
25015 
  def validate(self):
25016 
    return
25017 
 
25018 
 
25019 
  def __repr__(self):
25020 
    L = ['%s=%r' % (key, value)
25021 
      for key, value in self.__dict__.iteritems()]
25022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25023 
 
25024 
  def __eq__(self, other):
25025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25026 
 
25027 
  def __ne__(self, other):
25028 
    return not (self == other)
25029 
 
25030 
class getOrderIdsForStatus_result:
25031 
  """
25032 
  Attributes:
25033 
   - success
25034 
   - ex
25035 
  """
25036 
 
25037 
  thrift_spec = (
25038 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25040 
  )
25041 
 
25042 
  def __init__(self, success=None, ex=None,):
25043 
    self.success = success
25044 
    self.ex = ex
25045 
 
25046 
  def read(self, iprot):
25047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25049 
      return
25050 
    iprot.readStructBegin()
25051 
    while True:
25052 
      (fname, ftype, fid) = iprot.readFieldBegin()
25053 
      if ftype == TType.STOP:
25054 
        break
25055 
      if fid == 0:
25056 
        if ftype == TType.LIST:
25057 
          self.success = []
6188 rajveer 25058 
          (_etype603, _size600) = iprot.readListBegin()
25059 
          for _i604 in xrange(_size600):
25060 
            _elem605 = iprot.readI64();
25061 
            self.success.append(_elem605)
5067 varun.gupt 25062 
          iprot.readListEnd()
25063 
        else:
25064 
          iprot.skip(ftype)
25065 
      elif fid == 1:
25066 
        if ftype == TType.STRUCT:
25067 
          self.ex = TransactionServiceException()
25068 
          self.ex.read(iprot)
25069 
        else:
25070 
          iprot.skip(ftype)
25071 
      else:
25072 
        iprot.skip(ftype)
25073 
      iprot.readFieldEnd()
25074 
    iprot.readStructEnd()
25075 
 
25076 
  def write(self, oprot):
25077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25079 
      return
25080 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25081 
    if self.success is not None:
25082 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25083 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25084 
      for iter606 in self.success:
25085 
        oprot.writeI64(iter606)
5067 varun.gupt 25086 
      oprot.writeListEnd()
25087 
      oprot.writeFieldEnd()
25088 
    if self.ex is not None:
25089 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25090 
      self.ex.write(oprot)
25091 
      oprot.writeFieldEnd()
25092 
    oprot.writeFieldStop()
25093 
    oprot.writeStructEnd()
25094 
 
25095 
  def validate(self):
25096 
    return
25097 
 
25098 
 
25099 
  def __repr__(self):
25100 
    L = ['%s=%r' % (key, value)
25101 
      for key, value in self.__dict__.iteritems()]
25102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25103 
 
25104 
  def __eq__(self, other):
25105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25106 
 
25107 
  def __ne__(self, other):
25108 
    return not (self == other)
5099 varun.gupt 25109 
 
5348 anupam.sin 25110 
class updateCODAgent_args:
25111 
  """
25112 
  Attributes:
25113 
   - agent
25114 
   - orderId
25115 
  """
25116 
 
25117 
  thrift_spec = (
25118 
    None, # 0
25119 
    (1, TType.STRING, 'agent', None, None, ), # 1
25120 
    (2, TType.I64, 'orderId', None, None, ), # 2
25121 
  )
25122 
 
25123 
  def __init__(self, agent=None, orderId=None,):
25124 
    self.agent = agent
25125 
    self.orderId = orderId
25126 
 
25127 
  def read(self, iprot):
25128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25130 
      return
25131 
    iprot.readStructBegin()
25132 
    while True:
25133 
      (fname, ftype, fid) = iprot.readFieldBegin()
25134 
      if ftype == TType.STOP:
25135 
        break
25136 
      if fid == 1:
25137 
        if ftype == TType.STRING:
25138 
          self.agent = iprot.readString();
25139 
        else:
25140 
          iprot.skip(ftype)
25141 
      elif fid == 2:
25142 
        if ftype == TType.I64:
25143 
          self.orderId = iprot.readI64();
25144 
        else:
25145 
          iprot.skip(ftype)
25146 
      else:
25147 
        iprot.skip(ftype)
25148 
      iprot.readFieldEnd()
25149 
    iprot.readStructEnd()
25150 
 
25151 
  def write(self, oprot):
25152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25154 
      return
25155 
    oprot.writeStructBegin('updateCODAgent_args')
25156 
    if self.agent is not None:
25157 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25158 
      oprot.writeString(self.agent)
25159 
      oprot.writeFieldEnd()
25160 
    if self.orderId is not None:
25161 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25162 
      oprot.writeI64(self.orderId)
25163 
      oprot.writeFieldEnd()
25164 
    oprot.writeFieldStop()
25165 
    oprot.writeStructEnd()
25166 
 
25167 
  def validate(self):
25168 
    return
25169 
 
25170 
 
25171 
  def __repr__(self):
25172 
    L = ['%s=%r' % (key, value)
25173 
      for key, value in self.__dict__.iteritems()]
25174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25175 
 
25176 
  def __eq__(self, other):
25177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25178 
 
25179 
  def __ne__(self, other):
25180 
    return not (self == other)
25181 
 
25182 
class updateCODAgent_result:
25183 
  """
25184 
  Attributes:
25185 
   - ex
25186 
  """
25187 
 
25188 
  thrift_spec = (
25189 
    None, # 0
25190 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25191 
  )
25192 
 
25193 
  def __init__(self, ex=None,):
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 == 1:
25206 
        if ftype == TType.STRUCT:
25207 
          self.ex = TransactionServiceException()
25208 
          self.ex.read(iprot)
25209 
        else:
25210 
          iprot.skip(ftype)
25211 
      else:
25212 
        iprot.skip(ftype)
25213 
      iprot.readFieldEnd()
25214 
    iprot.readStructEnd()
25215 
 
25216 
  def write(self, oprot):
25217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25219 
      return
25220 
    oprot.writeStructBegin('updateCODAgent_result')
25221 
    if self.ex is not None:
25222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25223 
      self.ex.write(oprot)
25224 
      oprot.writeFieldEnd()
25225 
    oprot.writeFieldStop()
25226 
    oprot.writeStructEnd()
25227 
 
25228 
  def validate(self):
25229 
    return
25230 
 
25231 
 
25232 
  def __repr__(self):
25233 
    L = ['%s=%r' % (key, value)
25234 
      for key, value in self.__dict__.iteritems()]
25235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25236 
 
25237 
  def __eq__(self, other):
25238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25239 
 
25240 
  def __ne__(self, other):
25241 
    return not (self == other)
25242 
 
5099 varun.gupt 25243 
class updateOrderAsPaidToVendor_args:
25244 
  """
25245 
  Attributes:
25246 
   - orderId
25247 
  """
25248 
 
25249 
  thrift_spec = (
25250 
    None, # 0
25251 
    (1, TType.I64, 'orderId', None, None, ), # 1
25252 
  )
25253 
 
25254 
  def __init__(self, orderId=None,):
25255 
    self.orderId = orderId
25256 
 
25257 
  def read(self, iprot):
25258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25260 
      return
25261 
    iprot.readStructBegin()
25262 
    while True:
25263 
      (fname, ftype, fid) = iprot.readFieldBegin()
25264 
      if ftype == TType.STOP:
25265 
        break
25266 
      if fid == 1:
25267 
        if ftype == TType.I64:
25268 
          self.orderId = iprot.readI64();
25269 
        else:
25270 
          iprot.skip(ftype)
25271 
      else:
25272 
        iprot.skip(ftype)
25273 
      iprot.readFieldEnd()
25274 
    iprot.readStructEnd()
25275 
 
25276 
  def write(self, oprot):
25277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25279 
      return
25280 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25281 
    if self.orderId is not None:
25282 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25283 
      oprot.writeI64(self.orderId)
25284 
      oprot.writeFieldEnd()
25285 
    oprot.writeFieldStop()
25286 
    oprot.writeStructEnd()
25287 
 
25288 
  def validate(self):
25289 
    return
25290 
 
25291 
 
25292 
  def __repr__(self):
25293 
    L = ['%s=%r' % (key, value)
25294 
      for key, value in self.__dict__.iteritems()]
25295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25296 
 
25297 
  def __eq__(self, other):
25298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25299 
 
25300 
  def __ne__(self, other):
25301 
    return not (self == other)
25302 
 
25303 
class updateOrderAsPaidToVendor_result:
25304 
  """
25305 
  Attributes:
25306 
   - ex
25307 
  """
25308 
 
25309 
  thrift_spec = (
25310 
    None, # 0
25311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25312 
  )
25313 
 
25314 
  def __init__(self, ex=None,):
25315 
    self.ex = ex
25316 
 
25317 
  def read(self, iprot):
25318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25320 
      return
25321 
    iprot.readStructBegin()
25322 
    while True:
25323 
      (fname, ftype, fid) = iprot.readFieldBegin()
25324 
      if ftype == TType.STOP:
25325 
        break
25326 
      if fid == 1:
25327 
        if ftype == TType.STRUCT:
25328 
          self.ex = TransactionServiceException()
25329 
          self.ex.read(iprot)
25330 
        else:
25331 
          iprot.skip(ftype)
25332 
      else:
25333 
        iprot.skip(ftype)
25334 
      iprot.readFieldEnd()
25335 
    iprot.readStructEnd()
25336 
 
25337 
  def write(self, oprot):
25338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25340 
      return
25341 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25342 
    if self.ex is not None:
25343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25344 
      self.ex.write(oprot)
25345 
      oprot.writeFieldEnd()
25346 
    oprot.writeFieldStop()
25347 
    oprot.writeStructEnd()
25348 
 
25349 
  def validate(self):
25350 
    return
25351 
 
25352 
 
25353 
  def __repr__(self):
25354 
    L = ['%s=%r' % (key, value)
25355 
      for key, value in self.__dict__.iteritems()]
25356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25357 
 
25358 
  def __eq__(self, other):
25359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25360 
 
25361 
  def __ne__(self, other):
25362 
    return not (self == other)
5208 varun.gupt 25363 
 
5386 phani.kuma 25364 
class updateOrderOnlyAsPaidToVendor_args:
25365 
  """
25366 
  Attributes:
25367 
   - orderId
25368 
  """
25369 
 
25370 
  thrift_spec = (
25371 
    None, # 0
25372 
    (1, TType.I64, 'orderId', None, None, ), # 1
25373 
  )
25374 
 
25375 
  def __init__(self, orderId=None,):
25376 
    self.orderId = orderId
25377 
 
25378 
  def read(self, iprot):
25379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25381 
      return
25382 
    iprot.readStructBegin()
25383 
    while True:
25384 
      (fname, ftype, fid) = iprot.readFieldBegin()
25385 
      if ftype == TType.STOP:
25386 
        break
25387 
      if fid == 1:
25388 
        if ftype == TType.I64:
25389 
          self.orderId = iprot.readI64();
25390 
        else:
25391 
          iprot.skip(ftype)
25392 
      else:
25393 
        iprot.skip(ftype)
25394 
      iprot.readFieldEnd()
25395 
    iprot.readStructEnd()
25396 
 
25397 
  def write(self, oprot):
25398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25400 
      return
25401 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25402 
    if self.orderId is not None:
25403 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25404 
      oprot.writeI64(self.orderId)
25405 
      oprot.writeFieldEnd()
25406 
    oprot.writeFieldStop()
25407 
    oprot.writeStructEnd()
25408 
 
25409 
  def validate(self):
25410 
    return
25411 
 
25412 
 
25413 
  def __repr__(self):
25414 
    L = ['%s=%r' % (key, value)
25415 
      for key, value in self.__dict__.iteritems()]
25416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25417 
 
25418 
  def __eq__(self, other):
25419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25420 
 
25421 
  def __ne__(self, other):
25422 
    return not (self == other)
25423 
 
25424 
class updateOrderOnlyAsPaidToVendor_result:
25425 
  """
25426 
  Attributes:
25427 
   - ex
25428 
  """
25429 
 
25430 
  thrift_spec = (
25431 
    None, # 0
25432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25433 
  )
25434 
 
25435 
  def __init__(self, ex=None,):
25436 
    self.ex = ex
25437 
 
25438 
  def read(self, iprot):
25439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25441 
      return
25442 
    iprot.readStructBegin()
25443 
    while True:
25444 
      (fname, ftype, fid) = iprot.readFieldBegin()
25445 
      if ftype == TType.STOP:
25446 
        break
25447 
      if fid == 1:
25448 
        if ftype == TType.STRUCT:
25449 
          self.ex = TransactionServiceException()
25450 
          self.ex.read(iprot)
25451 
        else:
25452 
          iprot.skip(ftype)
25453 
      else:
25454 
        iprot.skip(ftype)
25455 
      iprot.readFieldEnd()
25456 
    iprot.readStructEnd()
25457 
 
25458 
  def write(self, oprot):
25459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25461 
      return
25462 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25463 
    if self.ex is not None:
25464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25465 
      self.ex.write(oprot)
25466 
      oprot.writeFieldEnd()
25467 
    oprot.writeFieldStop()
25468 
    oprot.writeStructEnd()
25469 
 
25470 
  def validate(self):
25471 
    return
25472 
 
25473 
 
25474 
  def __repr__(self):
25475 
    L = ['%s=%r' % (key, value)
25476 
      for key, value in self.__dict__.iteritems()]
25477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25478 
 
25479 
  def __eq__(self, other):
25480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25481 
 
25482 
  def __ne__(self, other):
25483 
    return not (self == other)
25484 
 
5208 varun.gupt 25485 
class getRefundedOrdersMarkedPaid_args:
25486 
 
25487 
  thrift_spec = (
25488 
  )
25489 
 
25490 
  def read(self, iprot):
25491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25493 
      return
25494 
    iprot.readStructBegin()
25495 
    while True:
25496 
      (fname, ftype, fid) = iprot.readFieldBegin()
25497 
      if ftype == TType.STOP:
25498 
        break
25499 
      else:
25500 
        iprot.skip(ftype)
25501 
      iprot.readFieldEnd()
25502 
    iprot.readStructEnd()
25503 
 
25504 
  def write(self, oprot):
25505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25507 
      return
25508 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25509 
    oprot.writeFieldStop()
25510 
    oprot.writeStructEnd()
25511 
 
25512 
  def validate(self):
25513 
    return
25514 
 
25515 
 
25516 
  def __repr__(self):
25517 
    L = ['%s=%r' % (key, value)
25518 
      for key, value in self.__dict__.iteritems()]
25519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25520 
 
25521 
  def __eq__(self, other):
25522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25523 
 
25524 
  def __ne__(self, other):
25525 
    return not (self == other)
25526 
 
25527 
class getRefundedOrdersMarkedPaid_result:
25528 
  """
25529 
  Attributes:
25530 
   - success
25531 
   - ex
25532 
  """
25533 
 
25534 
  thrift_spec = (
25535 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25537 
  )
25538 
 
25539 
  def __init__(self, success=None, ex=None,):
25540 
    self.success = success
25541 
    self.ex = ex
25542 
 
25543 
  def read(self, iprot):
25544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25546 
      return
25547 
    iprot.readStructBegin()
25548 
    while True:
25549 
      (fname, ftype, fid) = iprot.readFieldBegin()
25550 
      if ftype == TType.STOP:
25551 
        break
25552 
      if fid == 0:
25553 
        if ftype == TType.LIST:
25554 
          self.success = []
6188 rajveer 25555 
          (_etype610, _size607) = iprot.readListBegin()
25556 
          for _i611 in xrange(_size607):
25557 
            _elem612 = Order()
25558 
            _elem612.read(iprot)
25559 
            self.success.append(_elem612)
5208 varun.gupt 25560 
          iprot.readListEnd()
25561 
        else:
25562 
          iprot.skip(ftype)
25563 
      elif fid == 1:
25564 
        if ftype == TType.STRUCT:
25565 
          self.ex = TransactionServiceException()
25566 
          self.ex.read(iprot)
25567 
        else:
25568 
          iprot.skip(ftype)
25569 
      else:
25570 
        iprot.skip(ftype)
25571 
      iprot.readFieldEnd()
25572 
    iprot.readStructEnd()
25573 
 
25574 
  def write(self, oprot):
25575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25577 
      return
25578 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25579 
    if self.success is not None:
25580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25582 
      for iter613 in self.success:
25583 
        iter613.write(oprot)
5208 varun.gupt 25584 
      oprot.writeListEnd()
25585 
      oprot.writeFieldEnd()
25586 
    if self.ex is not None:
25587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25588 
      self.ex.write(oprot)
25589 
      oprot.writeFieldEnd()
25590 
    oprot.writeFieldStop()
25591 
    oprot.writeStructEnd()
25592 
 
25593 
  def validate(self):
25594 
    return
25595 
 
25596 
 
25597 
  def __repr__(self):
25598 
    L = ['%s=%r' % (key, value)
25599 
      for key, value in self.__dict__.iteritems()]
25600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25601 
 
25602 
  def __eq__(self, other):
25603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25604 
 
25605 
  def __ne__(self, other):
25606 
    return not (self == other)
5447 anupam.sin 25607 
 
25608 
class getAllVerificationAgents_args:
25609 
  """
25610 
  Attributes:
25611 
   - minOrderId
25612 
   - maxOrderId
25613 
  """
25614 
 
25615 
  thrift_spec = (
25616 
    None, # 0
25617 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25618 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25619 
  )
25620 
 
25621 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25622 
    self.minOrderId = minOrderId
25623 
    self.maxOrderId = maxOrderId
25624 
 
25625 
  def read(self, iprot):
25626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25628 
      return
25629 
    iprot.readStructBegin()
25630 
    while True:
25631 
      (fname, ftype, fid) = iprot.readFieldBegin()
25632 
      if ftype == TType.STOP:
25633 
        break
25634 
      if fid == 1:
25635 
        if ftype == TType.I64:
25636 
          self.minOrderId = iprot.readI64();
25637 
        else:
25638 
          iprot.skip(ftype)
25639 
      elif fid == 2:
25640 
        if ftype == TType.I64:
25641 
          self.maxOrderId = iprot.readI64();
25642 
        else:
25643 
          iprot.skip(ftype)
25644 
      else:
25645 
        iprot.skip(ftype)
25646 
      iprot.readFieldEnd()
25647 
    iprot.readStructEnd()
25648 
 
25649 
  def write(self, oprot):
25650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25652 
      return
25653 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25654 
    if self.minOrderId is not None:
25655 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25656 
      oprot.writeI64(self.minOrderId)
25657 
      oprot.writeFieldEnd()
25658 
    if self.maxOrderId is not None:
25659 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25660 
      oprot.writeI64(self.maxOrderId)
25661 
      oprot.writeFieldEnd()
25662 
    oprot.writeFieldStop()
25663 
    oprot.writeStructEnd()
25664 
 
25665 
  def validate(self):
25666 
    return
25667 
 
25668 
 
25669 
  def __repr__(self):
25670 
    L = ['%s=%r' % (key, value)
25671 
      for key, value in self.__dict__.iteritems()]
25672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25673 
 
25674 
  def __eq__(self, other):
25675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25676 
 
25677 
  def __ne__(self, other):
25678 
    return not (self == other)
25679 
 
25680 
class getAllVerificationAgents_result:
25681 
  """
25682 
  Attributes:
25683 
   - success
25684 
  """
25685 
 
25686 
  thrift_spec = (
25687 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25688 
  )
25689 
 
25690 
  def __init__(self, success=None,):
25691 
    self.success = success
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 
          (_etype617, _size614) = iprot.readListBegin()
25706 
          for _i618 in xrange(_size614):
25707 
            _elem619 = CODVerificationAgent()
25708 
            _elem619.read(iprot)
25709 
            self.success.append(_elem619)
5447 anupam.sin 25710 
          iprot.readListEnd()
25711 
        else:
25712 
          iprot.skip(ftype)
25713 
      else:
25714 
        iprot.skip(ftype)
25715 
      iprot.readFieldEnd()
25716 
    iprot.readStructEnd()
25717 
 
25718 
  def write(self, oprot):
25719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25721 
      return
25722 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25723 
    if self.success is not None:
25724 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25725 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25726 
      for iter620 in self.success:
25727 
        iter620.write(oprot)
5447 anupam.sin 25728 
      oprot.writeListEnd()
25729 
      oprot.writeFieldEnd()
25730 
    oprot.writeFieldStop()
25731 
    oprot.writeStructEnd()
25732 
 
25733 
  def validate(self):
25734 
    return
25735 
 
25736 
 
25737 
  def __repr__(self):
25738 
    L = ['%s=%r' % (key, value)
25739 
      for key, value in self.__dict__.iteritems()]
25740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25741 
 
25742 
  def __eq__(self, other):
25743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25744 
 
25745 
  def __ne__(self, other):
25746 
    return not (self == other)
5527 anupam.sin 25747 
 
25748 
class getAllAttributesForOrderId_args:
25749 
  """
25750 
  Attributes:
25751 
   - orderId
25752 
  """
25753 
 
25754 
  thrift_spec = (
25755 
    None, # 0
25756 
    (1, TType.I64, 'orderId', None, None, ), # 1
25757 
  )
25758 
 
25759 
  def __init__(self, orderId=None,):
25760 
    self.orderId = orderId
25761 
 
25762 
  def read(self, iprot):
25763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25765 
      return
25766 
    iprot.readStructBegin()
25767 
    while True:
25768 
      (fname, ftype, fid) = iprot.readFieldBegin()
25769 
      if ftype == TType.STOP:
25770 
        break
25771 
      if fid == 1:
25772 
        if ftype == TType.I64:
25773 
          self.orderId = iprot.readI64();
25774 
        else:
25775 
          iprot.skip(ftype)
25776 
      else:
25777 
        iprot.skip(ftype)
25778 
      iprot.readFieldEnd()
25779 
    iprot.readStructEnd()
25780 
 
25781 
  def write(self, oprot):
25782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25784 
      return
25785 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25786 
    if self.orderId is not None:
25787 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25788 
      oprot.writeI64(self.orderId)
25789 
      oprot.writeFieldEnd()
25790 
    oprot.writeFieldStop()
25791 
    oprot.writeStructEnd()
25792 
 
25793 
  def validate(self):
25794 
    return
25795 
 
25796 
 
25797 
  def __repr__(self):
25798 
    L = ['%s=%r' % (key, value)
25799 
      for key, value in self.__dict__.iteritems()]
25800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25801 
 
25802 
  def __eq__(self, other):
25803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25804 
 
25805 
  def __ne__(self, other):
25806 
    return not (self == other)
25807 
 
25808 
class getAllAttributesForOrderId_result:
25809 
  """
25810 
  Attributes:
25811 
   - success
25812 
  """
25813 
 
25814 
  thrift_spec = (
25815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25816 
  )
25817 
 
25818 
  def __init__(self, success=None,):
25819 
    self.success = success
25820 
 
25821 
  def read(self, iprot):
25822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25824 
      return
25825 
    iprot.readStructBegin()
25826 
    while True:
25827 
      (fname, ftype, fid) = iprot.readFieldBegin()
25828 
      if ftype == TType.STOP:
25829 
        break
25830 
      if fid == 0:
25831 
        if ftype == TType.LIST:
25832 
          self.success = []
6188 rajveer 25833 
          (_etype624, _size621) = iprot.readListBegin()
25834 
          for _i625 in xrange(_size621):
25835 
            _elem626 = Attribute()
25836 
            _elem626.read(iprot)
25837 
            self.success.append(_elem626)
5527 anupam.sin 25838 
          iprot.readListEnd()
25839 
        else:
25840 
          iprot.skip(ftype)
25841 
      else:
25842 
        iprot.skip(ftype)
25843 
      iprot.readFieldEnd()
25844 
    iprot.readStructEnd()
25845 
 
25846 
  def write(self, oprot):
25847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25849 
      return
25850 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25851 
    if self.success is not None:
25852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25854 
      for iter627 in self.success:
25855 
        iter627.write(oprot)
5527 anupam.sin 25856 
      oprot.writeListEnd()
25857 
      oprot.writeFieldEnd()
25858 
    oprot.writeFieldStop()
25859 
    oprot.writeStructEnd()
25860 
 
25861 
  def validate(self):
25862 
    return
25863 
 
25864 
 
25865 
  def __repr__(self):
25866 
    L = ['%s=%r' % (key, value)
25867 
      for key, value in self.__dict__.iteritems()]
25868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25869 
 
25870 
  def __eq__(self, other):
25871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25872 
 
25873 
  def __ne__(self, other):
25874 
    return not (self == other)
25875 
 
5676 rajveer 25876 
class setOrderAttributes_args:
25877 
  """
25878 
  Attributes:
25879 
   - orderId
25880 
   - attributes
25881 
  """
25882 
 
25883 
  thrift_spec = None
25884 
  def __init__(self, orderId=None, attributes=None,):
25885 
    self.orderId = orderId
25886 
    self.attributes = attributes
25887 
 
25888 
  def read(self, iprot):
25889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25891 
      return
25892 
    iprot.readStructBegin()
25893 
    while True:
25894 
      (fname, ftype, fid) = iprot.readFieldBegin()
25895 
      if ftype == TType.STOP:
25896 
        break
25897 
      if fid == 1:
25898 
        if ftype == TType.I64:
25899 
          self.orderId = iprot.readI64();
25900 
        else:
25901 
          iprot.skip(ftype)
25902 
      elif fid == -1:
25903 
        if ftype == TType.LIST:
25904 
          self.attributes = []
6188 rajveer 25905 
          (_etype631, _size628) = iprot.readListBegin()
25906 
          for _i632 in xrange(_size628):
25907 
            _elem633 = Attribute()
25908 
            _elem633.read(iprot)
25909 
            self.attributes.append(_elem633)
5676 rajveer 25910 
          iprot.readListEnd()
25911 
        else:
25912 
          iprot.skip(ftype)
25913 
      else:
25914 
        iprot.skip(ftype)
25915 
      iprot.readFieldEnd()
25916 
    iprot.readStructEnd()
25917 
 
25918 
  def write(self, oprot):
25919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25921 
      return
25922 
    oprot.writeStructBegin('setOrderAttributes_args')
25923 
    if self.attributes is not None:
25924 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25925 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25926 
      for iter634 in self.attributes:
25927 
        iter634.write(oprot)
5676 rajveer 25928 
      oprot.writeListEnd()
25929 
      oprot.writeFieldEnd()
25930 
    if self.orderId is not None:
25931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25932 
      oprot.writeI64(self.orderId)
25933 
      oprot.writeFieldEnd()
25934 
    oprot.writeFieldStop()
25935 
    oprot.writeStructEnd()
25936 
 
25937 
  def validate(self):
25938 
    return
25939 
 
25940 
 
25941 
  def __repr__(self):
25942 
    L = ['%s=%r' % (key, value)
25943 
      for key, value in self.__dict__.iteritems()]
25944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25945 
 
25946 
  def __eq__(self, other):
25947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25948 
 
25949 
  def __ne__(self, other):
25950 
    return not (self == other)
25951 
 
25952 
class setOrderAttributes_result:
25953 
 
25954 
  thrift_spec = (
25955 
  )
25956 
 
25957 
  def read(self, iprot):
25958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25960 
      return
25961 
    iprot.readStructBegin()
25962 
    while True:
25963 
      (fname, ftype, fid) = iprot.readFieldBegin()
25964 
      if ftype == TType.STOP:
25965 
        break
25966 
      else:
25967 
        iprot.skip(ftype)
25968 
      iprot.readFieldEnd()
25969 
    iprot.readStructEnd()
25970 
 
25971 
  def write(self, oprot):
25972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25974 
      return
25975 
    oprot.writeStructBegin('setOrderAttributes_result')
25976 
    oprot.writeFieldStop()
25977 
    oprot.writeStructEnd()
25978 
 
25979 
  def validate(self):
25980 
    return
25981 
 
25982 
 
25983 
  def __repr__(self):
25984 
    L = ['%s=%r' % (key, value)
25985 
      for key, value in self.__dict__.iteritems()]
25986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25987 
 
25988 
  def __eq__(self, other):
25989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25990 
 
25991 
  def __ne__(self, other):
25992 
    return not (self == other)
25993 
 
5527 anupam.sin 25994 
class setOrderAttributeForTransaction_args:
25995 
  """
25996 
  Attributes:
25997 
   - transactionId
25998 
   - attribute
25999 
  """
26000 
 
26001 
  thrift_spec = None
26002 
  def __init__(self, transactionId=None, attribute=None,):
26003 
    self.transactionId = transactionId
26004 
    self.attribute = attribute
26005 
 
26006 
  def read(self, iprot):
26007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26009 
      return
26010 
    iprot.readStructBegin()
26011 
    while True:
26012 
      (fname, ftype, fid) = iprot.readFieldBegin()
26013 
      if ftype == TType.STOP:
26014 
        break
26015 
      if fid == 1:
26016 
        if ftype == TType.I64:
26017 
          self.transactionId = iprot.readI64();
26018 
        else:
26019 
          iprot.skip(ftype)
26020 
      elif fid == -1:
26021 
        if ftype == TType.STRUCT:
26022 
          self.attribute = Attribute()
26023 
          self.attribute.read(iprot)
26024 
        else:
26025 
          iprot.skip(ftype)
26026 
      else:
26027 
        iprot.skip(ftype)
26028 
      iprot.readFieldEnd()
26029 
    iprot.readStructEnd()
26030 
 
26031 
  def write(self, oprot):
26032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26034 
      return
26035 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26036 
    if self.attribute is not None:
26037 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26038 
      self.attribute.write(oprot)
26039 
      oprot.writeFieldEnd()
26040 
    if self.transactionId is not None:
26041 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26042 
      oprot.writeI64(self.transactionId)
26043 
      oprot.writeFieldEnd()
26044 
    oprot.writeFieldStop()
26045 
    oprot.writeStructEnd()
26046 
 
26047 
  def validate(self):
26048 
    return
26049 
 
26050 
 
26051 
  def __repr__(self):
26052 
    L = ['%s=%r' % (key, value)
26053 
      for key, value in self.__dict__.iteritems()]
26054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26055 
 
26056 
  def __eq__(self, other):
26057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26058 
 
26059 
  def __ne__(self, other):
26060 
    return not (self == other)
26061 
 
26062 
class setOrderAttributeForTransaction_result:
26063 
 
26064 
  thrift_spec = (
26065 
  )
26066 
 
26067 
  def read(self, iprot):
26068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26070 
      return
26071 
    iprot.readStructBegin()
26072 
    while True:
26073 
      (fname, ftype, fid) = iprot.readFieldBegin()
26074 
      if ftype == TType.STOP:
26075 
        break
26076 
      else:
26077 
        iprot.skip(ftype)
26078 
      iprot.readFieldEnd()
26079 
    iprot.readStructEnd()
26080 
 
26081 
  def write(self, oprot):
26082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26084 
      return
26085 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26086 
    oprot.writeFieldStop()
26087 
    oprot.writeStructEnd()
26088 
 
26089 
  def validate(self):
26090 
    return
26091 
 
26092 
 
26093 
  def __repr__(self):
26094 
    L = ['%s=%r' % (key, value)
26095 
      for key, value in self.__dict__.iteritems()]
26096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26097 
 
26098 
  def __eq__(self, other):
26099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26100 
 
26101 
  def __ne__(self, other):
26102 
    return not (self == other)
5553 rajveer 26103 
 
26104 
class getReceivePendingOrders_args:
26105 
  """
26106 
  Attributes:
26107 
   - storeId
26108 
  """
26109 
 
26110 
  thrift_spec = (
26111 
    None, # 0
26112 
    (1, TType.I64, 'storeId', None, None, ), # 1
26113 
  )
26114 
 
26115 
  def __init__(self, storeId=None,):
26116 
    self.storeId = storeId
26117 
 
26118 
  def read(self, iprot):
26119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26121 
      return
26122 
    iprot.readStructBegin()
26123 
    while True:
26124 
      (fname, ftype, fid) = iprot.readFieldBegin()
26125 
      if ftype == TType.STOP:
26126 
        break
26127 
      if fid == 1:
26128 
        if ftype == TType.I64:
26129 
          self.storeId = iprot.readI64();
26130 
        else:
26131 
          iprot.skip(ftype)
26132 
      else:
26133 
        iprot.skip(ftype)
26134 
      iprot.readFieldEnd()
26135 
    iprot.readStructEnd()
26136 
 
26137 
  def write(self, oprot):
26138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26140 
      return
26141 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26142 
    if self.storeId is not None:
26143 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26144 
      oprot.writeI64(self.storeId)
26145 
      oprot.writeFieldEnd()
26146 
    oprot.writeFieldStop()
26147 
    oprot.writeStructEnd()
26148 
 
26149 
  def validate(self):
26150 
    return
26151 
 
26152 
 
26153 
  def __repr__(self):
26154 
    L = ['%s=%r' % (key, value)
26155 
      for key, value in self.__dict__.iteritems()]
26156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26157 
 
26158 
  def __eq__(self, other):
26159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26160 
 
26161 
  def __ne__(self, other):
26162 
    return not (self == other)
26163 
 
26164 
class getReceivePendingOrders_result:
26165 
  """
26166 
  Attributes:
26167 
   - success
26168 
  """
26169 
 
26170 
  thrift_spec = (
26171 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26172 
  )
26173 
 
26174 
  def __init__(self, success=None,):
26175 
    self.success = success
26176 
 
26177 
  def read(self, iprot):
26178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26180 
      return
26181 
    iprot.readStructBegin()
26182 
    while True:
26183 
      (fname, ftype, fid) = iprot.readFieldBegin()
26184 
      if ftype == TType.STOP:
26185 
        break
26186 
      if fid == 0:
26187 
        if ftype == TType.LIST:
26188 
          self.success = []
6188 rajveer 26189 
          (_etype638, _size635) = iprot.readListBegin()
26190 
          for _i639 in xrange(_size635):
26191 
            _elem640 = Order()
26192 
            _elem640.read(iprot)
26193 
            self.success.append(_elem640)
5553 rajveer 26194 
          iprot.readListEnd()
26195 
        else:
26196 
          iprot.skip(ftype)
26197 
      else:
26198 
        iprot.skip(ftype)
26199 
      iprot.readFieldEnd()
26200 
    iprot.readStructEnd()
26201 
 
26202 
  def write(self, oprot):
26203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26205 
      return
26206 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26207 
    if self.success is not None:
26208 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26209 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26210 
      for iter641 in self.success:
26211 
        iter641.write(oprot)
5553 rajveer 26212 
      oprot.writeListEnd()
26213 
      oprot.writeFieldEnd()
26214 
    oprot.writeFieldStop()
26215 
    oprot.writeStructEnd()
26216 
 
26217 
  def validate(self):
26218 
    return
26219 
 
26220 
 
26221 
  def __repr__(self):
26222 
    L = ['%s=%r' % (key, value)
26223 
      for key, value in self.__dict__.iteritems()]
26224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26225 
 
26226 
  def __eq__(self, other):
26227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26228 
 
26229 
  def __ne__(self, other):
26230 
    return not (self == other)
26231 
 
26232 
class getReceivedAtStoreOrders_args:
26233 
  """
26234 
  Attributes:
26235 
   - storeId
26236 
  """
26237 
 
26238 
  thrift_spec = (
26239 
    None, # 0
26240 
    (1, TType.I64, 'storeId', None, None, ), # 1
26241 
  )
26242 
 
26243 
  def __init__(self, storeId=None,):
26244 
    self.storeId = storeId
26245 
 
26246 
  def read(self, iprot):
26247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26249 
      return
26250 
    iprot.readStructBegin()
26251 
    while True:
26252 
      (fname, ftype, fid) = iprot.readFieldBegin()
26253 
      if ftype == TType.STOP:
26254 
        break
26255 
      if fid == 1:
26256 
        if ftype == TType.I64:
26257 
          self.storeId = iprot.readI64();
26258 
        else:
26259 
          iprot.skip(ftype)
26260 
      else:
26261 
        iprot.skip(ftype)
26262 
      iprot.readFieldEnd()
26263 
    iprot.readStructEnd()
26264 
 
26265 
  def write(self, oprot):
26266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26268 
      return
26269 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26270 
    if self.storeId is not None:
26271 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26272 
      oprot.writeI64(self.storeId)
26273 
      oprot.writeFieldEnd()
26274 
    oprot.writeFieldStop()
26275 
    oprot.writeStructEnd()
26276 
 
26277 
  def validate(self):
26278 
    return
26279 
 
26280 
 
26281 
  def __repr__(self):
26282 
    L = ['%s=%r' % (key, value)
26283 
      for key, value in self.__dict__.iteritems()]
26284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26285 
 
26286 
  def __eq__(self, other):
26287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26288 
 
26289 
  def __ne__(self, other):
26290 
    return not (self == other)
26291 
 
26292 
class getReceivedAtStoreOrders_result:
26293 
  """
26294 
  Attributes:
26295 
   - success
26296 
  """
26297 
 
26298 
  thrift_spec = (
26299 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26300 
  )
26301 
 
26302 
  def __init__(self, success=None,):
26303 
    self.success = success
26304 
 
26305 
  def read(self, iprot):
26306 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26307 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26308 
      return
26309 
    iprot.readStructBegin()
26310 
    while True:
26311 
      (fname, ftype, fid) = iprot.readFieldBegin()
26312 
      if ftype == TType.STOP:
26313 
        break
26314 
      if fid == 0:
26315 
        if ftype == TType.LIST:
26316 
          self.success = []
6188 rajveer 26317 
          (_etype645, _size642) = iprot.readListBegin()
26318 
          for _i646 in xrange(_size642):
26319 
            _elem647 = Order()
26320 
            _elem647.read(iprot)
26321 
            self.success.append(_elem647)
5553 rajveer 26322 
          iprot.readListEnd()
26323 
        else:
26324 
          iprot.skip(ftype)
26325 
      else:
26326 
        iprot.skip(ftype)
26327 
      iprot.readFieldEnd()
26328 
    iprot.readStructEnd()
26329 
 
26330 
  def write(self, oprot):
26331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26333 
      return
26334 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26335 
    if self.success is not None:
26336 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26337 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26338 
      for iter648 in self.success:
26339 
        iter648.write(oprot)
5553 rajveer 26340 
      oprot.writeListEnd()
26341 
      oprot.writeFieldEnd()
26342 
    oprot.writeFieldStop()
26343 
    oprot.writeStructEnd()
26344 
 
26345 
  def validate(self):
26346 
    return
26347 
 
26348 
 
26349 
  def __repr__(self):
26350 
    L = ['%s=%r' % (key, value)
26351 
      for key, value in self.__dict__.iteritems()]
26352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26353 
 
26354 
  def __eq__(self, other):
26355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26356 
 
26357 
  def __ne__(self, other):
26358 
    return not (self == other)
5593 mandeep.dh 26359 
 
5713 rajveer 26360 
class getOrdersCollectionAtStore_args:
26361 
  """
26362 
  Attributes:
26363 
   - storeId
26364 
   - fromDate
26365 
   - toDate
26366 
   - onlyCod
26367 
  """
26368 
 
26369 
  thrift_spec = (
26370 
    None, # 0
26371 
    (1, TType.I64, 'storeId', None, None, ), # 1
26372 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26373 
    (3, TType.I64, 'toDate', None, None, ), # 3
26374 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26375 
  )
26376 
 
26377 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26378 
    self.storeId = storeId
26379 
    self.fromDate = fromDate
26380 
    self.toDate = toDate
26381 
    self.onlyCod = onlyCod
26382 
 
26383 
  def read(self, iprot):
26384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26386 
      return
26387 
    iprot.readStructBegin()
26388 
    while True:
26389 
      (fname, ftype, fid) = iprot.readFieldBegin()
26390 
      if ftype == TType.STOP:
26391 
        break
26392 
      if fid == 1:
26393 
        if ftype == TType.I64:
26394 
          self.storeId = iprot.readI64();
26395 
        else:
26396 
          iprot.skip(ftype)
26397 
      elif fid == 2:
26398 
        if ftype == TType.I64:
26399 
          self.fromDate = iprot.readI64();
26400 
        else:
26401 
          iprot.skip(ftype)
26402 
      elif fid == 3:
26403 
        if ftype == TType.I64:
26404 
          self.toDate = iprot.readI64();
26405 
        else:
26406 
          iprot.skip(ftype)
26407 
      elif fid == 4:
26408 
        if ftype == TType.BOOL:
26409 
          self.onlyCod = iprot.readBool();
26410 
        else:
26411 
          iprot.skip(ftype)
26412 
      else:
26413 
        iprot.skip(ftype)
26414 
      iprot.readFieldEnd()
26415 
    iprot.readStructEnd()
26416 
 
26417 
  def write(self, oprot):
26418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26420 
      return
26421 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26422 
    if self.storeId is not None:
26423 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26424 
      oprot.writeI64(self.storeId)
26425 
      oprot.writeFieldEnd()
26426 
    if self.fromDate is not None:
26427 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26428 
      oprot.writeI64(self.fromDate)
26429 
      oprot.writeFieldEnd()
26430 
    if self.toDate is not None:
26431 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26432 
      oprot.writeI64(self.toDate)
26433 
      oprot.writeFieldEnd()
26434 
    if self.onlyCod is not None:
26435 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26436 
      oprot.writeBool(self.onlyCod)
26437 
      oprot.writeFieldEnd()
26438 
    oprot.writeFieldStop()
26439 
    oprot.writeStructEnd()
26440 
 
26441 
  def validate(self):
26442 
    return
26443 
 
26444 
 
26445 
  def __repr__(self):
26446 
    L = ['%s=%r' % (key, value)
26447 
      for key, value in self.__dict__.iteritems()]
26448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26449 
 
26450 
  def __eq__(self, other):
26451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26452 
 
26453 
  def __ne__(self, other):
26454 
    return not (self == other)
26455 
 
26456 
class getOrdersCollectionAtStore_result:
26457 
  """
26458 
  Attributes:
26459 
   - success
26460 
  """
26461 
 
26462 
  thrift_spec = (
26463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26464 
  )
26465 
 
26466 
  def __init__(self, success=None,):
26467 
    self.success = success
26468 
 
26469 
  def read(self, iprot):
26470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26472 
      return
26473 
    iprot.readStructBegin()
26474 
    while True:
26475 
      (fname, ftype, fid) = iprot.readFieldBegin()
26476 
      if ftype == TType.STOP:
26477 
        break
26478 
      if fid == 0:
26479 
        if ftype == TType.LIST:
26480 
          self.success = []
6188 rajveer 26481 
          (_etype652, _size649) = iprot.readListBegin()
26482 
          for _i653 in xrange(_size649):
26483 
            _elem654 = Order()
26484 
            _elem654.read(iprot)
26485 
            self.success.append(_elem654)
5713 rajveer 26486 
          iprot.readListEnd()
26487 
        else:
26488 
          iprot.skip(ftype)
26489 
      else:
26490 
        iprot.skip(ftype)
26491 
      iprot.readFieldEnd()
26492 
    iprot.readStructEnd()
26493 
 
26494 
  def write(self, oprot):
26495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26497 
      return
26498 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26499 
    if self.success is not None:
26500 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26501 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26502 
      for iter655 in self.success:
26503 
        iter655.write(oprot)
5713 rajveer 26504 
      oprot.writeListEnd()
26505 
      oprot.writeFieldEnd()
26506 
    oprot.writeFieldStop()
26507 
    oprot.writeStructEnd()
26508 
 
26509 
  def validate(self):
26510 
    return
26511 
 
26512 
 
26513 
  def __repr__(self):
26514 
    L = ['%s=%r' % (key, value)
26515 
      for key, value in self.__dict__.iteritems()]
26516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26517 
 
26518 
  def __eq__(self, other):
26519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26520 
 
26521 
  def __ne__(self, other):
26522 
    return not (self == other)
26523 
 
5833 rajveer 26524 
class getOrderAttributeValue_args:
26525 
  """
26526 
  Attributes:
26527 
   - orderId
26528 
   - attributeName
26529 
  """
26530 
 
26531 
  thrift_spec = None
26532 
  def __init__(self, orderId=None, attributeName=None,):
26533 
    self.orderId = orderId
26534 
    self.attributeName = attributeName
26535 
 
26536 
  def read(self, iprot):
26537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26539 
      return
26540 
    iprot.readStructBegin()
26541 
    while True:
26542 
      (fname, ftype, fid) = iprot.readFieldBegin()
26543 
      if ftype == TType.STOP:
26544 
        break
26545 
      if fid == 1:
26546 
        if ftype == TType.I64:
26547 
          self.orderId = iprot.readI64();
26548 
        else:
26549 
          iprot.skip(ftype)
26550 
      elif fid == -1:
26551 
        if ftype == TType.STRING:
26552 
          self.attributeName = iprot.readString();
26553 
        else:
26554 
          iprot.skip(ftype)
26555 
      else:
26556 
        iprot.skip(ftype)
26557 
      iprot.readFieldEnd()
26558 
    iprot.readStructEnd()
26559 
 
26560 
  def write(self, oprot):
26561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26563 
      return
26564 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26565 
    if self.attributeName is not None:
26566 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26567 
      oprot.writeString(self.attributeName)
26568 
      oprot.writeFieldEnd()
26569 
    if self.orderId is not None:
26570 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26571 
      oprot.writeI64(self.orderId)
26572 
      oprot.writeFieldEnd()
26573 
    oprot.writeFieldStop()
26574 
    oprot.writeStructEnd()
26575 
 
26576 
  def validate(self):
26577 
    return
26578 
 
26579 
 
26580 
  def __repr__(self):
26581 
    L = ['%s=%r' % (key, value)
26582 
      for key, value in self.__dict__.iteritems()]
26583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26584 
 
26585 
  def __eq__(self, other):
26586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26587 
 
26588 
  def __ne__(self, other):
26589 
    return not (self == other)
26590 
 
26591 
class getOrderAttributeValue_result:
26592 
  """
26593 
  Attributes:
26594 
   - success
26595 
  """
26596 
 
26597 
  thrift_spec = (
26598 
    (0, TType.STRING, 'success', None, None, ), # 0
26599 
  )
26600 
 
26601 
  def __init__(self, success=None,):
26602 
    self.success = success
26603 
 
26604 
  def read(self, iprot):
26605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26607 
      return
26608 
    iprot.readStructBegin()
26609 
    while True:
26610 
      (fname, ftype, fid) = iprot.readFieldBegin()
26611 
      if ftype == TType.STOP:
26612 
        break
26613 
      if fid == 0:
26614 
        if ftype == TType.STRING:
26615 
          self.success = iprot.readString();
26616 
        else:
26617 
          iprot.skip(ftype)
26618 
      else:
26619 
        iprot.skip(ftype)
26620 
      iprot.readFieldEnd()
26621 
    iprot.readStructEnd()
26622 
 
26623 
  def write(self, oprot):
26624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26626 
      return
26627 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26628 
    if self.success is not None:
26629 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26630 
      oprot.writeString(self.success)
26631 
      oprot.writeFieldEnd()
26632 
    oprot.writeFieldStop()
26633 
    oprot.writeStructEnd()
26634 
 
26635 
  def validate(self):
26636 
    return
26637 
 
26638 
 
26639 
  def __repr__(self):
26640 
    L = ['%s=%r' % (key, value)
26641 
      for key, value in self.__dict__.iteritems()]
26642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26643 
 
26644 
  def __eq__(self, other):
26645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26646 
 
26647 
  def __ne__(self, other):
26648 
    return not (self == other)
26649 
 
6019 rajveer 26650 
class changeJacketNumber_args:
26651 
  """
26652 
  Attributes:
26653 
   - orderId
26654 
   - jacketNumber
26655 
  """
26656 
 
26657 
  thrift_spec = (
26658 
    None, # 0
26659 
    (1, TType.I64, 'orderId', None, None, ), # 1
26660 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26661 
  )
26662 
 
26663 
  def __init__(self, orderId=None, jacketNumber=None,):
26664 
    self.orderId = orderId
26665 
    self.jacketNumber = jacketNumber
26666 
 
26667 
  def read(self, iprot):
26668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26670 
      return
26671 
    iprot.readStructBegin()
26672 
    while True:
26673 
      (fname, ftype, fid) = iprot.readFieldBegin()
26674 
      if ftype == TType.STOP:
26675 
        break
26676 
      if fid == 1:
26677 
        if ftype == TType.I64:
26678 
          self.orderId = iprot.readI64();
26679 
        else:
26680 
          iprot.skip(ftype)
26681 
      elif fid == 2:
26682 
        if ftype == TType.I64:
26683 
          self.jacketNumber = iprot.readI64();
26684 
        else:
26685 
          iprot.skip(ftype)
26686 
      else:
26687 
        iprot.skip(ftype)
26688 
      iprot.readFieldEnd()
26689 
    iprot.readStructEnd()
26690 
 
26691 
  def write(self, oprot):
26692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26694 
      return
26695 
    oprot.writeStructBegin('changeJacketNumber_args')
26696 
    if self.orderId is not None:
26697 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26698 
      oprot.writeI64(self.orderId)
26699 
      oprot.writeFieldEnd()
26700 
    if self.jacketNumber is not None:
26701 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26702 
      oprot.writeI64(self.jacketNumber)
26703 
      oprot.writeFieldEnd()
26704 
    oprot.writeFieldStop()
26705 
    oprot.writeStructEnd()
26706 
 
26707 
  def validate(self):
26708 
    return
26709 
 
26710 
 
26711 
  def __repr__(self):
26712 
    L = ['%s=%r' % (key, value)
26713 
      for key, value in self.__dict__.iteritems()]
26714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26715 
 
26716 
  def __eq__(self, other):
26717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26718 
 
26719 
  def __ne__(self, other):
26720 
    return not (self == other)
26721 
 
26722 
class changeJacketNumber_result:
26723 
  """
26724 
  Attributes:
26725 
   - success
26726 
  """
26727 
 
26728 
  thrift_spec = (
26729 
    (0, TType.BOOL, 'success', None, None, ), # 0
26730 
  )
26731 
 
26732 
  def __init__(self, success=None,):
26733 
    self.success = success
26734 
 
26735 
  def read(self, iprot):
26736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26738 
      return
26739 
    iprot.readStructBegin()
26740 
    while True:
26741 
      (fname, ftype, fid) = iprot.readFieldBegin()
26742 
      if ftype == TType.STOP:
26743 
        break
26744 
      if fid == 0:
26745 
        if ftype == TType.BOOL:
26746 
          self.success = iprot.readBool();
26747 
        else:
26748 
          iprot.skip(ftype)
26749 
      else:
26750 
        iprot.skip(ftype)
26751 
      iprot.readFieldEnd()
26752 
    iprot.readStructEnd()
26753 
 
26754 
  def write(self, oprot):
26755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26757 
      return
26758 
    oprot.writeStructBegin('changeJacketNumber_result')
26759 
    if self.success is not None:
26760 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26761 
      oprot.writeBool(self.success)
26762 
      oprot.writeFieldEnd()
26763 
    oprot.writeFieldStop()
26764 
    oprot.writeStructEnd()
26765 
 
26766 
  def validate(self):
26767 
    return
26768 
 
26769 
 
26770 
  def __repr__(self):
26771 
    L = ['%s=%r' % (key, value)
26772 
      for key, value in self.__dict__.iteritems()]
26773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26774 
 
26775 
  def __eq__(self, other):
26776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26777 
 
26778 
  def __ne__(self, other):
26779 
    return not (self == other)
26780 
 
26781 
class markOrderAsRtoInTransit_args:
26782 
  """
26783 
  Attributes:
26784 
   - orderId
26785 
  """
26786 
 
26787 
  thrift_spec = (
26788 
    None, # 0
26789 
    (1, TType.I64, 'orderId', None, None, ), # 1
26790 
  )
26791 
 
26792 
  def __init__(self, orderId=None,):
26793 
    self.orderId = orderId
26794 
 
26795 
  def read(self, iprot):
26796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26798 
      return
26799 
    iprot.readStructBegin()
26800 
    while True:
26801 
      (fname, ftype, fid) = iprot.readFieldBegin()
26802 
      if ftype == TType.STOP:
26803 
        break
26804 
      if fid == 1:
26805 
        if ftype == TType.I64:
26806 
          self.orderId = iprot.readI64();
26807 
        else:
26808 
          iprot.skip(ftype)
26809 
      else:
26810 
        iprot.skip(ftype)
26811 
      iprot.readFieldEnd()
26812 
    iprot.readStructEnd()
26813 
 
26814 
  def write(self, oprot):
26815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26817 
      return
26818 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26819 
    if self.orderId is not None:
26820 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26821 
      oprot.writeI64(self.orderId)
26822 
      oprot.writeFieldEnd()
26823 
    oprot.writeFieldStop()
26824 
    oprot.writeStructEnd()
26825 
 
26826 
  def validate(self):
26827 
    return
26828 
 
26829 
 
26830 
  def __repr__(self):
26831 
    L = ['%s=%r' % (key, value)
26832 
      for key, value in self.__dict__.iteritems()]
26833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26834 
 
26835 
  def __eq__(self, other):
26836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26837 
 
26838 
  def __ne__(self, other):
26839 
    return not (self == other)
26840 
 
26841 
class markOrderAsRtoInTransit_result:
26842 
  """
26843 
  Attributes:
26844 
   - success
26845 
  """
26846 
 
26847 
  thrift_spec = (
26848 
    (0, TType.BOOL, 'success', None, None, ), # 0
26849 
  )
26850 
 
26851 
  def __init__(self, success=None,):
26852 
    self.success = success
26853 
 
26854 
  def read(self, iprot):
26855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26857 
      return
26858 
    iprot.readStructBegin()
26859 
    while True:
26860 
      (fname, ftype, fid) = iprot.readFieldBegin()
26861 
      if ftype == TType.STOP:
26862 
        break
26863 
      if fid == 0:
26864 
        if ftype == TType.BOOL:
26865 
          self.success = iprot.readBool();
26866 
        else:
26867 
          iprot.skip(ftype)
26868 
      else:
26869 
        iprot.skip(ftype)
26870 
      iprot.readFieldEnd()
26871 
    iprot.readStructEnd()
26872 
 
26873 
  def write(self, oprot):
26874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26876 
      return
26877 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26878 
    if self.success is not None:
26879 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26880 
      oprot.writeBool(self.success)
26881 
      oprot.writeFieldEnd()
26882 
    oprot.writeFieldStop()
26883 
    oprot.writeStructEnd()
26884 
 
26885 
  def validate(self):
26886 
    return
26887 
 
26888 
 
26889 
  def __repr__(self):
26890 
    L = ['%s=%r' % (key, value)
26891 
      for key, value in self.__dict__.iteritems()]
26892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26893 
 
26894 
  def __eq__(self, other):
26895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26896 
 
26897 
  def __ne__(self, other):
26898 
    return not (self == other)
26899 
 
5593 mandeep.dh 26900 
class acceptOrderForItem_args:
26901 
  """
26902 
  Attributes:
26903 
   - itemId
26904 
   - quantity
26905 
   - fulfilmentWarehouseId
26906 
   - billingWarehouseId
26907 
  """
26908 
 
26909 
  thrift_spec = (
26910 
    None, # 0
26911 
    (1, TType.I64, 'itemId', None, None, ), # 1
26912 
    (2, TType.I64, 'quantity', None, None, ), # 2
26913 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26914 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26915 
  )
26916 
 
26917 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26918 
    self.itemId = itemId
26919 
    self.quantity = quantity
26920 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26921 
    self.billingWarehouseId = billingWarehouseId
26922 
 
26923 
  def read(self, iprot):
26924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26926 
      return
26927 
    iprot.readStructBegin()
26928 
    while True:
26929 
      (fname, ftype, fid) = iprot.readFieldBegin()
26930 
      if ftype == TType.STOP:
26931 
        break
26932 
      if fid == 1:
26933 
        if ftype == TType.I64:
26934 
          self.itemId = iprot.readI64();
26935 
        else:
26936 
          iprot.skip(ftype)
26937 
      elif fid == 2:
26938 
        if ftype == TType.I64:
26939 
          self.quantity = iprot.readI64();
26940 
        else:
26941 
          iprot.skip(ftype)
26942 
      elif fid == 3:
26943 
        if ftype == TType.I64:
26944 
          self.fulfilmentWarehouseId = iprot.readI64();
26945 
        else:
26946 
          iprot.skip(ftype)
26947 
      elif fid == 4:
26948 
        if ftype == TType.I64:
26949 
          self.billingWarehouseId = iprot.readI64();
26950 
        else:
26951 
          iprot.skip(ftype)
26952 
      else:
26953 
        iprot.skip(ftype)
26954 
      iprot.readFieldEnd()
26955 
    iprot.readStructEnd()
26956 
 
26957 
  def write(self, oprot):
26958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26960 
      return
26961 
    oprot.writeStructBegin('acceptOrderForItem_args')
26962 
    if self.itemId is not None:
26963 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26964 
      oprot.writeI64(self.itemId)
26965 
      oprot.writeFieldEnd()
26966 
    if self.quantity is not None:
26967 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26968 
      oprot.writeI64(self.quantity)
26969 
      oprot.writeFieldEnd()
26970 
    if self.fulfilmentWarehouseId is not None:
26971 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26972 
      oprot.writeI64(self.fulfilmentWarehouseId)
26973 
      oprot.writeFieldEnd()
26974 
    if self.billingWarehouseId is not None:
26975 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26976 
      oprot.writeI64(self.billingWarehouseId)
26977 
      oprot.writeFieldEnd()
26978 
    oprot.writeFieldStop()
26979 
    oprot.writeStructEnd()
26980 
 
26981 
  def validate(self):
26982 
    return
26983 
 
26984 
 
26985 
  def __repr__(self):
26986 
    L = ['%s=%r' % (key, value)
26987 
      for key, value in self.__dict__.iteritems()]
26988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26989 
 
26990 
  def __eq__(self, other):
26991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26992 
 
26993 
  def __ne__(self, other):
26994 
    return not (self == other)
26995 
 
26996 
class acceptOrderForItem_result:
26997 
 
26998 
  thrift_spec = (
26999 
  )
27000 
 
27001 
  def read(self, iprot):
27002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27004 
      return
27005 
    iprot.readStructBegin()
27006 
    while True:
27007 
      (fname, ftype, fid) = iprot.readFieldBegin()
27008 
      if ftype == TType.STOP:
27009 
        break
27010 
      else:
27011 
        iprot.skip(ftype)
27012 
      iprot.readFieldEnd()
27013 
    iprot.readStructEnd()
27014 
 
27015 
  def write(self, oprot):
27016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27018 
      return
27019 
    oprot.writeStructBegin('acceptOrderForItem_result')
27020 
    oprot.writeFieldStop()
27021 
    oprot.writeStructEnd()
27022 
 
27023 
  def validate(self):
27024 
    return
27025 
 
27026 
 
27027 
  def __repr__(self):
27028 
    L = ['%s=%r' % (key, value)
27029 
      for key, value in self.__dict__.iteritems()]
27030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27031 
 
27032 
  def __eq__(self, other):
27033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27034 
 
27035 
  def __ne__(self, other):
27036 
    return not (self == other)
6000 mandeep.dh 27037 
 
27038 
class createRechargeOrder_args:
27039 
  """
27040 
  Attributes:
27041 
   - rechargeOrder
27042 
  """
27043 
 
27044 
  thrift_spec = (
27045 
    None, # 0
27046 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27047 
  )
27048 
 
27049 
  def __init__(self, rechargeOrder=None,):
27050 
    self.rechargeOrder = rechargeOrder
27051 
 
27052 
  def read(self, iprot):
27053 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27054 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27055 
      return
27056 
    iprot.readStructBegin()
27057 
    while True:
27058 
      (fname, ftype, fid) = iprot.readFieldBegin()
27059 
      if ftype == TType.STOP:
27060 
        break
27061 
      if fid == 1:
27062 
        if ftype == TType.STRUCT:
27063 
          self.rechargeOrder = RechargeOrder()
27064 
          self.rechargeOrder.read(iprot)
27065 
        else:
27066 
          iprot.skip(ftype)
27067 
      else:
27068 
        iprot.skip(ftype)
27069 
      iprot.readFieldEnd()
27070 
    iprot.readStructEnd()
27071 
 
27072 
  def write(self, oprot):
27073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27075 
      return
27076 
    oprot.writeStructBegin('createRechargeOrder_args')
27077 
    if self.rechargeOrder is not None:
27078 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27079 
      self.rechargeOrder.write(oprot)
27080 
      oprot.writeFieldEnd()
27081 
    oprot.writeFieldStop()
27082 
    oprot.writeStructEnd()
27083 
 
27084 
  def validate(self):
27085 
    return
27086 
 
27087 
 
27088 
  def __repr__(self):
27089 
    L = ['%s=%r' % (key, value)
27090 
      for key, value in self.__dict__.iteritems()]
27091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27092 
 
27093 
  def __eq__(self, other):
27094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27095 
 
27096 
  def __ne__(self, other):
27097 
    return not (self == other)
27098 
 
27099 
class createRechargeOrder_result:
27100 
  """
27101 
  Attributes:
27102 
   - success
27103 
   - ex
27104 
  """
27105 
 
27106 
  thrift_spec = (
27107 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27109 
  )
27110 
 
27111 
  def __init__(self, success=None, ex=None,):
27112 
    self.success = success
27113 
    self.ex = ex
27114 
 
27115 
  def read(self, iprot):
27116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27118 
      return
27119 
    iprot.readStructBegin()
27120 
    while True:
27121 
      (fname, ftype, fid) = iprot.readFieldBegin()
27122 
      if ftype == TType.STOP:
27123 
        break
27124 
      if fid == 0:
27125 
        if ftype == TType.STRUCT:
27126 
          self.success = RechargeOrder()
27127 
          self.success.read(iprot)
27128 
        else:
27129 
          iprot.skip(ftype)
27130 
      elif fid == 1:
27131 
        if ftype == TType.STRUCT:
27132 
          self.ex = TransactionServiceException()
27133 
          self.ex.read(iprot)
27134 
        else:
27135 
          iprot.skip(ftype)
27136 
      else:
27137 
        iprot.skip(ftype)
27138 
      iprot.readFieldEnd()
27139 
    iprot.readStructEnd()
27140 
 
27141 
  def write(self, oprot):
27142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27144 
      return
27145 
    oprot.writeStructBegin('createRechargeOrder_result')
27146 
    if self.success is not None:
27147 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27148 
      self.success.write(oprot)
27149 
      oprot.writeFieldEnd()
27150 
    if self.ex is not None:
27151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27152 
      self.ex.write(oprot)
27153 
      oprot.writeFieldEnd()
27154 
    oprot.writeFieldStop()
27155 
    oprot.writeStructEnd()
27156 
 
27157 
  def validate(self):
27158 
    return
27159 
 
27160 
 
27161 
  def __repr__(self):
27162 
    L = ['%s=%r' % (key, value)
27163 
      for key, value in self.__dict__.iteritems()]
27164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27165 
 
27166 
  def __eq__(self, other):
27167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27168 
 
27169 
  def __ne__(self, other):
27170 
    return not (self == other)
27171 
 
6031 rajveer 27172 
class getRechargeOrder_args:
27173 
  """
27174 
  Attributes:
27175 
   - rechargeRrderId
27176 
  """
27177 
 
27178 
  thrift_spec = (
27179 
    None, # 0
27180 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27181 
  )
27182 
 
27183 
  def __init__(self, rechargeRrderId=None,):
27184 
    self.rechargeRrderId = rechargeRrderId
27185 
 
27186 
  def read(self, iprot):
27187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27189 
      return
27190 
    iprot.readStructBegin()
27191 
    while True:
27192 
      (fname, ftype, fid) = iprot.readFieldBegin()
27193 
      if ftype == TType.STOP:
27194 
        break
27195 
      if fid == 1:
27196 
        if ftype == TType.I64:
27197 
          self.rechargeRrderId = iprot.readI64();
27198 
        else:
27199 
          iprot.skip(ftype)
27200 
      else:
27201 
        iprot.skip(ftype)
27202 
      iprot.readFieldEnd()
27203 
    iprot.readStructEnd()
27204 
 
27205 
  def write(self, oprot):
27206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27208 
      return
27209 
    oprot.writeStructBegin('getRechargeOrder_args')
27210 
    if self.rechargeRrderId is not None:
27211 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27212 
      oprot.writeI64(self.rechargeRrderId)
27213 
      oprot.writeFieldEnd()
27214 
    oprot.writeFieldStop()
27215 
    oprot.writeStructEnd()
27216 
 
27217 
  def validate(self):
27218 
    return
27219 
 
27220 
 
27221 
  def __repr__(self):
27222 
    L = ['%s=%r' % (key, value)
27223 
      for key, value in self.__dict__.iteritems()]
27224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27225 
 
27226 
  def __eq__(self, other):
27227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27228 
 
27229 
  def __ne__(self, other):
27230 
    return not (self == other)
27231 
 
27232 
class getRechargeOrder_result:
27233 
  """
27234 
  Attributes:
27235 
   - success
27236 
   - ex
27237 
  """
27238 
 
27239 
  thrift_spec = (
27240 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27242 
  )
27243 
 
27244 
  def __init__(self, success=None, ex=None,):
27245 
    self.success = success
27246 
    self.ex = ex
27247 
 
27248 
  def read(self, iprot):
27249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27251 
      return
27252 
    iprot.readStructBegin()
27253 
    while True:
27254 
      (fname, ftype, fid) = iprot.readFieldBegin()
27255 
      if ftype == TType.STOP:
27256 
        break
27257 
      if fid == 0:
27258 
        if ftype == TType.STRUCT:
27259 
          self.success = RechargeOrder()
27260 
          self.success.read(iprot)
27261 
        else:
27262 
          iprot.skip(ftype)
27263 
      elif fid == 1:
27264 
        if ftype == TType.STRUCT:
27265 
          self.ex = TransactionServiceException()
27266 
          self.ex.read(iprot)
27267 
        else:
27268 
          iprot.skip(ftype)
27269 
      else:
27270 
        iprot.skip(ftype)
27271 
      iprot.readFieldEnd()
27272 
    iprot.readStructEnd()
27273 
 
27274 
  def write(self, oprot):
27275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27277 
      return
27278 
    oprot.writeStructBegin('getRechargeOrder_result')
27279 
    if self.success is not None:
27280 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27281 
      self.success.write(oprot)
27282 
      oprot.writeFieldEnd()
27283 
    if self.ex is not None:
27284 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27285 
      self.ex.write(oprot)
27286 
      oprot.writeFieldEnd()
27287 
    oprot.writeFieldStop()
27288 
    oprot.writeStructEnd()
27289 
 
27290 
  def validate(self):
27291 
    return
27292 
 
27293 
 
27294 
  def __repr__(self):
27295 
    L = ['%s=%r' % (key, value)
27296 
      for key, value in self.__dict__.iteritems()]
27297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27298 
 
27299 
  def __eq__(self, other):
27300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27301 
 
27302 
  def __ne__(self, other):
27303 
    return not (self == other)
27304 
 
27305 
class getRechargeOrders_args:
27306 
  """
27307 
  Attributes:
27308 
   - userId
27309 
  """
27310 
 
27311 
  thrift_spec = (
27312 
    None, # 0
27313 
    (1, TType.I64, 'userId', None, None, ), # 1
27314 
  )
27315 
 
27316 
  def __init__(self, userId=None,):
27317 
    self.userId = userId
27318 
 
27319 
  def read(self, iprot):
27320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27322 
      return
27323 
    iprot.readStructBegin()
27324 
    while True:
27325 
      (fname, ftype, fid) = iprot.readFieldBegin()
27326 
      if ftype == TType.STOP:
27327 
        break
27328 
      if fid == 1:
27329 
        if ftype == TType.I64:
27330 
          self.userId = iprot.readI64();
27331 
        else:
27332 
          iprot.skip(ftype)
27333 
      else:
27334 
        iprot.skip(ftype)
27335 
      iprot.readFieldEnd()
27336 
    iprot.readStructEnd()
27337 
 
27338 
  def write(self, oprot):
27339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27341 
      return
27342 
    oprot.writeStructBegin('getRechargeOrders_args')
27343 
    if self.userId is not None:
27344 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27345 
      oprot.writeI64(self.userId)
27346 
      oprot.writeFieldEnd()
27347 
    oprot.writeFieldStop()
27348 
    oprot.writeStructEnd()
27349 
 
27350 
  def validate(self):
27351 
    return
27352 
 
27353 
 
27354 
  def __repr__(self):
27355 
    L = ['%s=%r' % (key, value)
27356 
      for key, value in self.__dict__.iteritems()]
27357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27358 
 
27359 
  def __eq__(self, other):
27360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27361 
 
27362 
  def __ne__(self, other):
27363 
    return not (self == other)
27364 
 
27365 
class getRechargeOrders_result:
27366 
  """
27367 
  Attributes:
27368 
   - success
27369 
  """
27370 
 
27371 
  thrift_spec = (
27372 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27373 
  )
27374 
 
27375 
  def __init__(self, success=None,):
27376 
    self.success = success
27377 
 
27378 
  def read(self, iprot):
27379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27381 
      return
27382 
    iprot.readStructBegin()
27383 
    while True:
27384 
      (fname, ftype, fid) = iprot.readFieldBegin()
27385 
      if ftype == TType.STOP:
27386 
        break
27387 
      if fid == 0:
27388 
        if ftype == TType.LIST:
27389 
          self.success = []
6188 rajveer 27390 
          (_etype659, _size656) = iprot.readListBegin()
27391 
          for _i660 in xrange(_size656):
27392 
            _elem661 = RechargeOrder()
27393 
            _elem661.read(iprot)
27394 
            self.success.append(_elem661)
6031 rajveer 27395 
          iprot.readListEnd()
27396 
        else:
27397 
          iprot.skip(ftype)
27398 
      else:
27399 
        iprot.skip(ftype)
27400 
      iprot.readFieldEnd()
27401 
    iprot.readStructEnd()
27402 
 
27403 
  def write(self, oprot):
27404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27406 
      return
27407 
    oprot.writeStructBegin('getRechargeOrders_result')
27408 
    if self.success is not None:
27409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27411 
      for iter662 in self.success:
27412 
        iter662.write(oprot)
6031 rajveer 27413 
      oprot.writeListEnd()
27414 
      oprot.writeFieldEnd()
27415 
    oprot.writeFieldStop()
27416 
    oprot.writeStructEnd()
27417 
 
27418 
  def validate(self):
27419 
    return
27420 
 
27421 
 
27422 
  def __repr__(self):
27423 
    L = ['%s=%r' % (key, value)
27424 
      for key, value in self.__dict__.iteritems()]
27425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27426 
 
27427 
  def __eq__(self, other):
27428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27429 
 
27430 
  def __ne__(self, other):
27431 
    return not (self == other)
27432 
 
6000 mandeep.dh 27433 
class updateRechargeOrderStatus_args:
27434 
  """
27435 
  Attributes:
27436 
   - rechargeOrderId
27437 
   - rechargeOrderStatus
27438 
  """
27439 
 
27440 
  thrift_spec = (
27441 
    None, # 0
27442 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27443 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27444 
  )
27445 
 
27446 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27447 
    self.rechargeOrderId = rechargeOrderId
27448 
    self.rechargeOrderStatus = rechargeOrderStatus
27449 
 
27450 
  def read(self, iprot):
27451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27453 
      return
27454 
    iprot.readStructBegin()
27455 
    while True:
27456 
      (fname, ftype, fid) = iprot.readFieldBegin()
27457 
      if ftype == TType.STOP:
27458 
        break
27459 
      if fid == 1:
27460 
        if ftype == TType.I64:
27461 
          self.rechargeOrderId = iprot.readI64();
27462 
        else:
27463 
          iprot.skip(ftype)
27464 
      elif fid == 2:
27465 
        if ftype == TType.I32:
27466 
          self.rechargeOrderStatus = iprot.readI32();
27467 
        else:
27468 
          iprot.skip(ftype)
27469 
      else:
27470 
        iprot.skip(ftype)
27471 
      iprot.readFieldEnd()
27472 
    iprot.readStructEnd()
27473 
 
27474 
  def write(self, oprot):
27475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27477 
      return
27478 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27479 
    if self.rechargeOrderId is not None:
27480 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27481 
      oprot.writeI64(self.rechargeOrderId)
27482 
      oprot.writeFieldEnd()
27483 
    if self.rechargeOrderStatus is not None:
27484 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27485 
      oprot.writeI32(self.rechargeOrderStatus)
27486 
      oprot.writeFieldEnd()
27487 
    oprot.writeFieldStop()
27488 
    oprot.writeStructEnd()
27489 
 
27490 
  def validate(self):
27491 
    return
27492 
 
27493 
 
27494 
  def __repr__(self):
27495 
    L = ['%s=%r' % (key, value)
27496 
      for key, value in self.__dict__.iteritems()]
27497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27498 
 
27499 
  def __eq__(self, other):
27500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27501 
 
27502 
  def __ne__(self, other):
27503 
    return not (self == other)
27504 
 
27505 
class updateRechargeOrderStatus_result:
27506 
  """
27507 
  Attributes:
6031 rajveer 27508 
   - success
6000 mandeep.dh 27509 
   - ex
27510 
  """
27511 
 
27512 
  thrift_spec = (
6031 rajveer 27513 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27514 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27515 
  )
27516 
 
6031 rajveer 27517 
  def __init__(self, success=None, ex=None,):
27518 
    self.success = success
6000 mandeep.dh 27519 
    self.ex = ex
27520 
 
27521 
  def read(self, iprot):
27522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27524 
      return
27525 
    iprot.readStructBegin()
27526 
    while True:
27527 
      (fname, ftype, fid) = iprot.readFieldBegin()
27528 
      if ftype == TType.STOP:
27529 
        break
6031 rajveer 27530 
      if fid == 0:
27531 
        if ftype == TType.BOOL:
27532 
          self.success = iprot.readBool();
27533 
        else:
27534 
          iprot.skip(ftype)
27535 
      elif fid == 1:
6000 mandeep.dh 27536 
        if ftype == TType.STRUCT:
27537 
          self.ex = TransactionServiceException()
27538 
          self.ex.read(iprot)
27539 
        else:
27540 
          iprot.skip(ftype)
27541 
      else:
27542 
        iprot.skip(ftype)
27543 
      iprot.readFieldEnd()
27544 
    iprot.readStructEnd()
27545 
 
27546 
  def write(self, oprot):
27547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27549 
      return
27550 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27551 
    if self.success is not None:
27552 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27553 
      oprot.writeBool(self.success)
27554 
      oprot.writeFieldEnd()
6000 mandeep.dh 27555 
    if self.ex is not None:
27556 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27557 
      self.ex.write(oprot)
27558 
      oprot.writeFieldEnd()
27559 
    oprot.writeFieldStop()
27560 
    oprot.writeStructEnd()
27561 
 
27562 
  def validate(self):
27563 
    return
27564 
 
27565 
 
27566 
  def __repr__(self):
27567 
    L = ['%s=%r' % (key, value)
27568 
      for key, value in self.__dict__.iteritems()]
27569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27570 
 
27571 
  def __eq__(self, other):
27572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27573 
 
27574 
  def __ne__(self, other):
27575 
    return not (self == other)
27576 
 
27577 
class activateRechargeTxn_args:
27578 
  """
27579 
  Attributes:
6031 rajveer 27580 
   - rechargeOrderId
6000 mandeep.dh 27581 
  """
27582 
 
27583 
  thrift_spec = (
27584 
    None, # 0
6031 rajveer 27585 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27586 
  )
27587 
 
6031 rajveer 27588 
  def __init__(self, rechargeOrderId=None,):
27589 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27590 
 
27591 
  def read(self, iprot):
27592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27594 
      return
27595 
    iprot.readStructBegin()
27596 
    while True:
27597 
      (fname, ftype, fid) = iprot.readFieldBegin()
27598 
      if ftype == TType.STOP:
27599 
        break
27600 
      if fid == 1:
6031 rajveer 27601 
        if ftype == TType.I64:
27602 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27603 
        else:
27604 
          iprot.skip(ftype)
27605 
      else:
27606 
        iprot.skip(ftype)
27607 
      iprot.readFieldEnd()
27608 
    iprot.readStructEnd()
27609 
 
27610 
  def write(self, oprot):
27611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27613 
      return
27614 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27615 
    if self.rechargeOrderId is not None:
27616 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27617 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27618 
      oprot.writeFieldEnd()
27619 
    oprot.writeFieldStop()
27620 
    oprot.writeStructEnd()
27621 
 
27622 
  def validate(self):
27623 
    return
27624 
 
27625 
 
27626 
  def __repr__(self):
27627 
    L = ['%s=%r' % (key, value)
27628 
      for key, value in self.__dict__.iteritems()]
27629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27630 
 
27631 
  def __eq__(self, other):
27632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27633 
 
27634 
  def __ne__(self, other):
27635 
    return not (self == other)
27636 
 
27637 
class activateRechargeTxn_result:
27638 
  """
27639 
  Attributes:
27640 
   - success
27641 
   - ex
27642 
  """
27643 
 
27644 
  thrift_spec = (
6031 rajveer 27645 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27647 
  )
27648 
 
27649 
  def __init__(self, success=None, ex=None,):
27650 
    self.success = success
27651 
    self.ex = ex
27652 
 
27653 
  def read(self, iprot):
27654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27656 
      return
27657 
    iprot.readStructBegin()
27658 
    while True:
27659 
      (fname, ftype, fid) = iprot.readFieldBegin()
27660 
      if ftype == TType.STOP:
27661 
        break
27662 
      if fid == 0:
6031 rajveer 27663 
        if ftype == TType.BOOL:
27664 
          self.success = iprot.readBool();
6000 mandeep.dh 27665 
        else:
27666 
          iprot.skip(ftype)
27667 
      elif fid == 1:
27668 
        if ftype == TType.STRUCT:
27669 
          self.ex = TransactionServiceException()
27670 
          self.ex.read(iprot)
27671 
        else:
27672 
          iprot.skip(ftype)
27673 
      else:
27674 
        iprot.skip(ftype)
27675 
      iprot.readFieldEnd()
27676 
    iprot.readStructEnd()
27677 
 
27678 
  def write(self, oprot):
27679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27681 
      return
27682 
    oprot.writeStructBegin('activateRechargeTxn_result')
27683 
    if self.success is not None:
6031 rajveer 27684 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27685 
      oprot.writeBool(self.success)
6000 mandeep.dh 27686 
      oprot.writeFieldEnd()
27687 
    if self.ex is not None:
27688 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27689 
      self.ex.write(oprot)
27690 
      oprot.writeFieldEnd()
27691 
    oprot.writeFieldStop()
27692 
    oprot.writeStructEnd()
27693 
 
27694 
  def validate(self):
27695 
    return
27696 
 
27697 
 
27698 
  def __repr__(self):
27699 
    L = ['%s=%r' % (key, value)
27700 
      for key, value in self.__dict__.iteritems()]
27701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27702 
 
27703 
  def __eq__(self, other):
27704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27705 
 
27706 
  def __ne__(self, other):
27707 
    return not (self == other)
27708 
 
6031 rajveer 27709 
class getUserWallet_args:
6000 mandeep.dh 27710 
  """
27711 
  Attributes:
6031 rajveer 27712 
   - userId
6000 mandeep.dh 27713 
  """
27714 
 
27715 
  thrift_spec = (
27716 
    None, # 0
6031 rajveer 27717 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27718 
  )
27719 
 
6031 rajveer 27720 
  def __init__(self, userId=None,):
27721 
    self.userId = userId
6000 mandeep.dh 27722 
 
27723 
  def read(self, iprot):
27724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27726 
      return
27727 
    iprot.readStructBegin()
27728 
    while True:
27729 
      (fname, ftype, fid) = iprot.readFieldBegin()
27730 
      if ftype == TType.STOP:
27731 
        break
27732 
      if fid == 1:
27733 
        if ftype == TType.I64:
6031 rajveer 27734 
          self.userId = iprot.readI64();
6000 mandeep.dh 27735 
        else:
27736 
          iprot.skip(ftype)
27737 
      else:
27738 
        iprot.skip(ftype)
27739 
      iprot.readFieldEnd()
27740 
    iprot.readStructEnd()
27741 
 
27742 
  def write(self, oprot):
27743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27745 
      return
6031 rajveer 27746 
    oprot.writeStructBegin('getUserWallet_args')
27747 
    if self.userId is not None:
27748 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27749 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27750 
      oprot.writeFieldEnd()
27751 
    oprot.writeFieldStop()
27752 
    oprot.writeStructEnd()
27753 
 
27754 
  def validate(self):
27755 
    return
27756 
 
27757 
 
27758 
  def __repr__(self):
27759 
    L = ['%s=%r' % (key, value)
27760 
      for key, value in self.__dict__.iteritems()]
27761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27762 
 
27763 
  def __eq__(self, other):
27764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27765 
 
27766 
  def __ne__(self, other):
27767 
    return not (self == other)
27768 
 
6031 rajveer 27769 
class getUserWallet_result:
6000 mandeep.dh 27770 
  """
27771 
  Attributes:
27772 
   - success
27773 
  """
27774 
 
27775 
  thrift_spec = (
6031 rajveer 27776 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27777 
  )
27778 
 
27779 
  def __init__(self, success=None,):
27780 
    self.success = success
27781 
 
27782 
  def read(self, iprot):
27783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27785 
      return
27786 
    iprot.readStructBegin()
27787 
    while True:
27788 
      (fname, ftype, fid) = iprot.readFieldBegin()
27789 
      if ftype == TType.STOP:
27790 
        break
27791 
      if fid == 0:
6031 rajveer 27792 
        if ftype == TType.STRUCT:
27793 
          self.success = UserWallet()
27794 
          self.success.read(iprot)
6000 mandeep.dh 27795 
        else:
27796 
          iprot.skip(ftype)
27797 
      else:
27798 
        iprot.skip(ftype)
27799 
      iprot.readFieldEnd()
27800 
    iprot.readStructEnd()
27801 
 
27802 
  def write(self, oprot):
27803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27805 
      return
6031 rajveer 27806 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27807 
    if self.success is not None:
6031 rajveer 27808 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27809 
      self.success.write(oprot)
6000 mandeep.dh 27810 
      oprot.writeFieldEnd()
27811 
    oprot.writeFieldStop()
27812 
    oprot.writeStructEnd()
27813 
 
27814 
  def validate(self):
27815 
    return
27816 
 
27817 
 
27818 
  def __repr__(self):
27819 
    L = ['%s=%r' % (key, value)
27820 
      for key, value in self.__dict__.iteritems()]
27821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27822 
 
27823 
  def __eq__(self, other):
27824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27825 
 
27826 
  def __ne__(self, other):
27827 
    return not (self == other)
27828 
 
6031 rajveer 27829 
class getUserWalletHistory_args:
6000 mandeep.dh 27830 
  """
27831 
  Attributes:
6031 rajveer 27832 
   - userId
6000 mandeep.dh 27833 
  """
27834 
 
27835 
  thrift_spec = (
27836 
    None, # 0
6031 rajveer 27837 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27838 
  )
27839 
 
6031 rajveer 27840 
  def __init__(self, userId=None,):
27841 
    self.userId = userId
6000 mandeep.dh 27842 
 
27843 
  def read(self, iprot):
27844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27846 
      return
27847 
    iprot.readStructBegin()
27848 
    while True:
27849 
      (fname, ftype, fid) = iprot.readFieldBegin()
27850 
      if ftype == TType.STOP:
27851 
        break
27852 
      if fid == 1:
27853 
        if ftype == TType.I64:
6031 rajveer 27854 
          self.userId = iprot.readI64();
6000 mandeep.dh 27855 
        else:
27856 
          iprot.skip(ftype)
27857 
      else:
27858 
        iprot.skip(ftype)
27859 
      iprot.readFieldEnd()
27860 
    iprot.readStructEnd()
27861 
 
27862 
  def write(self, oprot):
27863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27865 
      return
6031 rajveer 27866 
    oprot.writeStructBegin('getUserWalletHistory_args')
27867 
    if self.userId is not None:
27868 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27869 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27870 
      oprot.writeFieldEnd()
27871 
    oprot.writeFieldStop()
27872 
    oprot.writeStructEnd()
27873 
 
27874 
  def validate(self):
27875 
    return
27876 
 
27877 
 
27878 
  def __repr__(self):
27879 
    L = ['%s=%r' % (key, value)
27880 
      for key, value in self.__dict__.iteritems()]
27881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27882 
 
27883 
  def __eq__(self, other):
27884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27885 
 
27886 
  def __ne__(self, other):
27887 
    return not (self == other)
27888 
 
6031 rajveer 27889 
class getUserWalletHistory_result:
6000 mandeep.dh 27890 
  """
27891 
  Attributes:
27892 
   - success
27893 
  """
27894 
 
27895 
  thrift_spec = (
6031 rajveer 27896 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27897 
  )
27898 
 
27899 
  def __init__(self, success=None,):
27900 
    self.success = success
27901 
 
27902 
  def read(self, iprot):
27903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27905 
      return
27906 
    iprot.readStructBegin()
27907 
    while True:
27908 
      (fname, ftype, fid) = iprot.readFieldBegin()
27909 
      if ftype == TType.STOP:
27910 
        break
27911 
      if fid == 0:
27912 
        if ftype == TType.LIST:
27913 
          self.success = []
6188 rajveer 27914 
          (_etype666, _size663) = iprot.readListBegin()
27915 
          for _i667 in xrange(_size663):
27916 
            _elem668 = UserWalletHistory()
27917 
            _elem668.read(iprot)
27918 
            self.success.append(_elem668)
6000 mandeep.dh 27919 
          iprot.readListEnd()
27920 
        else:
27921 
          iprot.skip(ftype)
27922 
      else:
27923 
        iprot.skip(ftype)
27924 
      iprot.readFieldEnd()
27925 
    iprot.readStructEnd()
27926 
 
27927 
  def write(self, oprot):
27928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27930 
      return
6031 rajveer 27931 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27932 
    if self.success is not None:
27933 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27934 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27935 
      for iter669 in self.success:
27936 
        iter669.write(oprot)
6000 mandeep.dh 27937 
      oprot.writeListEnd()
27938 
      oprot.writeFieldEnd()
27939 
    oprot.writeFieldStop()
27940 
    oprot.writeStructEnd()
27941 
 
27942 
  def validate(self):
27943 
    return
27944 
 
27945 
 
27946 
  def __repr__(self):
27947 
    L = ['%s=%r' % (key, value)
27948 
      for key, value in self.__dict__.iteritems()]
27949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27950 
 
27951 
  def __eq__(self, other):
27952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27953 
 
27954 
  def __ne__(self, other):
27955 
    return not (self == other)
6048 rajveer 27956 
 
6050 anupam.sin 27957 
class getRechargeOrdersForTransaction_args:
27958 
  """
27959 
  Attributes:
27960 
   - txnId
27961 
  """
27962 
 
27963 
  thrift_spec = (
27964 
    None, # 0
27965 
    (1, TType.I64, 'txnId', None, None, ), # 1
27966 
  )
27967 
 
27968 
  def __init__(self, txnId=None,):
27969 
    self.txnId = txnId
27970 
 
27971 
  def read(self, iprot):
27972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27974 
      return
27975 
    iprot.readStructBegin()
27976 
    while True:
27977 
      (fname, ftype, fid) = iprot.readFieldBegin()
27978 
      if ftype == TType.STOP:
27979 
        break
27980 
      if fid == 1:
27981 
        if ftype == TType.I64:
27982 
          self.txnId = iprot.readI64();
27983 
        else:
27984 
          iprot.skip(ftype)
27985 
      else:
27986 
        iprot.skip(ftype)
27987 
      iprot.readFieldEnd()
27988 
    iprot.readStructEnd()
27989 
 
27990 
  def write(self, oprot):
27991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27993 
      return
27994 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27995 
    if self.txnId is not None:
27996 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27997 
      oprot.writeI64(self.txnId)
27998 
      oprot.writeFieldEnd()
27999 
    oprot.writeFieldStop()
28000 
    oprot.writeStructEnd()
28001 
 
28002 
  def validate(self):
28003 
    return
28004 
 
28005 
 
28006 
  def __repr__(self):
28007 
    L = ['%s=%r' % (key, value)
28008 
      for key, value in self.__dict__.iteritems()]
28009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28010 
 
28011 
  def __eq__(self, other):
28012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28013 
 
28014 
  def __ne__(self, other):
28015 
    return not (self == other)
28016 
 
28017 
class getRechargeOrdersForTransaction_result:
28018 
  """
28019 
  Attributes:
28020 
   - success
28021 
   - ex
28022 
  """
28023 
 
28024 
  thrift_spec = (
28025 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28026 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28027 
  )
28028 
 
28029 
  def __init__(self, success=None, ex=None,):
28030 
    self.success = success
28031 
    self.ex = ex
28032 
 
28033 
  def read(self, iprot):
28034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28036 
      return
28037 
    iprot.readStructBegin()
28038 
    while True:
28039 
      (fname, ftype, fid) = iprot.readFieldBegin()
28040 
      if ftype == TType.STOP:
28041 
        break
28042 
      if fid == 0:
28043 
        if ftype == TType.STRUCT:
28044 
          self.success = RechargeOrder()
28045 
          self.success.read(iprot)
28046 
        else:
28047 
          iprot.skip(ftype)
28048 
      elif fid == 1:
28049 
        if ftype == TType.STRUCT:
28050 
          self.ex = TransactionServiceException()
28051 
          self.ex.read(iprot)
28052 
        else:
28053 
          iprot.skip(ftype)
28054 
      else:
28055 
        iprot.skip(ftype)
28056 
      iprot.readFieldEnd()
28057 
    iprot.readStructEnd()
28058 
 
28059 
  def write(self, oprot):
28060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28062 
      return
28063 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28064 
    if self.success is not None:
28065 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28066 
      self.success.write(oprot)
28067 
      oprot.writeFieldEnd()
28068 
    if self.ex is not None:
28069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28070 
      self.ex.write(oprot)
28071 
      oprot.writeFieldEnd()
28072 
    oprot.writeFieldStop()
28073 
    oprot.writeStructEnd()
28074 
 
28075 
  def validate(self):
28076 
    return
28077 
 
28078 
 
28079 
  def __repr__(self):
28080 
    L = ['%s=%r' % (key, value)
28081 
      for key, value in self.__dict__.iteritems()]
28082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28083 
 
28084 
  def __eq__(self, other):
28085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28086 
 
28087 
  def __ne__(self, other):
28088 
    return not (self == other)
28089 
 
6048 rajveer 28090 
class getServiceProviders_args:
28091 
  """
28092 
  Attributes:
28093 
   - rechargeType
6206 rajveer 28094 
   - onlyActive
6048 rajveer 28095 
  """
28096 
 
28097 
  thrift_spec = (
28098 
    None, # 0
28099 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28100 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28101 
  )
28102 
 
6206 rajveer 28103 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28104 
    self.rechargeType = rechargeType
6206 rajveer 28105 
    self.onlyActive = onlyActive
6048 rajveer 28106 
 
28107 
  def read(self, iprot):
28108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28110 
      return
28111 
    iprot.readStructBegin()
28112 
    while True:
28113 
      (fname, ftype, fid) = iprot.readFieldBegin()
28114 
      if ftype == TType.STOP:
28115 
        break
28116 
      if fid == 1:
28117 
        if ftype == TType.I32:
28118 
          self.rechargeType = iprot.readI32();
28119 
        else:
28120 
          iprot.skip(ftype)
6206 rajveer 28121 
      elif fid == 2:
28122 
        if ftype == TType.BOOL:
28123 
          self.onlyActive = iprot.readBool();
28124 
        else:
28125 
          iprot.skip(ftype)
6048 rajveer 28126 
      else:
28127 
        iprot.skip(ftype)
28128 
      iprot.readFieldEnd()
28129 
    iprot.readStructEnd()
28130 
 
28131 
  def write(self, oprot):
28132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28134 
      return
28135 
    oprot.writeStructBegin('getServiceProviders_args')
28136 
    if self.rechargeType is not None:
28137 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28138 
      oprot.writeI32(self.rechargeType)
28139 
      oprot.writeFieldEnd()
6206 rajveer 28140 
    if self.onlyActive is not None:
28141 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28142 
      oprot.writeBool(self.onlyActive)
28143 
      oprot.writeFieldEnd()
6048 rajveer 28144 
    oprot.writeFieldStop()
28145 
    oprot.writeStructEnd()
28146 
 
28147 
  def validate(self):
28148 
    return
28149 
 
28150 
 
28151 
  def __repr__(self):
28152 
    L = ['%s=%r' % (key, value)
28153 
      for key, value in self.__dict__.iteritems()]
28154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28155 
 
28156 
  def __eq__(self, other):
28157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28158 
 
28159 
  def __ne__(self, other):
28160 
    return not (self == other)
28161 
 
28162 
class getServiceProviders_result:
28163 
  """
28164 
  Attributes:
28165 
   - success
28166 
  """
28167 
 
28168 
  thrift_spec = (
28169 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28170 
  )
28171 
 
28172 
  def __init__(self, success=None,):
28173 
    self.success = success
28174 
 
28175 
  def read(self, iprot):
28176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28178 
      return
28179 
    iprot.readStructBegin()
28180 
    while True:
28181 
      (fname, ftype, fid) = iprot.readFieldBegin()
28182 
      if ftype == TType.STOP:
28183 
        break
28184 
      if fid == 0:
28185 
        if ftype == TType.MAP:
28186 
          self.success = {}
6188 rajveer 28187 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28188 
          for _i674 in xrange(_size670):
28189 
            _key675 = iprot.readI64();
28190 
            _val676 = iprot.readString();
28191 
            self.success[_key675] = _val676
6048 rajveer 28192 
          iprot.readMapEnd()
28193 
        else:
28194 
          iprot.skip(ftype)
28195 
      else:
28196 
        iprot.skip(ftype)
28197 
      iprot.readFieldEnd()
28198 
    iprot.readStructEnd()
28199 
 
28200 
  def write(self, oprot):
28201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28203 
      return
28204 
    oprot.writeStructBegin('getServiceProviders_result')
28205 
    if self.success is not None:
28206 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28207 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28208 
      for kiter677,viter678 in self.success.items():
28209 
        oprot.writeI64(kiter677)
28210 
        oprot.writeString(viter678)
6048 rajveer 28211 
      oprot.writeMapEnd()
28212 
      oprot.writeFieldEnd()
28213 
    oprot.writeFieldStop()
28214 
    oprot.writeStructEnd()
28215 
 
28216 
  def validate(self):
28217 
    return
28218 
 
28219 
 
28220 
  def __repr__(self):
28221 
    L = ['%s=%r' % (key, value)
28222 
      for key, value in self.__dict__.iteritems()]
28223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28224 
 
28225 
  def __eq__(self, other):
28226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28227 
 
28228 
  def __ne__(self, other):
28229 
    return not (self == other)
28230 
 
28231 
class getServiceProviderForDevice_args:
28232 
  """
28233 
  Attributes:
6049 rajveer 28234 
   - rechargeType
6048 rajveer 28235 
   - deviceNumber
28236 
  """
28237 
 
28238 
  thrift_spec = (
28239 
    None, # 0
6049 rajveer 28240 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28241 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28242 
  )
28243 
 
6049 rajveer 28244 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28245 
    self.rechargeType = rechargeType
6048 rajveer 28246 
    self.deviceNumber = deviceNumber
28247 
 
28248 
  def read(self, iprot):
28249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28251 
      return
28252 
    iprot.readStructBegin()
28253 
    while True:
28254 
      (fname, ftype, fid) = iprot.readFieldBegin()
28255 
      if ftype == TType.STOP:
28256 
        break
28257 
      if fid == 1:
6049 rajveer 28258 
        if ftype == TType.I32:
28259 
          self.rechargeType = iprot.readI32();
28260 
        else:
28261 
          iprot.skip(ftype)
28262 
      elif fid == 2:
6048 rajveer 28263 
        if ftype == TType.STRING:
28264 
          self.deviceNumber = iprot.readString();
28265 
        else:
28266 
          iprot.skip(ftype)
28267 
      else:
28268 
        iprot.skip(ftype)
28269 
      iprot.readFieldEnd()
28270 
    iprot.readStructEnd()
28271 
 
28272 
  def write(self, oprot):
28273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28275 
      return
28276 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28277 
    if self.rechargeType is not None:
28278 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28279 
      oprot.writeI32(self.rechargeType)
28280 
      oprot.writeFieldEnd()
6048 rajveer 28281 
    if self.deviceNumber is not None:
6049 rajveer 28282 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28283 
      oprot.writeString(self.deviceNumber)
28284 
      oprot.writeFieldEnd()
28285 
    oprot.writeFieldStop()
28286 
    oprot.writeStructEnd()
28287 
 
28288 
  def validate(self):
28289 
    return
28290 
 
28291 
 
28292 
  def __repr__(self):
28293 
    L = ['%s=%r' % (key, value)
28294 
      for key, value in self.__dict__.iteritems()]
28295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28296 
 
28297 
  def __eq__(self, other):
28298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28299 
 
28300 
  def __ne__(self, other):
28301 
    return not (self == other)
28302 
 
28303 
class getServiceProviderForDevice_result:
28304 
  """
28305 
  Attributes:
28306 
   - success
28307 
  """
28308 
 
28309 
  thrift_spec = (
6289 anupam.sin 28310 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28311 
  )
28312 
 
28313 
  def __init__(self, success=None,):
28314 
    self.success = success
28315 
 
28316 
  def read(self, iprot):
28317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28319 
      return
28320 
    iprot.readStructBegin()
28321 
    while True:
28322 
      (fname, ftype, fid) = iprot.readFieldBegin()
28323 
      if ftype == TType.STOP:
28324 
        break
28325 
      if fid == 0:
6289 anupam.sin 28326 
        if ftype == TType.STRUCT:
28327 
          self.success = DeviceNumberInfo()
28328 
          self.success.read(iprot)
6048 rajveer 28329 
        else:
28330 
          iprot.skip(ftype)
28331 
      else:
28332 
        iprot.skip(ftype)
28333 
      iprot.readFieldEnd()
28334 
    iprot.readStructEnd()
28335 
 
28336 
  def write(self, oprot):
28337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28339 
      return
28340 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28341 
    if self.success is not None:
6289 anupam.sin 28342 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28343 
      self.success.write(oprot)
6048 rajveer 28344 
      oprot.writeFieldEnd()
28345 
    oprot.writeFieldStop()
28346 
    oprot.writeStructEnd()
28347 
 
28348 
  def validate(self):
28349 
    return
28350 
 
28351 
 
28352 
  def __repr__(self):
28353 
    L = ['%s=%r' % (key, value)
28354 
      for key, value in self.__dict__.iteritems()]
28355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28356 
 
28357 
  def __eq__(self, other):
28358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28359 
 
28360 
  def __ne__(self, other):
28361 
    return not (self == other)
6094 rajveer 28362 
 
6269 rajveer 28363 
class validateRecharge_args:
28364 
  """
28365 
  Attributes:
28366 
   - rechargeType
28367 
   - deviceNumber
6307 anupam.sin 28368 
   - userSelectedProviderId
6591 anupam.sin 28369 
   - clientAddress
6269 rajveer 28370 
  """
28371 
 
28372 
  thrift_spec = (
28373 
    None, # 0
28374 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28375 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28376 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28377 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28378 
  )
28379 
 
6591 anupam.sin 28380 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28381 
    self.rechargeType = rechargeType
28382 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28383 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28384 
    self.clientAddress = clientAddress
6269 rajveer 28385 
 
28386 
  def read(self, iprot):
28387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28389 
      return
28390 
    iprot.readStructBegin()
28391 
    while True:
28392 
      (fname, ftype, fid) = iprot.readFieldBegin()
28393 
      if ftype == TType.STOP:
28394 
        break
28395 
      if fid == 1:
28396 
        if ftype == TType.I32:
28397 
          self.rechargeType = iprot.readI32();
28398 
        else:
28399 
          iprot.skip(ftype)
28400 
      elif fid == 2:
28401 
        if ftype == TType.STRING:
28402 
          self.deviceNumber = iprot.readString();
28403 
        else:
28404 
          iprot.skip(ftype)
6307 anupam.sin 28405 
      elif fid == 3:
28406 
        if ftype == TType.I64:
28407 
          self.userSelectedProviderId = iprot.readI64();
28408 
        else:
28409 
          iprot.skip(ftype)
6591 anupam.sin 28410 
      elif fid == 4:
28411 
        if ftype == TType.STRING:
28412 
          self.clientAddress = iprot.readString();
28413 
        else:
28414 
          iprot.skip(ftype)
6269 rajveer 28415 
      else:
28416 
        iprot.skip(ftype)
28417 
      iprot.readFieldEnd()
28418 
    iprot.readStructEnd()
28419 
 
28420 
  def write(self, oprot):
28421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28423 
      return
28424 
    oprot.writeStructBegin('validateRecharge_args')
28425 
    if self.rechargeType is not None:
28426 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28427 
      oprot.writeI32(self.rechargeType)
28428 
      oprot.writeFieldEnd()
28429 
    if self.deviceNumber is not None:
28430 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28431 
      oprot.writeString(self.deviceNumber)
28432 
      oprot.writeFieldEnd()
6307 anupam.sin 28433 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28434 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28435 
      oprot.writeI64(self.userSelectedProviderId)
28436 
      oprot.writeFieldEnd()
6591 anupam.sin 28437 
    if self.clientAddress is not None:
28438 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28439 
      oprot.writeString(self.clientAddress)
28440 
      oprot.writeFieldEnd()
6269 rajveer 28441 
    oprot.writeFieldStop()
28442 
    oprot.writeStructEnd()
28443 
 
28444 
  def validate(self):
28445 
    return
28446 
 
28447 
 
28448 
  def __repr__(self):
28449 
    L = ['%s=%r' % (key, value)
28450 
      for key, value in self.__dict__.iteritems()]
28451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28452 
 
28453 
  def __eq__(self, other):
28454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28455 
 
28456 
  def __ne__(self, other):
28457 
    return not (self == other)
28458 
 
28459 
class validateRecharge_result:
28460 
  """
28461 
  Attributes:
28462 
   - success
28463 
  """
28464 
 
28465 
  thrift_spec = (
28466 
    (0, TType.STRING, 'success', None, None, ), # 0
28467 
  )
28468 
 
28469 
  def __init__(self, success=None,):
28470 
    self.success = success
28471 
 
28472 
  def read(self, iprot):
28473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28475 
      return
28476 
    iprot.readStructBegin()
28477 
    while True:
28478 
      (fname, ftype, fid) = iprot.readFieldBegin()
28479 
      if ftype == TType.STOP:
28480 
        break
28481 
      if fid == 0:
28482 
        if ftype == TType.STRING:
28483 
          self.success = iprot.readString();
28484 
        else:
28485 
          iprot.skip(ftype)
28486 
      else:
28487 
        iprot.skip(ftype)
28488 
      iprot.readFieldEnd()
28489 
    iprot.readStructEnd()
28490 
 
28491 
  def write(self, oprot):
28492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28494 
      return
28495 
    oprot.writeStructBegin('validateRecharge_result')
28496 
    if self.success is not None:
28497 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28498 
      oprot.writeString(self.success)
28499 
      oprot.writeFieldEnd()
28500 
    oprot.writeFieldStop()
28501 
    oprot.writeStructEnd()
28502 
 
28503 
  def validate(self):
28504 
    return
28505 
 
28506 
 
28507 
  def __repr__(self):
28508 
    L = ['%s=%r' % (key, value)
28509 
      for key, value in self.__dict__.iteritems()]
28510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28511 
 
28512 
  def __eq__(self, other):
28513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28514 
 
28515 
  def __ne__(self, other):
28516 
    return not (self == other)
28517 
 
6094 rajveer 28518 
class getRechargeOrdersForDevice_args:
28519 
  """
28520 
  Attributes:
28521 
   - deviceNumber
28522 
  """
28523 
 
28524 
  thrift_spec = (
28525 
    None, # 0
28526 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28527 
  )
28528 
 
28529 
  def __init__(self, deviceNumber=None,):
28530 
    self.deviceNumber = deviceNumber
28531 
 
28532 
  def read(self, iprot):
28533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28535 
      return
28536 
    iprot.readStructBegin()
28537 
    while True:
28538 
      (fname, ftype, fid) = iprot.readFieldBegin()
28539 
      if ftype == TType.STOP:
28540 
        break
28541 
      if fid == 1:
28542 
        if ftype == TType.STRING:
28543 
          self.deviceNumber = iprot.readString();
28544 
        else:
28545 
          iprot.skip(ftype)
28546 
      else:
28547 
        iprot.skip(ftype)
28548 
      iprot.readFieldEnd()
28549 
    iprot.readStructEnd()
28550 
 
28551 
  def write(self, oprot):
28552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28554 
      return
28555 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28556 
    if self.deviceNumber is not None:
28557 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28558 
      oprot.writeString(self.deviceNumber)
28559 
      oprot.writeFieldEnd()
28560 
    oprot.writeFieldStop()
28561 
    oprot.writeStructEnd()
28562 
 
28563 
  def validate(self):
28564 
    return
28565 
 
28566 
 
28567 
  def __repr__(self):
28568 
    L = ['%s=%r' % (key, value)
28569 
      for key, value in self.__dict__.iteritems()]
28570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28571 
 
28572 
  def __eq__(self, other):
28573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28574 
 
28575 
  def __ne__(self, other):
28576 
    return not (self == other)
28577 
 
28578 
class getRechargeOrdersForDevice_result:
28579 
  """
28580 
  Attributes:
28581 
   - success
28582 
  """
28583 
 
28584 
  thrift_spec = (
28585 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28586 
  )
28587 
 
28588 
  def __init__(self, success=None,):
28589 
    self.success = success
28590 
 
28591 
  def read(self, iprot):
28592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28594 
      return
28595 
    iprot.readStructBegin()
28596 
    while True:
28597 
      (fname, ftype, fid) = iprot.readFieldBegin()
28598 
      if ftype == TType.STOP:
28599 
        break
28600 
      if fid == 0:
28601 
        if ftype == TType.LIST:
28602 
          self.success = []
6188 rajveer 28603 
          (_etype682, _size679) = iprot.readListBegin()
28604 
          for _i683 in xrange(_size679):
28605 
            _elem684 = RechargeOrder()
28606 
            _elem684.read(iprot)
28607 
            self.success.append(_elem684)
6094 rajveer 28608 
          iprot.readListEnd()
28609 
        else:
28610 
          iprot.skip(ftype)
28611 
      else:
28612 
        iprot.skip(ftype)
28613 
      iprot.readFieldEnd()
28614 
    iprot.readStructEnd()
28615 
 
28616 
  def write(self, oprot):
28617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28619 
      return
28620 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28621 
    if self.success is not None:
28622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28624 
      for iter685 in self.success:
28625 
        iter685.write(oprot)
6094 rajveer 28626 
      oprot.writeListEnd()
28627 
      oprot.writeFieldEnd()
28628 
    oprot.writeFieldStop()
28629 
    oprot.writeStructEnd()
28630 
 
28631 
  def validate(self):
28632 
    return
28633 
 
28634 
 
28635 
  def __repr__(self):
28636 
    L = ['%s=%r' % (key, value)
28637 
      for key, value in self.__dict__.iteritems()]
28638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28639 
 
28640 
  def __eq__(self, other):
28641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28642 
 
28643 
  def __ne__(self, other):
28644 
    return not (self == other)
28645 
 
28646 
class addAmountToWallet_args:
28647 
  """
28648 
  Attributes:
28649 
   - userId
28650 
   - orderId
28651 
   - amount
28652 
  """
28653 
 
28654 
  thrift_spec = (
28655 
    None, # 0
28656 
    (1, TType.I64, 'userId', None, None, ), # 1
28657 
    (2, TType.I64, 'orderId', None, None, ), # 2
28658 
    (3, TType.I64, 'amount', None, None, ), # 3
28659 
  )
28660 
 
28661 
  def __init__(self, userId=None, orderId=None, amount=None,):
28662 
    self.userId = userId
28663 
    self.orderId = orderId
28664 
    self.amount = amount
28665 
 
28666 
  def read(self, iprot):
28667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28669 
      return
28670 
    iprot.readStructBegin()
28671 
    while True:
28672 
      (fname, ftype, fid) = iprot.readFieldBegin()
28673 
      if ftype == TType.STOP:
28674 
        break
28675 
      if fid == 1:
28676 
        if ftype == TType.I64:
28677 
          self.userId = iprot.readI64();
28678 
        else:
28679 
          iprot.skip(ftype)
28680 
      elif fid == 2:
28681 
        if ftype == TType.I64:
28682 
          self.orderId = iprot.readI64();
28683 
        else:
28684 
          iprot.skip(ftype)
28685 
      elif fid == 3:
28686 
        if ftype == TType.I64:
28687 
          self.amount = iprot.readI64();
28688 
        else:
28689 
          iprot.skip(ftype)
28690 
      else:
28691 
        iprot.skip(ftype)
28692 
      iprot.readFieldEnd()
28693 
    iprot.readStructEnd()
28694 
 
28695 
  def write(self, oprot):
28696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28698 
      return
28699 
    oprot.writeStructBegin('addAmountToWallet_args')
28700 
    if self.userId is not None:
28701 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28702 
      oprot.writeI64(self.userId)
28703 
      oprot.writeFieldEnd()
28704 
    if self.orderId is not None:
28705 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28706 
      oprot.writeI64(self.orderId)
28707 
      oprot.writeFieldEnd()
28708 
    if self.amount is not None:
28709 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28710 
      oprot.writeI64(self.amount)
28711 
      oprot.writeFieldEnd()
28712 
    oprot.writeFieldStop()
28713 
    oprot.writeStructEnd()
28714 
 
28715 
  def validate(self):
28716 
    return
28717 
 
28718 
 
28719 
  def __repr__(self):
28720 
    L = ['%s=%r' % (key, value)
28721 
      for key, value in self.__dict__.iteritems()]
28722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28723 
 
28724 
  def __eq__(self, other):
28725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28726 
 
28727 
  def __ne__(self, other):
28728 
    return not (self == other)
28729 
 
28730 
class addAmountToWallet_result:
28731 
 
28732 
  thrift_spec = (
28733 
  )
28734 
 
28735 
  def read(self, iprot):
28736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28738 
      return
28739 
    iprot.readStructBegin()
28740 
    while True:
28741 
      (fname, ftype, fid) = iprot.readFieldBegin()
28742 
      if ftype == TType.STOP:
28743 
        break
28744 
      else:
28745 
        iprot.skip(ftype)
28746 
      iprot.readFieldEnd()
28747 
    iprot.readStructEnd()
28748 
 
28749 
  def write(self, oprot):
28750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28752 
      return
28753 
    oprot.writeStructBegin('addAmountToWallet_result')
28754 
    oprot.writeFieldStop()
28755 
    oprot.writeStructEnd()
28756 
 
28757 
  def validate(self):
28758 
    return
28759 
 
28760 
 
28761 
  def __repr__(self):
28762 
    L = ['%s=%r' % (key, value)
28763 
      for key, value in self.__dict__.iteritems()]
28764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28765 
 
28766 
  def __eq__(self, other):
28767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28768 
 
28769 
  def __ne__(self, other):
28770 
    return not (self == other)
6154 rajveer 28771 
 
6188 rajveer 28772 
class getRechargeStatistics_args:
28773 
 
28774 
  thrift_spec = (
28775 
  )
28776 
 
28777 
  def read(self, iprot):
28778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28780 
      return
28781 
    iprot.readStructBegin()
28782 
    while True:
28783 
      (fname, ftype, fid) = iprot.readFieldBegin()
28784 
      if ftype == TType.STOP:
28785 
        break
28786 
      else:
28787 
        iprot.skip(ftype)
28788 
      iprot.readFieldEnd()
28789 
    iprot.readStructEnd()
28790 
 
28791 
  def write(self, oprot):
28792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28794 
      return
28795 
    oprot.writeStructBegin('getRechargeStatistics_args')
28796 
    oprot.writeFieldStop()
28797 
    oprot.writeStructEnd()
28798 
 
28799 
  def validate(self):
28800 
    return
28801 
 
28802 
 
28803 
  def __repr__(self):
28804 
    L = ['%s=%r' % (key, value)
28805 
      for key, value in self.__dict__.iteritems()]
28806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28807 
 
28808 
  def __eq__(self, other):
28809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28810 
 
28811 
  def __ne__(self, other):
28812 
    return not (self == other)
28813 
 
28814 
class getRechargeStatistics_result:
28815 
  """
28816 
  Attributes:
28817 
   - success
28818 
  """
28819 
 
28820 
  thrift_spec = (
28821 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28822 
  )
28823 
 
28824 
  def __init__(self, success=None,):
28825 
    self.success = success
28826 
 
28827 
  def read(self, iprot):
28828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28830 
      return
28831 
    iprot.readStructBegin()
28832 
    while True:
28833 
      (fname, ftype, fid) = iprot.readFieldBegin()
28834 
      if ftype == TType.STOP:
28835 
        break
28836 
      if fid == 0:
28837 
        if ftype == TType.STRUCT:
28838 
          self.success = RechargeStatistics()
28839 
          self.success.read(iprot)
28840 
        else:
28841 
          iprot.skip(ftype)
28842 
      else:
28843 
        iprot.skip(ftype)
28844 
      iprot.readFieldEnd()
28845 
    iprot.readStructEnd()
28846 
 
28847 
  def write(self, oprot):
28848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28850 
      return
28851 
    oprot.writeStructBegin('getRechargeStatistics_result')
28852 
    if self.success is not None:
28853 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28854 
      self.success.write(oprot)
28855 
      oprot.writeFieldEnd()
28856 
    oprot.writeFieldStop()
28857 
    oprot.writeStructEnd()
28858 
 
28859 
  def validate(self):
28860 
    return
28861 
 
28862 
 
28863 
  def __repr__(self):
28864 
    L = ['%s=%r' % (key, value)
28865 
      for key, value in self.__dict__.iteritems()]
28866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28867 
 
28868 
  def __eq__(self, other):
28869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28870 
 
28871 
  def __ne__(self, other):
28872 
    return not (self == other)
28873 
 
6154 rajveer 28874 
class getRechargeOrdersForStatus_args:
28875 
  """
28876 
  Attributes:
28877 
   - status
28878 
  """
28879 
 
28880 
  thrift_spec = (
28881 
    None, # 0
28882 
    (1, TType.I64, 'status', None, None, ), # 1
28883 
  )
28884 
 
28885 
  def __init__(self, status=None,):
28886 
    self.status = status
28887 
 
28888 
  def read(self, iprot):
28889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28891 
      return
28892 
    iprot.readStructBegin()
28893 
    while True:
28894 
      (fname, ftype, fid) = iprot.readFieldBegin()
28895 
      if ftype == TType.STOP:
28896 
        break
28897 
      if fid == 1:
28898 
        if ftype == TType.I64:
28899 
          self.status = iprot.readI64();
28900 
        else:
28901 
          iprot.skip(ftype)
28902 
      else:
28903 
        iprot.skip(ftype)
28904 
      iprot.readFieldEnd()
28905 
    iprot.readStructEnd()
28906 
 
28907 
  def write(self, oprot):
28908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28910 
      return
28911 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28912 
    if self.status is not None:
28913 
      oprot.writeFieldBegin('status', TType.I64, 1)
28914 
      oprot.writeI64(self.status)
28915 
      oprot.writeFieldEnd()
28916 
    oprot.writeFieldStop()
28917 
    oprot.writeStructEnd()
28918 
 
28919 
  def validate(self):
28920 
    return
28921 
 
28922 
 
28923 
  def __repr__(self):
28924 
    L = ['%s=%r' % (key, value)
28925 
      for key, value in self.__dict__.iteritems()]
28926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28927 
 
28928 
  def __eq__(self, other):
28929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28930 
 
28931 
  def __ne__(self, other):
28932 
    return not (self == other)
28933 
 
28934 
class getRechargeOrdersForStatus_result:
28935 
  """
28936 
  Attributes:
28937 
   - success
28938 
  """
28939 
 
28940 
  thrift_spec = (
28941 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28942 
  )
28943 
 
28944 
  def __init__(self, success=None,):
28945 
    self.success = success
28946 
 
28947 
  def read(self, iprot):
28948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28950 
      return
28951 
    iprot.readStructBegin()
28952 
    while True:
28953 
      (fname, ftype, fid) = iprot.readFieldBegin()
28954 
      if ftype == TType.STOP:
28955 
        break
28956 
      if fid == 0:
28957 
        if ftype == TType.LIST:
28958 
          self.success = []
6188 rajveer 28959 
          (_etype689, _size686) = iprot.readListBegin()
28960 
          for _i690 in xrange(_size686):
28961 
            _elem691 = RechargeOrder()
28962 
            _elem691.read(iprot)
28963 
            self.success.append(_elem691)
6154 rajveer 28964 
          iprot.readListEnd()
28965 
        else:
28966 
          iprot.skip(ftype)
28967 
      else:
28968 
        iprot.skip(ftype)
28969 
      iprot.readFieldEnd()
28970 
    iprot.readStructEnd()
28971 
 
28972 
  def write(self, oprot):
28973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28975 
      return
28976 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28977 
    if self.success is not None:
28978 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28979 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28980 
      for iter692 in self.success:
28981 
        iter692.write(oprot)
6154 rajveer 28982 
      oprot.writeListEnd()
28983 
      oprot.writeFieldEnd()
28984 
    oprot.writeFieldStop()
28985 
    oprot.writeStructEnd()
28986 
 
28987 
  def validate(self):
28988 
    return
28989 
 
28990 
 
28991 
  def __repr__(self):
28992 
    L = ['%s=%r' % (key, value)
28993 
      for key, value in self.__dict__.iteritems()]
28994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28995 
 
28996 
  def __eq__(self, other):
28997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28998 
 
28999 
  def __ne__(self, other):
29000 
    return not (self == other)
6159 rajveer 29001 
 
29002 
class getPlansForOperator_args:
29003 
  """
29004 
  Attributes:
29005 
   - operatorId
29006 
  """
29007 
 
29008 
  thrift_spec = (
29009 
    None, # 0
29010 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29011 
  )
29012 
 
29013 
  def __init__(self, operatorId=None,):
29014 
    self.operatorId = operatorId
29015 
 
29016 
  def read(self, iprot):
29017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29019 
      return
29020 
    iprot.readStructBegin()
29021 
    while True:
29022 
      (fname, ftype, fid) = iprot.readFieldBegin()
29023 
      if ftype == TType.STOP:
29024 
        break
29025 
      if fid == 1:
29026 
        if ftype == TType.I64:
29027 
          self.operatorId = iprot.readI64();
29028 
        else:
29029 
          iprot.skip(ftype)
29030 
      else:
29031 
        iprot.skip(ftype)
29032 
      iprot.readFieldEnd()
29033 
    iprot.readStructEnd()
29034 
 
29035 
  def write(self, oprot):
29036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29038 
      return
29039 
    oprot.writeStructBegin('getPlansForOperator_args')
29040 
    if self.operatorId is not None:
29041 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29042 
      oprot.writeI64(self.operatorId)
29043 
      oprot.writeFieldEnd()
29044 
    oprot.writeFieldStop()
29045 
    oprot.writeStructEnd()
29046 
 
29047 
  def validate(self):
29048 
    return
29049 
 
29050 
 
29051 
  def __repr__(self):
29052 
    L = ['%s=%r' % (key, value)
29053 
      for key, value in self.__dict__.iteritems()]
29054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29055 
 
29056 
  def __eq__(self, other):
29057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29058 
 
29059 
  def __ne__(self, other):
29060 
    return not (self == other)
29061 
 
29062 
class getPlansForOperator_result:
29063 
  """
29064 
  Attributes:
29065 
   - success
29066 
  """
29067 
 
29068 
  thrift_spec = (
29069 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29070 
  )
29071 
 
29072 
  def __init__(self, success=None,):
29073 
    self.success = success
29074 
 
29075 
  def read(self, iprot):
29076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29078 
      return
29079 
    iprot.readStructBegin()
29080 
    while True:
29081 
      (fname, ftype, fid) = iprot.readFieldBegin()
29082 
      if ftype == TType.STOP:
29083 
        break
29084 
      if fid == 0:
29085 
        if ftype == TType.LIST:
29086 
          self.success = []
6188 rajveer 29087 
          (_etype696, _size693) = iprot.readListBegin()
29088 
          for _i697 in xrange(_size693):
29089 
            _elem698 = RechargePlan()
29090 
            _elem698.read(iprot)
29091 
            self.success.append(_elem698)
6159 rajveer 29092 
          iprot.readListEnd()
29093 
        else:
29094 
          iprot.skip(ftype)
29095 
      else:
29096 
        iprot.skip(ftype)
29097 
      iprot.readFieldEnd()
29098 
    iprot.readStructEnd()
29099 
 
29100 
  def write(self, oprot):
29101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29103 
      return
29104 
    oprot.writeStructBegin('getPlansForOperator_result')
29105 
    if self.success is not None:
29106 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29107 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29108 
      for iter699 in self.success:
29109 
        iter699.write(oprot)
6159 rajveer 29110 
      oprot.writeListEnd()
29111 
      oprot.writeFieldEnd()
29112 
    oprot.writeFieldStop()
29113 
    oprot.writeStructEnd()
29114 
 
29115 
  def validate(self):
29116 
    return
29117 
 
29118 
 
29119 
  def __repr__(self):
29120 
    L = ['%s=%r' % (key, value)
29121 
      for key, value in self.__dict__.iteritems()]
29122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29123 
 
29124 
  def __eq__(self, other):
29125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29126 
 
29127 
  def __ne__(self, other):
29128 
    return not (self == other)
6289 anupam.sin 29129 
 
29130 
class getRechargeDenominations_args:
29131 
  """
29132 
  Attributes:
29133 
   - operatorId
6307 anupam.sin 29134 
   - circleCode
6289 anupam.sin 29135 
   - denominationType
29136 
  """
29137 
 
29138 
  thrift_spec = (
29139 
    None, # 0
29140 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29141 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29142 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29143 
  )
29144 
 
6307 anupam.sin 29145 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29146 
    self.operatorId = operatorId
6307 anupam.sin 29147 
    self.circleCode = circleCode
6289 anupam.sin 29148 
    self.denominationType = denominationType
29149 
 
29150 
  def read(self, iprot):
29151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29153 
      return
29154 
    iprot.readStructBegin()
29155 
    while True:
29156 
      (fname, ftype, fid) = iprot.readFieldBegin()
29157 
      if ftype == TType.STOP:
29158 
        break
29159 
      if fid == 1:
29160 
        if ftype == TType.I64:
29161 
          self.operatorId = iprot.readI64();
29162 
        else:
29163 
          iprot.skip(ftype)
29164 
      elif fid == 2:
29165 
        if ftype == TType.STRING:
6307 anupam.sin 29166 
          self.circleCode = iprot.readString();
6289 anupam.sin 29167 
        else:
29168 
          iprot.skip(ftype)
29169 
      elif fid == 3:
29170 
        if ftype == TType.I32:
29171 
          self.denominationType = iprot.readI32();
29172 
        else:
29173 
          iprot.skip(ftype)
29174 
      else:
29175 
        iprot.skip(ftype)
29176 
      iprot.readFieldEnd()
29177 
    iprot.readStructEnd()
29178 
 
29179 
  def write(self, oprot):
29180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29182 
      return
29183 
    oprot.writeStructBegin('getRechargeDenominations_args')
29184 
    if self.operatorId is not None:
29185 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29186 
      oprot.writeI64(self.operatorId)
29187 
      oprot.writeFieldEnd()
6307 anupam.sin 29188 
    if self.circleCode is not None:
29189 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29190 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29191 
      oprot.writeFieldEnd()
29192 
    if self.denominationType is not None:
29193 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29194 
      oprot.writeI32(self.denominationType)
29195 
      oprot.writeFieldEnd()
29196 
    oprot.writeFieldStop()
29197 
    oprot.writeStructEnd()
29198 
 
29199 
  def validate(self):
29200 
    return
29201 
 
29202 
 
29203 
  def __repr__(self):
29204 
    L = ['%s=%r' % (key, value)
29205 
      for key, value in self.__dict__.iteritems()]
29206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29207 
 
29208 
  def __eq__(self, other):
29209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29210 
 
29211 
  def __ne__(self, other):
29212 
    return not (self == other)
29213 
 
29214 
class getRechargeDenominations_result:
29215 
  """
29216 
  Attributes:
29217 
   - success
29218 
   - ex
29219 
  """
29220 
 
29221 
  thrift_spec = (
29222 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29224 
  )
29225 
 
29226 
  def __init__(self, success=None, ex=None,):
29227 
    self.success = success
29228 
    self.ex = ex
29229 
 
29230 
  def read(self, iprot):
29231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29233 
      return
29234 
    iprot.readStructBegin()
29235 
    while True:
29236 
      (fname, ftype, fid) = iprot.readFieldBegin()
29237 
      if ftype == TType.STOP:
29238 
        break
29239 
      if fid == 0:
29240 
        if ftype == TType.LIST:
29241 
          self.success = []
29242 
          (_etype703, _size700) = iprot.readListBegin()
29243 
          for _i704 in xrange(_size700):
29244 
            _elem705 = RechargeDenomination()
29245 
            _elem705.read(iprot)
29246 
            self.success.append(_elem705)
29247 
          iprot.readListEnd()
29248 
        else:
29249 
          iprot.skip(ftype)
29250 
      elif fid == 1:
29251 
        if ftype == TType.STRUCT:
29252 
          self.ex = TransactionServiceException()
29253 
          self.ex.read(iprot)
29254 
        else:
29255 
          iprot.skip(ftype)
29256 
      else:
29257 
        iprot.skip(ftype)
29258 
      iprot.readFieldEnd()
29259 
    iprot.readStructEnd()
29260 
 
29261 
  def write(self, oprot):
29262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29264 
      return
29265 
    oprot.writeStructBegin('getRechargeDenominations_result')
29266 
    if self.success is not None:
29267 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29268 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29269 
      for iter706 in self.success:
29270 
        iter706.write(oprot)
29271 
      oprot.writeListEnd()
29272 
      oprot.writeFieldEnd()
29273 
    if self.ex is not None:
29274 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29275 
      self.ex.write(oprot)
29276 
      oprot.writeFieldEnd()
29277 
    oprot.writeFieldStop()
29278 
    oprot.writeStructEnd()
29279 
 
29280 
  def validate(self):
29281 
    return
29282 
 
29283 
 
29284 
  def __repr__(self):
29285 
    L = ['%s=%r' % (key, value)
29286 
      for key, value in self.__dict__.iteritems()]
29287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29288 
 
29289 
  def __eq__(self, other):
29290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29291 
 
29292 
  def __ne__(self, other):
29293 
    return not (self == other)
6371 rajveer 29294 
 
29295 
class updateAvailabilityStatus_args:
29296 
  """
29297 
  Attributes:
29298 
   - operatorId
29299 
   - circleId
29300 
   - isAvailable
29301 
  """
29302 
 
29303 
  thrift_spec = (
29304 
    None, # 0
29305 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29306 
    (2, TType.I64, 'circleId', None, None, ), # 2
29307 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29308 
  )
29309 
 
29310 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29311 
    self.operatorId = operatorId
29312 
    self.circleId = circleId
29313 
    self.isAvailable = isAvailable
29314 
 
29315 
  def read(self, iprot):
29316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29318 
      return
29319 
    iprot.readStructBegin()
29320 
    while True:
29321 
      (fname, ftype, fid) = iprot.readFieldBegin()
29322 
      if ftype == TType.STOP:
29323 
        break
29324 
      if fid == 1:
29325 
        if ftype == TType.I64:
29326 
          self.operatorId = iprot.readI64();
29327 
        else:
29328 
          iprot.skip(ftype)
29329 
      elif fid == 2:
29330 
        if ftype == TType.I64:
29331 
          self.circleId = iprot.readI64();
29332 
        else:
29333 
          iprot.skip(ftype)
29334 
      elif fid == 3:
29335 
        if ftype == TType.BOOL:
29336 
          self.isAvailable = iprot.readBool();
29337 
        else:
29338 
          iprot.skip(ftype)
29339 
      else:
29340 
        iprot.skip(ftype)
29341 
      iprot.readFieldEnd()
29342 
    iprot.readStructEnd()
29343 
 
29344 
  def write(self, oprot):
29345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29347 
      return
29348 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29349 
    if self.operatorId is not None:
29350 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29351 
      oprot.writeI64(self.operatorId)
29352 
      oprot.writeFieldEnd()
29353 
    if self.circleId is not None:
29354 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29355 
      oprot.writeI64(self.circleId)
29356 
      oprot.writeFieldEnd()
29357 
    if self.isAvailable is not None:
29358 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29359 
      oprot.writeBool(self.isAvailable)
29360 
      oprot.writeFieldEnd()
29361 
    oprot.writeFieldStop()
29362 
    oprot.writeStructEnd()
29363 
 
29364 
  def validate(self):
29365 
    return
29366 
 
29367 
 
29368 
  def __repr__(self):
29369 
    L = ['%s=%r' % (key, value)
29370 
      for key, value in self.__dict__.iteritems()]
29371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29372 
 
29373 
  def __eq__(self, other):
29374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29375 
 
29376 
  def __ne__(self, other):
29377 
    return not (self == other)
29378 
 
29379 
class updateAvailabilityStatus_result:
29380 
 
29381 
  thrift_spec = (
29382 
  )
29383 
 
29384 
  def read(self, iprot):
29385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29387 
      return
29388 
    iprot.readStructBegin()
29389 
    while True:
29390 
      (fname, ftype, fid) = iprot.readFieldBegin()
29391 
      if ftype == TType.STOP:
29392 
        break
29393 
      else:
29394 
        iprot.skip(ftype)
29395 
      iprot.readFieldEnd()
29396 
    iprot.readStructEnd()
29397 
 
29398 
  def write(self, oprot):
29399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29401 
      return
29402 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29403 
    oprot.writeFieldStop()
29404 
    oprot.writeStructEnd()
29405 
 
29406 
  def validate(self):
29407 
    return
29408 
 
29409 
 
29410 
  def __repr__(self):
29411 
    L = ['%s=%r' % (key, value)
29412 
      for key, value in self.__dict__.iteritems()]
29413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29414 
 
29415 
  def __eq__(self, other):
29416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29417 
 
29418 
  def __ne__(self, other):
29419 
    return not (self == other)
6389 rajveer 29420 
 
29421 
class getAvailableEmiSchemes_args:
29422 
 
29423 
  thrift_spec = (
29424 
  )
29425 
 
29426 
  def read(self, iprot):
29427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29429 
      return
29430 
    iprot.readStructBegin()
29431 
    while True:
29432 
      (fname, ftype, fid) = iprot.readFieldBegin()
29433 
      if ftype == TType.STOP:
29434 
        break
29435 
      else:
29436 
        iprot.skip(ftype)
29437 
      iprot.readFieldEnd()
29438 
    iprot.readStructEnd()
29439 
 
29440 
  def write(self, oprot):
29441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29443 
      return
29444 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29445 
    oprot.writeFieldStop()
29446 
    oprot.writeStructEnd()
29447 
 
29448 
  def validate(self):
29449 
    return
29450 
 
29451 
 
29452 
  def __repr__(self):
29453 
    L = ['%s=%r' % (key, value)
29454 
      for key, value in self.__dict__.iteritems()]
29455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29456 
 
29457 
  def __eq__(self, other):
29458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29459 
 
29460 
  def __ne__(self, other):
29461 
    return not (self == other)
29462 
 
29463 
class getAvailableEmiSchemes_result:
29464 
  """
29465 
  Attributes:
29466 
   - success
29467 
  """
29468 
 
29469 
  thrift_spec = (
29470 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29471 
  )
29472 
 
29473 
  def __init__(self, success=None,):
29474 
    self.success = success
29475 
 
29476 
  def read(self, iprot):
29477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29479 
      return
29480 
    iprot.readStructBegin()
29481 
    while True:
29482 
      (fname, ftype, fid) = iprot.readFieldBegin()
29483 
      if ftype == TType.STOP:
29484 
        break
29485 
      if fid == 0:
29486 
        if ftype == TType.LIST:
29487 
          self.success = []
29488 
          (_etype710, _size707) = iprot.readListBegin()
29489 
          for _i711 in xrange(_size707):
29490 
            _elem712 = EmiScheme()
29491 
            _elem712.read(iprot)
29492 
            self.success.append(_elem712)
29493 
          iprot.readListEnd()
29494 
        else:
29495 
          iprot.skip(ftype)
29496 
      else:
29497 
        iprot.skip(ftype)
29498 
      iprot.readFieldEnd()
29499 
    iprot.readStructEnd()
29500 
 
29501 
  def write(self, oprot):
29502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29504 
      return
29505 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29506 
    if self.success is not None:
29507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29509 
      for iter713 in self.success:
29510 
        iter713.write(oprot)
29511 
      oprot.writeListEnd()
29512 
      oprot.writeFieldEnd()
29513 
    oprot.writeFieldStop()
29514 
    oprot.writeStructEnd()
29515 
 
29516 
  def validate(self):
29517 
    return
29518 
 
29519 
 
29520 
  def __repr__(self):
29521 
    L = ['%s=%r' % (key, value)
29522 
      for key, value in self.__dict__.iteritems()]
29523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29524 
 
29525 
  def __eq__(self, other):
29526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29527 
 
29528 
  def __ne__(self, other):
29529 
    return not (self == other)
29530 
 
29531 
class getMiscCharges_args:
29532 
  """
29533 
  Attributes:
29534 
   - transactionId
29535 
  """
29536 
 
29537 
  thrift_spec = (
29538 
    None, # 0
29539 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29540 
  )
29541 
 
29542 
  def __init__(self, transactionId=None,):
29543 
    self.transactionId = transactionId
29544 
 
29545 
  def read(self, iprot):
29546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29548 
      return
29549 
    iprot.readStructBegin()
29550 
    while True:
29551 
      (fname, ftype, fid) = iprot.readFieldBegin()
29552 
      if ftype == TType.STOP:
29553 
        break
29554 
      if fid == 1:
29555 
        if ftype == TType.I64:
29556 
          self.transactionId = iprot.readI64();
29557 
        else:
29558 
          iprot.skip(ftype)
29559 
      else:
29560 
        iprot.skip(ftype)
29561 
      iprot.readFieldEnd()
29562 
    iprot.readStructEnd()
29563 
 
29564 
  def write(self, oprot):
29565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29567 
      return
29568 
    oprot.writeStructBegin('getMiscCharges_args')
29569 
    if self.transactionId is not None:
29570 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29571 
      oprot.writeI64(self.transactionId)
29572 
      oprot.writeFieldEnd()
29573 
    oprot.writeFieldStop()
29574 
    oprot.writeStructEnd()
29575 
 
29576 
  def validate(self):
29577 
    return
29578 
 
29579 
 
29580 
  def __repr__(self):
29581 
    L = ['%s=%r' % (key, value)
29582 
      for key, value in self.__dict__.iteritems()]
29583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29584 
 
29585 
  def __eq__(self, other):
29586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29587 
 
29588 
  def __ne__(self, other):
29589 
    return not (self == other)
29590 
 
29591 
class getMiscCharges_result:
29592 
  """
29593 
  Attributes:
29594 
   - success
29595 
  """
29596 
 
29597 
  thrift_spec = (
6412 rajveer 29598 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29599 
  )
29600 
 
29601 
  def __init__(self, success=None,):
29602 
    self.success = success
29603 
 
29604 
  def read(self, iprot):
29605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29607 
      return
29608 
    iprot.readStructBegin()
29609 
    while True:
29610 
      (fname, ftype, fid) = iprot.readFieldBegin()
29611 
      if ftype == TType.STOP:
29612 
        break
29613 
      if fid == 0:
29614 
        if ftype == TType.MAP:
29615 
          self.success = {}
29616 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29617 
          for _i718 in xrange(_size714):
29618 
            _key719 = iprot.readI64();
6412 rajveer 29619 
            _val720 = iprot.readDouble();
6389 rajveer 29620 
            self.success[_key719] = _val720
29621 
          iprot.readMapEnd()
29622 
        else:
29623 
          iprot.skip(ftype)
29624 
      else:
29625 
        iprot.skip(ftype)
29626 
      iprot.readFieldEnd()
29627 
    iprot.readStructEnd()
29628 
 
29629 
  def write(self, oprot):
29630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29632 
      return
29633 
    oprot.writeStructBegin('getMiscCharges_result')
29634 
    if self.success is not None:
29635 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29636 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29637 
      for kiter721,viter722 in self.success.items():
29638 
        oprot.writeI64(kiter721)
6412 rajveer 29639 
        oprot.writeDouble(viter722)
6389 rajveer 29640 
      oprot.writeMapEnd()
29641 
      oprot.writeFieldEnd()
29642 
    oprot.writeFieldStop()
29643 
    oprot.writeStructEnd()
29644 
 
29645 
  def validate(self):
29646 
    return
29647 
 
29648 
 
29649 
  def __repr__(self):
29650 
    L = ['%s=%r' % (key, value)
29651 
      for key, value in self.__dict__.iteritems()]
29652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29653 
 
29654 
  def __eq__(self, other):
29655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29656 
 
29657 
  def __ne__(self, other):
29658 
    return not (self == other)
6507 anupam.sin 29659 
 
29660 
class refundRechargeOrder_args:
29661 
  """
29662 
  Attributes:
29663 
   - rechargeOrderId
29664 
  """
29665 
 
29666 
  thrift_spec = (
29667 
    None, # 0
29668 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29669 
  )
29670 
 
29671 
  def __init__(self, rechargeOrderId=None,):
29672 
    self.rechargeOrderId = rechargeOrderId
29673 
 
29674 
  def read(self, iprot):
29675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29677 
      return
29678 
    iprot.readStructBegin()
29679 
    while True:
29680 
      (fname, ftype, fid) = iprot.readFieldBegin()
29681 
      if ftype == TType.STOP:
29682 
        break
29683 
      if fid == 1:
29684 
        if ftype == TType.I64:
29685 
          self.rechargeOrderId = iprot.readI64();
29686 
        else:
29687 
          iprot.skip(ftype)
29688 
      else:
29689 
        iprot.skip(ftype)
29690 
      iprot.readFieldEnd()
29691 
    iprot.readStructEnd()
29692 
 
29693 
  def write(self, oprot):
29694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29696 
      return
29697 
    oprot.writeStructBegin('refundRechargeOrder_args')
29698 
    if self.rechargeOrderId is not None:
29699 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29700 
      oprot.writeI64(self.rechargeOrderId)
29701 
      oprot.writeFieldEnd()
29702 
    oprot.writeFieldStop()
29703 
    oprot.writeStructEnd()
29704 
 
29705 
  def validate(self):
29706 
    return
29707 
 
29708 
 
29709 
  def __repr__(self):
29710 
    L = ['%s=%r' % (key, value)
29711 
      for key, value in self.__dict__.iteritems()]
29712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29713 
 
29714 
  def __eq__(self, other):
29715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29716 
 
29717 
  def __ne__(self, other):
29718 
    return not (self == other)
29719 
 
29720 
class refundRechargeOrder_result:
29721 
  """
29722 
  Attributes:
29723 
   - success
29724 
   - ex
29725 
  """
29726 
 
29727 
  thrift_spec = (
29728 
    (0, TType.BOOL, 'success', None, None, ), # 0
29729 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29730 
  )
29731 
 
29732 
  def __init__(self, success=None, ex=None,):
29733 
    self.success = success
29734 
    self.ex = ex
29735 
 
29736 
  def read(self, iprot):
29737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29739 
      return
29740 
    iprot.readStructBegin()
29741 
    while True:
29742 
      (fname, ftype, fid) = iprot.readFieldBegin()
29743 
      if ftype == TType.STOP:
29744 
        break
29745 
      if fid == 0:
29746 
        if ftype == TType.BOOL:
29747 
          self.success = iprot.readBool();
29748 
        else:
29749 
          iprot.skip(ftype)
29750 
      elif fid == 1:
29751 
        if ftype == TType.STRUCT:
29752 
          self.ex = TransactionServiceException()
29753 
          self.ex.read(iprot)
29754 
        else:
29755 
          iprot.skip(ftype)
29756 
      else:
29757 
        iprot.skip(ftype)
29758 
      iprot.readFieldEnd()
29759 
    iprot.readStructEnd()
29760 
 
29761 
  def write(self, oprot):
29762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29764 
      return
29765 
    oprot.writeStructBegin('refundRechargeOrder_result')
29766 
    if self.success is not None:
29767 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29768 
      oprot.writeBool(self.success)
29769 
      oprot.writeFieldEnd()
29770 
    if self.ex is not None:
29771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29772 
      self.ex.write(oprot)
29773 
      oprot.writeFieldEnd()
29774 
    oprot.writeFieldStop()
29775 
    oprot.writeStructEnd()
29776 
 
29777 
  def validate(self):
29778 
    return
29779 
 
29780 
 
29781 
  def __repr__(self):
29782 
    L = ['%s=%r' % (key, value)
29783 
      for key, value in self.__dict__.iteritems()]
29784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29785 
 
29786 
  def __eq__(self, other):
29787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29788 
 
29789 
  def __ne__(self, other):
29790 
    return not (self == other)
6821 amar.kumar 29791 
 
29792 
class getPhysicalOrders_args:
29793 
  """
29794 
  Attributes:
29795 
   - fromDate
29796 
   - toDate
29797 
  """
29798 
 
29799 
  thrift_spec = (
29800 
    None, # 0
29801 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29802 
    (2, TType.I64, 'toDate', None, None, ), # 2
29803 
  )
29804 
 
29805 
  def __init__(self, fromDate=None, toDate=None,):
29806 
    self.fromDate = fromDate
29807 
    self.toDate = toDate
29808 
 
29809 
  def read(self, iprot):
29810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29812 
      return
29813 
    iprot.readStructBegin()
29814 
    while True:
29815 
      (fname, ftype, fid) = iprot.readFieldBegin()
29816 
      if ftype == TType.STOP:
29817 
        break
29818 
      if fid == 1:
29819 
        if ftype == TType.I64:
29820 
          self.fromDate = iprot.readI64();
29821 
        else:
29822 
          iprot.skip(ftype)
29823 
      elif fid == 2:
29824 
        if ftype == TType.I64:
29825 
          self.toDate = iprot.readI64();
29826 
        else:
29827 
          iprot.skip(ftype)
29828 
      else:
29829 
        iprot.skip(ftype)
29830 
      iprot.readFieldEnd()
29831 
    iprot.readStructEnd()
29832 
 
29833 
  def write(self, oprot):
29834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29836 
      return
29837 
    oprot.writeStructBegin('getPhysicalOrders_args')
29838 
    if self.fromDate is not None:
29839 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29840 
      oprot.writeI64(self.fromDate)
29841 
      oprot.writeFieldEnd()
29842 
    if self.toDate is not None:
29843 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29844 
      oprot.writeI64(self.toDate)
29845 
      oprot.writeFieldEnd()
29846 
    oprot.writeFieldStop()
29847 
    oprot.writeStructEnd()
29848 
 
29849 
  def validate(self):
29850 
    return
29851 
 
29852 
 
29853 
  def __repr__(self):
29854 
    L = ['%s=%r' % (key, value)
29855 
      for key, value in self.__dict__.iteritems()]
29856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29857 
 
29858 
  def __eq__(self, other):
29859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29860 
 
29861 
  def __ne__(self, other):
29862 
    return not (self == other)
29863 
 
29864 
class getPhysicalOrders_result:
29865 
  """
29866 
  Attributes:
29867 
   - success
29868 
  """
29869 
 
29870 
  thrift_spec = (
29871 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29872 
  )
29873 
 
29874 
  def __init__(self, success=None,):
29875 
    self.success = success
29876 
 
29877 
  def read(self, iprot):
29878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29880 
      return
29881 
    iprot.readStructBegin()
29882 
    while True:
29883 
      (fname, ftype, fid) = iprot.readFieldBegin()
29884 
      if ftype == TType.STOP:
29885 
        break
29886 
      if fid == 0:
29887 
        if ftype == TType.LIST:
29888 
          self.success = []
29889 
          (_etype726, _size723) = iprot.readListBegin()
29890 
          for _i727 in xrange(_size723):
29891 
            _elem728 = Order()
29892 
            _elem728.read(iprot)
29893 
            self.success.append(_elem728)
29894 
          iprot.readListEnd()
29895 
        else:
29896 
          iprot.skip(ftype)
29897 
      else:
29898 
        iprot.skip(ftype)
29899 
      iprot.readFieldEnd()
29900 
    iprot.readStructEnd()
29901 
 
29902 
  def write(self, oprot):
29903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29905 
      return
29906 
    oprot.writeStructBegin('getPhysicalOrders_result')
29907 
    if self.success is not None:
29908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29910 
      for iter729 in self.success:
29911 
        iter729.write(oprot)
29912 
      oprot.writeListEnd()
29913 
      oprot.writeFieldEnd()
29914 
    oprot.writeFieldStop()
29915 
    oprot.writeStructEnd()
29916 
 
29917 
  def validate(self):
29918 
    return
29919 
 
29920 
 
29921 
  def __repr__(self):
29922 
    L = ['%s=%r' % (key, value)
29923 
      for key, value in self.__dict__.iteritems()]
29924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29925 
 
29926 
  def __eq__(self, other):
29927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29928 
 
29929 
  def __ne__(self, other):
29930 
    return not (self == other)
6906 rajveer 29931 
 
29932 
class getDocument_args:
29933 
  """
29934 
  Attributes:
29935 
   - docType
29936 
   - docSource
29937 
  """
29938 
 
29939 
  thrift_spec = (
29940 
    None, # 0
29941 
    (1, TType.I64, 'docType', None, None, ), # 1
29942 
    (2, TType.I64, 'docSource', None, None, ), # 2
29943 
  )
29944 
 
29945 
  def __init__(self, docType=None, docSource=None,):
29946 
    self.docType = docType
29947 
    self.docSource = docSource
29948 
 
29949 
  def read(self, iprot):
29950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29952 
      return
29953 
    iprot.readStructBegin()
29954 
    while True:
29955 
      (fname, ftype, fid) = iprot.readFieldBegin()
29956 
      if ftype == TType.STOP:
29957 
        break
29958 
      if fid == 1:
29959 
        if ftype == TType.I64:
29960 
          self.docType = iprot.readI64();
29961 
        else:
29962 
          iprot.skip(ftype)
29963 
      elif fid == 2:
29964 
        if ftype == TType.I64:
29965 
          self.docSource = iprot.readI64();
29966 
        else:
29967 
          iprot.skip(ftype)
29968 
      else:
29969 
        iprot.skip(ftype)
29970 
      iprot.readFieldEnd()
29971 
    iprot.readStructEnd()
29972 
 
29973 
  def write(self, oprot):
29974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29976 
      return
29977 
    oprot.writeStructBegin('getDocument_args')
29978 
    if self.docType is not None:
29979 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29980 
      oprot.writeI64(self.docType)
29981 
      oprot.writeFieldEnd()
29982 
    if self.docSource is not None:
29983 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29984 
      oprot.writeI64(self.docSource)
29985 
      oprot.writeFieldEnd()
29986 
    oprot.writeFieldStop()
29987 
    oprot.writeStructEnd()
29988 
 
29989 
  def validate(self):
29990 
    return
29991 
 
29992 
 
29993 
  def __repr__(self):
29994 
    L = ['%s=%r' % (key, value)
29995 
      for key, value in self.__dict__.iteritems()]
29996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29997 
 
29998 
  def __eq__(self, other):
29999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30000 
 
30001 
  def __ne__(self, other):
30002 
    return not (self == other)
30003 
 
30004 
class getDocument_result:
30005 
  """
30006 
  Attributes:
30007 
   - success
30008 
  """
30009 
 
30010 
  thrift_spec = (
30011 
    (0, TType.STRING, 'success', None, None, ), # 0
30012 
  )
30013 
 
30014 
  def __init__(self, success=None,):
30015 
    self.success = success
30016 
 
30017 
  def read(self, iprot):
30018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30020 
      return
30021 
    iprot.readStructBegin()
30022 
    while True:
30023 
      (fname, ftype, fid) = iprot.readFieldBegin()
30024 
      if ftype == TType.STOP:
30025 
        break
30026 
      if fid == 0:
30027 
        if ftype == TType.STRING:
30028 
          self.success = iprot.readString();
30029 
        else:
30030 
          iprot.skip(ftype)
30031 
      else:
30032 
        iprot.skip(ftype)
30033 
      iprot.readFieldEnd()
30034 
    iprot.readStructEnd()
30035 
 
30036 
  def write(self, oprot):
30037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30039 
      return
30040 
    oprot.writeStructBegin('getDocument_result')
30041 
    if self.success is not None:
30042 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30043 
      oprot.writeString(self.success)
30044 
      oprot.writeFieldEnd()
30045 
    oprot.writeFieldStop()
30046 
    oprot.writeStructEnd()
30047 
 
30048 
  def validate(self):
30049 
    return
30050 
 
30051 
 
30052 
  def __repr__(self):
30053 
    L = ['%s=%r' % (key, value)
30054 
      for key, value in self.__dict__.iteritems()]
30055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30056 
 
30057 
  def __eq__(self, other):
30058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30059 
 
30060 
  def __ne__(self, other):
30061 
    return not (self == other)
6985 anupam.sin 30062 
 
30063 
class changeShippingAddress_args:
30064 
  """
30065 
  Attributes:
30066 
   - orderId
30067 
   - line1
30068 
   - line2
30069 
   - city
30070 
   - state
30071 
   - pin
30072 
  """
30073 
 
30074 
  thrift_spec = (
30075 
    None, # 0
30076 
    (1, TType.I64, 'orderId', None, None, ), # 1
30077 
    (2, TType.STRING, 'line1', None, None, ), # 2
30078 
    (3, TType.STRING, 'line2', None, None, ), # 3
30079 
    (4, TType.STRING, 'city', None, None, ), # 4
30080 
    (5, TType.STRING, 'state', None, None, ), # 5
30081 
    (6, TType.STRING, 'pin', None, None, ), # 6
30082 
  )
30083 
 
30084 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30085 
    self.orderId = orderId
30086 
    self.line1 = line1
30087 
    self.line2 = line2
30088 
    self.city = city
30089 
    self.state = state
30090 
    self.pin = pin
30091 
 
30092 
  def read(self, iprot):
30093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30095 
      return
30096 
    iprot.readStructBegin()
30097 
    while True:
30098 
      (fname, ftype, fid) = iprot.readFieldBegin()
30099 
      if ftype == TType.STOP:
30100 
        break
30101 
      if fid == 1:
30102 
        if ftype == TType.I64:
30103 
          self.orderId = iprot.readI64();
30104 
        else:
30105 
          iprot.skip(ftype)
30106 
      elif fid == 2:
30107 
        if ftype == TType.STRING:
30108 
          self.line1 = iprot.readString();
30109 
        else:
30110 
          iprot.skip(ftype)
30111 
      elif fid == 3:
30112 
        if ftype == TType.STRING:
30113 
          self.line2 = iprot.readString();
30114 
        else:
30115 
          iprot.skip(ftype)
30116 
      elif fid == 4:
30117 
        if ftype == TType.STRING:
30118 
          self.city = iprot.readString();
30119 
        else:
30120 
          iprot.skip(ftype)
30121 
      elif fid == 5:
30122 
        if ftype == TType.STRING:
30123 
          self.state = iprot.readString();
30124 
        else:
30125 
          iprot.skip(ftype)
30126 
      elif fid == 6:
30127 
        if ftype == TType.STRING:
30128 
          self.pin = iprot.readString();
30129 
        else:
30130 
          iprot.skip(ftype)
30131 
      else:
30132 
        iprot.skip(ftype)
30133 
      iprot.readFieldEnd()
30134 
    iprot.readStructEnd()
30135 
 
30136 
  def write(self, oprot):
30137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30139 
      return
30140 
    oprot.writeStructBegin('changeShippingAddress_args')
30141 
    if self.orderId is not None:
30142 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30143 
      oprot.writeI64(self.orderId)
30144 
      oprot.writeFieldEnd()
30145 
    if self.line1 is not None:
30146 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30147 
      oprot.writeString(self.line1)
30148 
      oprot.writeFieldEnd()
30149 
    if self.line2 is not None:
30150 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30151 
      oprot.writeString(self.line2)
30152 
      oprot.writeFieldEnd()
30153 
    if self.city is not None:
30154 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30155 
      oprot.writeString(self.city)
30156 
      oprot.writeFieldEnd()
30157 
    if self.state is not None:
30158 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30159 
      oprot.writeString(self.state)
30160 
      oprot.writeFieldEnd()
30161 
    if self.pin is not None:
30162 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30163 
      oprot.writeString(self.pin)
30164 
      oprot.writeFieldEnd()
30165 
    oprot.writeFieldStop()
30166 
    oprot.writeStructEnd()
30167 
 
30168 
  def validate(self):
30169 
    return
30170 
 
30171 
 
30172 
  def __repr__(self):
30173 
    L = ['%s=%r' % (key, value)
30174 
      for key, value in self.__dict__.iteritems()]
30175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30176 
 
30177 
  def __eq__(self, other):
30178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30179 
 
30180 
  def __ne__(self, other):
30181 
    return not (self == other)
30182 
 
30183 
class changeShippingAddress_result:
30184 
  """
30185 
  Attributes:
30186 
   - success
30187 
  """
30188 
 
30189 
  thrift_spec = (
30190 
    (0, TType.BOOL, 'success', None, None, ), # 0
30191 
  )
30192 
 
30193 
  def __init__(self, success=None,):
30194 
    self.success = success
30195 
 
30196 
  def read(self, iprot):
30197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30199 
      return
30200 
    iprot.readStructBegin()
30201 
    while True:
30202 
      (fname, ftype, fid) = iprot.readFieldBegin()
30203 
      if ftype == TType.STOP:
30204 
        break
30205 
      if fid == 0:
30206 
        if ftype == TType.BOOL:
30207 
          self.success = iprot.readBool();
30208 
        else:
30209 
          iprot.skip(ftype)
30210 
      else:
30211 
        iprot.skip(ftype)
30212 
      iprot.readFieldEnd()
30213 
    iprot.readStructEnd()
30214 
 
30215 
  def write(self, oprot):
30216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30218 
      return
30219 
    oprot.writeStructBegin('changeShippingAddress_result')
30220 
    if self.success is not None:
30221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30222 
      oprot.writeBool(self.success)
30223 
      oprot.writeFieldEnd()
30224 
    oprot.writeFieldStop()
30225 
    oprot.writeStructEnd()
30226 
 
30227 
  def validate(self):
30228 
    return
30229 
 
30230 
 
30231 
  def __repr__(self):
30232 
    L = ['%s=%r' % (key, value)
30233 
      for key, value in self.__dict__.iteritems()]
30234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30235 
 
30236 
  def __eq__(self, other):
30237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30238 
 
30239 
  def __ne__(self, other):
30240 
    return not (self == other)
6988 rajveer 30241 
 
30242 
class retrieveInvoice_args:
30243 
  """
30244 
  Attributes:
30245 
   - orderId
7075 rajveer 30246 
   - userId
6988 rajveer 30247 
  """
30248 
 
30249 
  thrift_spec = (
30250 
    None, # 0
30251 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30252 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30253 
  )
30254 
 
7075 rajveer 30255 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30256 
    self.orderId = orderId
7075 rajveer 30257 
    self.userId = userId
6988 rajveer 30258 
 
30259 
  def read(self, iprot):
30260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30262 
      return
30263 
    iprot.readStructBegin()
30264 
    while True:
30265 
      (fname, ftype, fid) = iprot.readFieldBegin()
30266 
      if ftype == TType.STOP:
30267 
        break
30268 
      if fid == 1:
30269 
        if ftype == TType.I64:
30270 
          self.orderId = iprot.readI64();
30271 
        else:
30272 
          iprot.skip(ftype)
7075 rajveer 30273 
      elif fid == 2:
30274 
        if ftype == TType.I64:
30275 
          self.userId = iprot.readI64();
30276 
        else:
30277 
          iprot.skip(ftype)
6988 rajveer 30278 
      else:
30279 
        iprot.skip(ftype)
30280 
      iprot.readFieldEnd()
30281 
    iprot.readStructEnd()
30282 
 
30283 
  def write(self, oprot):
30284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30286 
      return
30287 
    oprot.writeStructBegin('retrieveInvoice_args')
30288 
    if self.orderId is not None:
30289 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30290 
      oprot.writeI64(self.orderId)
30291 
      oprot.writeFieldEnd()
7075 rajveer 30292 
    if self.userId is not None:
30293 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30294 
      oprot.writeI64(self.userId)
30295 
      oprot.writeFieldEnd()
6988 rajveer 30296 
    oprot.writeFieldStop()
30297 
    oprot.writeStructEnd()
30298 
 
30299 
  def validate(self):
30300 
    return
30301 
 
30302 
 
30303 
  def __repr__(self):
30304 
    L = ['%s=%r' % (key, value)
30305 
      for key, value in self.__dict__.iteritems()]
30306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30307 
 
30308 
  def __eq__(self, other):
30309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30310 
 
30311 
  def __ne__(self, other):
30312 
    return not (self == other)
30313 
 
30314 
class retrieveInvoice_result:
30315 
  """
30316 
  Attributes:
30317 
   - success
30318 
  """
30319 
 
30320 
  thrift_spec = (
30321 
    (0, TType.STRING, 'success', None, None, ), # 0
30322 
  )
30323 
 
30324 
  def __init__(self, success=None,):
30325 
    self.success = success
30326 
 
30327 
  def read(self, iprot):
30328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30330 
      return
30331 
    iprot.readStructBegin()
30332 
    while True:
30333 
      (fname, ftype, fid) = iprot.readFieldBegin()
30334 
      if ftype == TType.STOP:
30335 
        break
30336 
      if fid == 0:
30337 
        if ftype == TType.STRING:
30338 
          self.success = iprot.readString();
30339 
        else:
30340 
          iprot.skip(ftype)
30341 
      else:
30342 
        iprot.skip(ftype)
30343 
      iprot.readFieldEnd()
30344 
    iprot.readStructEnd()
30345 
 
30346 
  def write(self, oprot):
30347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30349 
      return
30350 
    oprot.writeStructBegin('retrieveInvoice_result')
30351 
    if self.success is not None:
30352 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30353 
      oprot.writeString(self.success)
30354 
      oprot.writeFieldEnd()
30355 
    oprot.writeFieldStop()
30356 
    oprot.writeStructEnd()
30357 
 
30358 
  def validate(self):
30359 
    return
30360 
 
30361 
 
30362 
  def __repr__(self):
30363 
    L = ['%s=%r' % (key, value)
30364 
      for key, value in self.__dict__.iteritems()]
30365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30366 
 
30367 
  def __eq__(self, other):
30368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30369 
 
30370 
  def __ne__(self, other):
30371 
    return not (self == other)
7026 rajveer 30372 
 
30373 
class receiveUpdatesForRedExpress_args:
30374 
  """
30375 
  Attributes:
30376 
   - awbNumber
30377 
  """
30378 
 
30379 
  thrift_spec = (
30380 
    None, # 0
30381 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30382 
  )
30383 
 
30384 
  def __init__(self, awbNumber=None,):
30385 
    self.awbNumber = awbNumber
30386 
 
30387 
  def read(self, iprot):
30388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30390 
      return
30391 
    iprot.readStructBegin()
30392 
    while True:
30393 
      (fname, ftype, fid) = iprot.readFieldBegin()
30394 
      if ftype == TType.STOP:
30395 
        break
30396 
      if fid == 1:
30397 
        if ftype == TType.STRING:
30398 
          self.awbNumber = iprot.readString();
30399 
        else:
30400 
          iprot.skip(ftype)
30401 
      else:
30402 
        iprot.skip(ftype)
30403 
      iprot.readFieldEnd()
30404 
    iprot.readStructEnd()
30405 
 
30406 
  def write(self, oprot):
30407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30409 
      return
30410 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30411 
    if self.awbNumber is not None:
30412 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30413 
      oprot.writeString(self.awbNumber)
30414 
      oprot.writeFieldEnd()
30415 
    oprot.writeFieldStop()
30416 
    oprot.writeStructEnd()
30417 
 
30418 
  def validate(self):
30419 
    return
30420 
 
30421 
 
30422 
  def __repr__(self):
30423 
    L = ['%s=%r' % (key, value)
30424 
      for key, value in self.__dict__.iteritems()]
30425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30426 
 
30427 
  def __eq__(self, other):
30428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30429 
 
30430 
  def __ne__(self, other):
30431 
    return not (self == other)
30432 
 
30433 
class receiveUpdatesForRedExpress_result:
30434 
  """
30435 
  Attributes:
30436 
   - success
30437 
  """
30438 
 
30439 
  thrift_spec = (
30440 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30441 
  )
30442 
 
30443 
  def __init__(self, success=None,):
30444 
    self.success = success
30445 
 
30446 
  def read(self, iprot):
30447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30449 
      return
30450 
    iprot.readStructBegin()
30451 
    while True:
30452 
      (fname, ftype, fid) = iprot.readFieldBegin()
30453 
      if ftype == TType.STOP:
30454 
        break
30455 
      if fid == 0:
30456 
        if ftype == TType.LIST:
30457 
          self.success = []
30458 
          (_etype733, _size730) = iprot.readListBegin()
30459 
          for _i734 in xrange(_size730):
30460 
            _elem735 = iprot.readString();
30461 
            self.success.append(_elem735)
30462 
          iprot.readListEnd()
30463 
        else:
30464 
          iprot.skip(ftype)
30465 
      else:
30466 
        iprot.skip(ftype)
30467 
      iprot.readFieldEnd()
30468 
    iprot.readStructEnd()
30469 
 
30470 
  def write(self, oprot):
30471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30473 
      return
30474 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30475 
    if self.success is not None:
30476 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30477 
      oprot.writeListBegin(TType.STRING, len(self.success))
30478 
      for iter736 in self.success:
30479 
        oprot.writeString(iter736)
30480 
      oprot.writeListEnd()
30481 
      oprot.writeFieldEnd()
30482 
    oprot.writeFieldStop()
30483 
    oprot.writeStructEnd()
30484 
 
30485 
  def validate(self):
30486 
    return
30487 
 
30488 
 
30489 
  def __repr__(self):
30490 
    L = ['%s=%r' % (key, value)
30491 
      for key, value in self.__dict__.iteritems()]
30492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30493 
 
30494 
  def __eq__(self, other):
30495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30496 
 
30497 
  def __ne__(self, other):
30498 
    return not (self == other)
7073 anupam.sin 30499 
 
30500 
class createRechargeTransaction_args:
30501 
  """
30502 
  Attributes:
30503 
   - thriftRechargeTransaction
30504 
  """
30505 
 
30506 
  thrift_spec = (
30507 
    None, # 0
30508 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30509 
  )
30510 
 
30511 
  def __init__(self, thriftRechargeTransaction=None,):
30512 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30513 
 
30514 
  def read(self, iprot):
30515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30517 
      return
30518 
    iprot.readStructBegin()
30519 
    while True:
30520 
      (fname, ftype, fid) = iprot.readFieldBegin()
30521 
      if ftype == TType.STOP:
30522 
        break
30523 
      if fid == 1:
30524 
        if ftype == TType.STRUCT:
30525 
          self.thriftRechargeTransaction = RechargeTransaction()
30526 
          self.thriftRechargeTransaction.read(iprot)
30527 
        else:
30528 
          iprot.skip(ftype)
30529 
      else:
30530 
        iprot.skip(ftype)
30531 
      iprot.readFieldEnd()
30532 
    iprot.readStructEnd()
30533 
 
30534 
  def write(self, oprot):
30535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30537 
      return
30538 
    oprot.writeStructBegin('createRechargeTransaction_args')
30539 
    if self.thriftRechargeTransaction is not None:
30540 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
30541 
      self.thriftRechargeTransaction.write(oprot)
30542 
      oprot.writeFieldEnd()
30543 
    oprot.writeFieldStop()
30544 
    oprot.writeStructEnd()
30545 
 
30546 
  def validate(self):
30547 
    return
30548 
 
30549 
 
30550 
  def __repr__(self):
30551 
    L = ['%s=%r' % (key, value)
30552 
      for key, value in self.__dict__.iteritems()]
30553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30554 
 
30555 
  def __eq__(self, other):
30556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30557 
 
30558 
  def __ne__(self, other):
30559 
    return not (self == other)
30560 
 
30561 
class createRechargeTransaction_result:
30562 
  """
30563 
  Attributes:
30564 
   - success
30565 
  """
30566 
 
30567 
  thrift_spec = (
30568 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
30569 
  )
30570 
 
30571 
  def __init__(self, success=None,):
30572 
    self.success = success
30573 
 
30574 
  def read(self, iprot):
30575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30577 
      return
30578 
    iprot.readStructBegin()
30579 
    while True:
30580 
      (fname, ftype, fid) = iprot.readFieldBegin()
30581 
      if ftype == TType.STOP:
30582 
        break
30583 
      if fid == 0:
30584 
        if ftype == TType.STRUCT:
30585 
          self.success = RechargeTransaction()
30586 
          self.success.read(iprot)
30587 
        else:
30588 
          iprot.skip(ftype)
30589 
      else:
30590 
        iprot.skip(ftype)
30591 
      iprot.readFieldEnd()
30592 
    iprot.readStructEnd()
30593 
 
30594 
  def write(self, oprot):
30595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30597 
      return
30598 
    oprot.writeStructBegin('createRechargeTransaction_result')
30599 
    if self.success is not None:
30600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
30601 
      self.success.write(oprot)
30602 
      oprot.writeFieldEnd()
30603 
    oprot.writeFieldStop()
30604 
    oprot.writeStructEnd()
30605 
 
30606 
  def validate(self):
30607 
    return
30608 
 
30609 
 
30610 
  def __repr__(self):
30611 
    L = ['%s=%r' % (key, value)
30612 
      for key, value in self.__dict__.iteritems()]
30613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30614 
 
30615 
  def __eq__(self, other):
30616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30617 
 
30618 
  def __ne__(self, other):
30619 
    return not (self == other)