Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
527 
    Returns the final flag status.
528 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
7075 rajveer 1475 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1476 
    """
1477 
    Parameters:
1478 
     - orderId
7075 rajveer 1479 
     - userId
6988 rajveer 1480 
    """
1481 
    pass
6985 anupam.sin 1482 
 
7026 rajveer 1483 
  def receiveUpdatesForRedExpress(self, awbNumber):
1484 
    """
1485 
    Parameters:
1486 
     - awbNumber
1487 
    """
1488 
    pass
6988 rajveer 1489 
 
7073 anupam.sin 1490 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1491 
    """
1492 
    Parameters:
1493 
     - thriftRechargeTransaction
1494 
    """
1495 
    pass
7026 rajveer 1496 
 
7085 rajveer 1497 
  def getRechargeTransactions(self, storeId):
1498 
    """
1499 
    Parameters:
1500 
     - storeId
1501 
    """
1502 
    pass
1503 
 
7151 amit.gupta 1504 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1505 
    """
1506 
    Parameters:
1507 
     - storeId
1508 
     - startDate
1509 
     - endDate
1510 
     - status
1511 
    """
1512 
    pass
1513 
 
7080 anupam.sin 1514 
  def getRechargeTransaction(self, rechargeId):
1515 
    """
1516 
    Parameters:
1517 
     - rechargeId
1518 
    """
1519 
    pass
7073 anupam.sin 1520 
 
7080 anupam.sin 1521 
  def getFRCs(self, circleId, operatorId):
1522 
    """
1523 
    Parameters:
1524 
     - circleId
1525 
     - operatorId
1526 
    """
1527 
    pass
1528 
 
7096 anupam.sin 1529 
  def getHotspotStore(self, id, hotspotid):
1530 
    """
1531 
    Parameters:
1532 
     - id
1533 
     - hotspotid
1534 
    """
1535 
    pass
7080 anupam.sin 1536 
 
7096 anupam.sin 1537 
  def getTelecomCircle(self, id, code):
1538 
    """
1539 
    Parameters:
1540 
     - id
1541 
     - code
1542 
    """
1543 
    pass
1544 
 
7109 anupam.sin 1545 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1546 
    """
1547 
    Parameters:
1548 
     - rechargeId
1549 
    """
1550 
    pass
7096 anupam.sin 1551 
 
7172 anupam.sin 1552 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 1553 
    """
1554 
    Parameters:
1555 
     - number
7172 anupam.sin 1556 
     - storeId
7169 anupam.sin 1557 
    """
1558 
    pass
7109 anupam.sin 1559 
 
7169 anupam.sin 1560 
  def updateHotspotStorePassword(self, storeId, password):
1561 
    """
1562 
    Parameters:
1563 
     - storeId
1564 
     - password
1565 
    """
1566 
    pass
1567 
 
1568 
 
3376 rajveer 1569 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1570 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1571 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1572 
 
1573 
  def createTransaction(self, transaction):
1574 
    """
1575 
    Parameters:
1576 
     - transaction
1577 
    """
1578 
    self.send_createTransaction(transaction)
132 ashish 1579 
    return self.recv_createTransaction()
94 ashish 1580 
 
1581 
  def send_createTransaction(self, transaction):
1582 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1583 
    args = createTransaction_args()
1584 
    args.transaction = transaction
1585 
    args.write(self._oprot)
1586 
    self._oprot.writeMessageEnd()
1587 
    self._oprot.trans.flush()
1588 
 
1589 
  def recv_createTransaction(self, ):
1590 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1591 
    if mtype == TMessageType.EXCEPTION:
1592 
      x = TApplicationException()
1593 
      x.read(self._iprot)
1594 
      self._iprot.readMessageEnd()
1595 
      raise x
1596 
    result = createTransaction_result()
1597 
    result.read(self._iprot)
1598 
    self._iprot.readMessageEnd()
3431 rajveer 1599 
    if result.success is not None:
132 ashish 1600 
      return result.success
3431 rajveer 1601 
    if result.ex is not None:
94 ashish 1602 
      raise result.ex
132 ashish 1603 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1604 
 
1605 
  def getTransaction(self, id):
1606 
    """
1607 
    Parameters:
1608 
     - id
1609 
    """
1610 
    self.send_getTransaction(id)
1611 
    return self.recv_getTransaction()
1612 
 
1613 
  def send_getTransaction(self, id):
1614 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1615 
    args = getTransaction_args()
1616 
    args.id = id
1617 
    args.write(self._oprot)
1618 
    self._oprot.writeMessageEnd()
1619 
    self._oprot.trans.flush()
1620 
 
1621 
  def recv_getTransaction(self, ):
1622 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1623 
    if mtype == TMessageType.EXCEPTION:
1624 
      x = TApplicationException()
1625 
      x.read(self._iprot)
1626 
      self._iprot.readMessageEnd()
1627 
      raise x
1628 
    result = getTransaction_result()
1629 
    result.read(self._iprot)
1630 
    self._iprot.readMessageEnd()
3431 rajveer 1631 
    if result.success is not None:
94 ashish 1632 
      return result.success
3431 rajveer 1633 
    if result.ex is not None:
94 ashish 1634 
      raise result.ex
1635 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1636 
 
1637 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1638 
    """
1639 
    Parameters:
1640 
     - customerId
1641 
     - from_date
1642 
     - to_date
1643 
     - status
1644 
    """
1645 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1646 
    return self.recv_getTransactionsForCustomer()
1647 
 
1648 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1649 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1650 
    args = getTransactionsForCustomer_args()
1651 
    args.customerId = customerId
1652 
    args.from_date = from_date
1653 
    args.to_date = to_date
1654 
    args.status = status
1655 
    args.write(self._oprot)
1656 
    self._oprot.writeMessageEnd()
1657 
    self._oprot.trans.flush()
1658 
 
1659 
  def recv_getTransactionsForCustomer(self, ):
1660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1661 
    if mtype == TMessageType.EXCEPTION:
1662 
      x = TApplicationException()
1663 
      x.read(self._iprot)
1664 
      self._iprot.readMessageEnd()
1665 
      raise x
1666 
    result = getTransactionsForCustomer_result()
1667 
    result.read(self._iprot)
1668 
    self._iprot.readMessageEnd()
3431 rajveer 1669 
    if result.success is not None:
94 ashish 1670 
      return result.success
3431 rajveer 1671 
    if result.ex is not None:
94 ashish 1672 
      raise result.ex
1673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1674 
 
132 ashish 1675 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1676 
    """
1677 
    Parameters:
1678 
     - shoppingCartId
1679 
    """
1680 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1681 
    return self.recv_getTransactionsForShoppingCartId()
1682 
 
1683 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1684 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1685 
    args = getTransactionsForShoppingCartId_args()
1686 
    args.shoppingCartId = shoppingCartId
1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
1691 
  def recv_getTransactionsForShoppingCartId(self, ):
1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
1698 
    result = getTransactionsForShoppingCartId_result()
1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
3431 rajveer 1701 
    if result.success is not None:
132 ashish 1702 
      return result.success
3431 rajveer 1703 
    if result.ex is not None:
132 ashish 1704 
      raise result.ex
1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1706 
 
94 ashish 1707 
  def getTransactionStatus(self, transactionId):
1708 
    """
1709 
    Parameters:
1710 
     - transactionId
1711 
    """
1712 
    self.send_getTransactionStatus(transactionId)
1713 
    return self.recv_getTransactionStatus()
1714 
 
1715 
  def send_getTransactionStatus(self, transactionId):
1716 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1717 
    args = getTransactionStatus_args()
1718 
    args.transactionId = transactionId
1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1723 
  def recv_getTransactionStatus(self, ):
1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1730 
    result = getTransactionStatus_result()
1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
3431 rajveer 1733 
    if result.success is not None:
94 ashish 1734 
      return result.success
3431 rajveer 1735 
    if result.ex is not None:
94 ashish 1736 
      raise result.ex
1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1738 
 
5527 anupam.sin 1739 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1740 
    """
1741 
    Parameters:
1742 
     - transactionId
1743 
     - status
1744 
     - description
5527 anupam.sin 1745 
     - pickUp
1746 
     - orderType
94 ashish 1747 
    """
5527 anupam.sin 1748 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1749 
    return self.recv_changeTransactionStatus()
1750 
 
5527 anupam.sin 1751 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1752 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1753 
    args = changeTransactionStatus_args()
1754 
    args.transactionId = transactionId
1755 
    args.status = status
1756 
    args.description = description
5527 anupam.sin 1757 
    args.pickUp = pickUp
1758 
    args.orderType = orderType
94 ashish 1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_changeTransactionStatus(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = changeTransactionStatus_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
3431 rajveer 1773 
    if result.success is not None:
94 ashish 1774 
      return result.success
3431 rajveer 1775 
    if result.ex is not None:
94 ashish 1776 
      raise result.ex
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1778 
 
1398 varun.gupt 1779 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1780 
    """
1781 
    Parameters:
1782 
     - transactionId
1783 
    """
1398 varun.gupt 1784 
    self.send_enqueueTransactionInfoEmail(transactionId)
1785 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1786 
 
1398 varun.gupt 1787 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1788 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1789 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1790 
    args.transactionId = transactionId
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1398 varun.gupt 1795 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1398 varun.gupt 1802 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
3431 rajveer 1805 
    if result.success is not None:
1382 varun.gupt 1806 
      return result.success
3431 rajveer 1807 
    if result.ex is not None:
1382 varun.gupt 1808 
      raise result.ex
1398 varun.gupt 1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1810 
 
4801 anupam.sin 1811 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1812 
    """
1813 
    Parameters:
4801 anupam.sin 1814 
     - statuses
483 rajveer 1815 
     - from_date
1816 
     - to_date
1817 
     - warehouse_id
94 ashish 1818 
    """
4801 anupam.sin 1819 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1820 
    return self.recv_getAllOrders()
94 ashish 1821 
 
4801 anupam.sin 1822 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1823 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1824 
    args = getAllOrders_args()
4801 anupam.sin 1825 
    args.statuses = statuses
483 rajveer 1826 
    args.from_date = from_date
1827 
    args.to_date = to_date
1828 
    args.warehouse_id = warehouse_id
94 ashish 1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
483 rajveer 1833 
  def recv_getAllOrders(self, ):
94 ashish 1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
483 rajveer 1840 
    result = getAllOrders_result()
94 ashish 1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
3431 rajveer 1843 
    if result.success is not None:
94 ashish 1844 
      return result.success
3431 rajveer 1845 
    if result.ex is not None:
94 ashish 1846 
      raise result.ex
483 rajveer 1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1848 
 
4133 chandransh 1849 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1850 
    """
1851 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1852 
    Pass the status as null and the limit as 0 to ignore them.
1853 
 
1854 
    Parameters:
1855 
     - statuses
1856 
     - offset
1857 
     - limit
1858 
     - warehouse_id
1859 
    """
1860 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1861 
    return self.recv_getOrdersInBatch()
1862 
 
1863 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1864 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1865 
    args = getOrdersInBatch_args()
1866 
    args.statuses = statuses
1867 
    args.offset = offset
1868 
    args.limit = limit
1869 
    args.warehouse_id = warehouse_id
1870 
    args.write(self._oprot)
1871 
    self._oprot.writeMessageEnd()
1872 
    self._oprot.trans.flush()
1873 
 
1874 
  def recv_getOrdersInBatch(self, ):
1875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1876 
    if mtype == TMessageType.EXCEPTION:
1877 
      x = TApplicationException()
1878 
      x.read(self._iprot)
1879 
      self._iprot.readMessageEnd()
1880 
      raise x
1881 
    result = getOrdersInBatch_result()
1882 
    result.read(self._iprot)
1883 
    self._iprot.readMessageEnd()
1884 
    if result.success is not None:
1885 
      return result.success
1886 
    if result.ex is not None:
1887 
      raise result.ex
1888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1889 
 
1890 
  def getOrderCount(self, statuses, warehouseId):
1891 
    """
1892 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1893 
 
1894 
    Parameters:
1895 
     - statuses
1896 
     - warehouseId
1897 
    """
1898 
    self.send_getOrderCount(statuses, warehouseId)
1899 
    return self.recv_getOrderCount()
1900 
 
1901 
  def send_getOrderCount(self, statuses, warehouseId):
1902 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1903 
    args = getOrderCount_args()
1904 
    args.statuses = statuses
1905 
    args.warehouseId = warehouseId
1906 
    args.write(self._oprot)
1907 
    self._oprot.writeMessageEnd()
1908 
    self._oprot.trans.flush()
1909 
 
1910 
  def recv_getOrderCount(self, ):
1911 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1912 
    if mtype == TMessageType.EXCEPTION:
1913 
      x = TApplicationException()
1914 
      x.read(self._iprot)
1915 
      self._iprot.readMessageEnd()
1916 
      raise x
1917 
    result = getOrderCount_result()
1918 
    result.read(self._iprot)
1919 
    self._iprot.readMessageEnd()
1920 
    if result.success is not None:
1921 
      return result.success
1922 
    if result.ex is not None:
1923 
      raise result.ex
1924 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1925 
 
999 varun.gupt 1926 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1927 
    """
1132 chandransh 1928 
    Returns orders within a range of their billing dates
3431 rajveer 1929 
 
999 varun.gupt 1930 
    Parameters:
1931 
     - status
1932 
     - start_billing_date
1933 
     - end_billing_date
1934 
     - warehouse_id
1935 
    """
1936 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1937 
    return self.recv_getOrdersByBillingDate()
1938 
 
1939 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1940 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1941 
    args = getOrdersByBillingDate_args()
1942 
    args.status = status
1943 
    args.start_billing_date = start_billing_date
1944 
    args.end_billing_date = end_billing_date
1945 
    args.warehouse_id = warehouse_id
1946 
    args.write(self._oprot)
1947 
    self._oprot.writeMessageEnd()
1948 
    self._oprot.trans.flush()
1949 
 
1950 
  def recv_getOrdersByBillingDate(self, ):
1951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1952 
    if mtype == TMessageType.EXCEPTION:
1953 
      x = TApplicationException()
1954 
      x.read(self._iprot)
1955 
      self._iprot.readMessageEnd()
1956 
      raise x
1957 
    result = getOrdersByBillingDate_result()
1958 
    result.read(self._iprot)
1959 
    self._iprot.readMessageEnd()
3431 rajveer 1960 
    if result.success is not None:
999 varun.gupt 1961 
      return result.success
3431 rajveer 1962 
    if result.ex is not None:
999 varun.gupt 1963 
      raise result.ex
1964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1965 
 
3451 chandransh 1966 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1967 
    """
1968 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1969 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1970 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1971 
 
3427 chandransh 1972 
    Parameters:
1973 
     - fromShippingDate
1974 
     - toShippingDate
1975 
     - providerId
1976 
     - warehouseId
3451 chandransh 1977 
     - cod
3427 chandransh 1978 
    """
3451 chandransh 1979 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1980 
    return self.recv_getOrdersByShippingDate()
1981 
 
3451 chandransh 1982 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1983 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1984 
    args = getOrdersByShippingDate_args()
1985 
    args.fromShippingDate = fromShippingDate
1986 
    args.toShippingDate = toShippingDate
1987 
    args.providerId = providerId
1988 
    args.warehouseId = warehouseId
3451 chandransh 1989 
    args.cod = cod
3427 chandransh 1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
1994 
  def recv_getOrdersByShippingDate(self, ):
1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
2001 
    result = getOrdersByShippingDate_result()
2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
3431 rajveer 2004 
    if result.success is not None:
3427 chandransh 2005 
      return result.success
3431 rajveer 2006 
    if result.ex is not None:
3427 chandransh 2007 
      raise result.ex
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2009 
 
1382 varun.gupt 2010 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2011 
    """
2012 
    Returns order ids for orders which can be returned
3431 rajveer 2013 
 
1382 varun.gupt 2014 
    Parameters:
2015 
     - customer_id
2016 
     - limit
2017 
    """
2018 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2019 
    return self.recv_getReturnableOrdersForCustomer()
2020 
 
2021 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2022 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2023 
    args = getReturnableOrdersForCustomer_args()
2024 
    args.customer_id = customer_id
2025 
    args.limit = limit
2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
2030 
  def recv_getReturnableOrdersForCustomer(self, ):
2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
2037 
    result = getReturnableOrdersForCustomer_result()
2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
3431 rajveer 2040 
    if result.success is not None:
1382 varun.gupt 2041 
      return result.success
3431 rajveer 2042 
    if result.ex is not None:
1382 varun.gupt 2043 
      raise result.ex
2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2045 
 
2046 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2047 
    """
2048 
    Returns order ids for orders which can be cancelled
3431 rajveer 2049 
 
1382 varun.gupt 2050 
    Parameters:
2051 
     - customer_id
2052 
     - limit
2053 
    """
2054 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2055 
    return self.recv_getCancellableOrdersForCustomer()
2056 
 
2057 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2058 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2059 
    args = getCancellableOrdersForCustomer_args()
2060 
    args.customer_id = customer_id
2061 
    args.limit = limit
2062 
    args.write(self._oprot)
2063 
    self._oprot.writeMessageEnd()
2064 
    self._oprot.trans.flush()
2065 
 
2066 
  def recv_getCancellableOrdersForCustomer(self, ):
2067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2068 
    if mtype == TMessageType.EXCEPTION:
2069 
      x = TApplicationException()
2070 
      x.read(self._iprot)
2071 
      self._iprot.readMessageEnd()
2072 
      raise x
2073 
    result = getCancellableOrdersForCustomer_result()
2074 
    result.read(self._iprot)
2075 
    self._iprot.readMessageEnd()
3431 rajveer 2076 
    if result.success is not None:
1382 varun.gupt 2077 
      return result.success
3431 rajveer 2078 
    if result.ex is not None:
1382 varun.gupt 2079 
      raise result.ex
2080 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2081 
 
483 rajveer 2082 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2083 
    """
2084 
    Parameters:
483 rajveer 2085 
     - orderId
2086 
     - status
2087 
     - description
94 ashish 2088 
    """
483 rajveer 2089 
    self.send_changeOrderStatus(orderId, status, description)
2090 
    return self.recv_changeOrderStatus()
94 ashish 2091 
 
483 rajveer 2092 
  def send_changeOrderStatus(self, orderId, status, description):
2093 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2094 
    args = changeOrderStatus_args()
2095 
    args.orderId = orderId
2096 
    args.status = status
2097 
    args.description = description
94 ashish 2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
483 rajveer 2102 
  def recv_changeOrderStatus(self, ):
94 ashish 2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
483 rajveer 2109 
    result = changeOrderStatus_result()
94 ashish 2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
3431 rajveer 2112 
    if result.success is not None:
94 ashish 2113 
      return result.success
3431 rajveer 2114 
    if result.ex is not None:
94 ashish 2115 
      raise result.ex
483 rajveer 2116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2117 
 
1528 ankur.sing 2118 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2119 
    """
1528 ankur.sing 2120 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2121 
    only user who owns the transaction can view its order details.
3431 rajveer 2122 
 
94 ashish 2123 
    Parameters:
2124 
     - transactionId
1528 ankur.sing 2125 
     - customerId
94 ashish 2126 
    """
1528 ankur.sing 2127 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2128 
    return self.recv_getOrdersForTransaction()
94 ashish 2129 
 
1528 ankur.sing 2130 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2131 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2132 
    args = getOrdersForTransaction_args()
94 ashish 2133 
    args.transactionId = transactionId
1528 ankur.sing 2134 
    args.customerId = customerId
94 ashish 2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
483 rajveer 2139 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
483 rajveer 2146 
    result = getOrdersForTransaction_result()
94 ashish 2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
3431 rajveer 2149 
    if result.success is not None:
94 ashish 2150 
      return result.success
3431 rajveer 2151 
    if result.ex is not None:
94 ashish 2152 
      raise result.ex
483 rajveer 2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2154 
 
3014 chandransh 2155 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2156 
    """
3014 chandransh 2157 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2158 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2159 
 
94 ashish 2160 
    Parameters:
483 rajveer 2161 
     - customerId
2162 
     - from_date
2163 
     - to_date
3014 chandransh 2164 
     - statuses
94 ashish 2165 
    """
3014 chandransh 2166 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2167 
    return self.recv_getOrdersForCustomer()
94 ashish 2168 
 
3014 chandransh 2169 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2170 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2171 
    args = getOrdersForCustomer_args()
2172 
    args.customerId = customerId
2173 
    args.from_date = from_date
2174 
    args.to_date = to_date
3014 chandransh 2175 
    args.statuses = statuses
94 ashish 2176 
    args.write(self._oprot)
2177 
    self._oprot.writeMessageEnd()
2178 
    self._oprot.trans.flush()
2179 
 
483 rajveer 2180 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2181 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2182 
    if mtype == TMessageType.EXCEPTION:
2183 
      x = TApplicationException()
2184 
      x.read(self._iprot)
2185 
      self._iprot.readMessageEnd()
2186 
      raise x
483 rajveer 2187 
    result = getOrdersForCustomer_result()
94 ashish 2188 
    result.read(self._iprot)
2189 
    self._iprot.readMessageEnd()
3431 rajveer 2190 
    if result.success is not None:
94 ashish 2191 
      return result.success
3431 rajveer 2192 
    if result.ex is not None:
94 ashish 2193 
      raise result.ex
483 rajveer 2194 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2195 
 
483 rajveer 2196 
  def createOrder(self, order):
94 ashish 2197 
    """
2198 
    Parameters:
483 rajveer 2199 
     - order
94 ashish 2200 
    """
483 rajveer 2201 
    self.send_createOrder(order)
2202 
    return self.recv_createOrder()
94 ashish 2203 
 
483 rajveer 2204 
  def send_createOrder(self, order):
2205 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2206 
    args = createOrder_args()
2207 
    args.order = order
94 ashish 2208 
    args.write(self._oprot)
2209 
    self._oprot.writeMessageEnd()
2210 
    self._oprot.trans.flush()
2211 
 
483 rajveer 2212 
  def recv_createOrder(self, ):
94 ashish 2213 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2214 
    if mtype == TMessageType.EXCEPTION:
2215 
      x = TApplicationException()
2216 
      x.read(self._iprot)
2217 
      self._iprot.readMessageEnd()
2218 
      raise x
483 rajveer 2219 
    result = createOrder_result()
94 ashish 2220 
    result.read(self._iprot)
2221 
    self._iprot.readMessageEnd()
3431 rajveer 2222 
    if result.success is not None:
94 ashish 2223 
      return result.success
3431 rajveer 2224 
    if result.ex is not None:
94 ashish 2225 
      raise result.ex
483 rajveer 2226 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2227 
 
483 rajveer 2228 
  def getOrder(self, id):
94 ashish 2229 
    """
2230 
    Parameters:
483 rajveer 2231 
     - id
94 ashish 2232 
    """
483 rajveer 2233 
    self.send_getOrder(id)
2234 
    return self.recv_getOrder()
94 ashish 2235 
 
483 rajveer 2236 
  def send_getOrder(self, id):
2237 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2238 
    args = getOrder_args()
2239 
    args.id = id
94 ashish 2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
483 rajveer 2244 
  def recv_getOrder(self, ):
94 ashish 2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
483 rajveer 2251 
    result = getOrder_result()
94 ashish 2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
3431 rajveer 2254 
    if result.success is not None:
94 ashish 2255 
      return result.success
3431 rajveer 2256 
    if result.ex is not None:
94 ashish 2257 
      raise result.ex
483 rajveer 2258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2259 
 
483 rajveer 2260 
  def getLineItemsForOrder(self, orderId):
94 ashish 2261 
    """
2262 
    Parameters:
483 rajveer 2263 
     - orderId
94 ashish 2264 
    """
483 rajveer 2265 
    self.send_getLineItemsForOrder(orderId)
2266 
    return self.recv_getLineItemsForOrder()
94 ashish 2267 
 
483 rajveer 2268 
  def send_getLineItemsForOrder(self, orderId):
2269 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2270 
    args = getLineItemsForOrder_args()
2271 
    args.orderId = orderId
94 ashish 2272 
    args.write(self._oprot)
2273 
    self._oprot.writeMessageEnd()
2274 
    self._oprot.trans.flush()
2275 
 
483 rajveer 2276 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2278 
    if mtype == TMessageType.EXCEPTION:
2279 
      x = TApplicationException()
2280 
      x.read(self._iprot)
2281 
      self._iprot.readMessageEnd()
2282 
      raise x
483 rajveer 2283 
    result = getLineItemsForOrder_result()
94 ashish 2284 
    result.read(self._iprot)
2285 
    self._iprot.readMessageEnd()
3431 rajveer 2286 
    if result.success is not None:
94 ashish 2287 
      return result.success
3431 rajveer 2288 
    if result.ex is not None:
94 ashish 2289 
      raise result.ex
483 rajveer 2290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2291 
 
4999 phani.kuma 2292 
  def getOrderList(self, order_ids):
2293 
    """
2294 
    Parameters:
2295 
     - order_ids
2296 
    """
2297 
    self.send_getOrderList(order_ids)
2298 
    return self.recv_getOrderList()
2299 
 
2300 
  def send_getOrderList(self, order_ids):
2301 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2302 
    args = getOrderList_args()
2303 
    args.order_ids = order_ids
2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_getOrderList(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = getOrderList_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
2318 
    if result.success is not None:
2319 
      return result.success
2320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2321 
 
5386 phani.kuma 2322 
  def getOrderListForVendor(self, order_ids, vendorId):
2323 
    """
2324 
    Parameters:
2325 
     - order_ids
2326 
     - vendorId
2327 
    """
2328 
    self.send_getOrderListForVendor(order_ids, vendorId)
2329 
    return self.recv_getOrderListForVendor()
2330 
 
2331 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2332 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2333 
    args = getOrderListForVendor_args()
2334 
    args.order_ids = order_ids
2335 
    args.vendorId = vendorId
2336 
    args.write(self._oprot)
2337 
    self._oprot.writeMessageEnd()
2338 
    self._oprot.trans.flush()
2339 
 
2340 
  def recv_getOrderListForVendor(self, ):
2341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2342 
    if mtype == TMessageType.EXCEPTION:
2343 
      x = TApplicationException()
2344 
      x.read(self._iprot)
2345 
      self._iprot.readMessageEnd()
2346 
      raise x
2347 
    result = getOrderListForVendor_result()
2348 
    result.read(self._iprot)
2349 
    self._iprot.readMessageEnd()
2350 
    if result.success is not None:
2351 
      return result.success
2352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2353 
 
1528 ankur.sing 2354 
  def getOrderForCustomer(self, orderId, customerId):
2355 
    """
2356 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2357 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2358 
 
1528 ankur.sing 2359 
    Parameters:
2360 
     - orderId
2361 
     - customerId
2362 
    """
2363 
    self.send_getOrderForCustomer(orderId, customerId)
2364 
    return self.recv_getOrderForCustomer()
2365 
 
2366 
  def send_getOrderForCustomer(self, orderId, customerId):
2367 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2368 
    args = getOrderForCustomer_args()
2369 
    args.orderId = orderId
2370 
    args.customerId = customerId
2371 
    args.write(self._oprot)
2372 
    self._oprot.writeMessageEnd()
2373 
    self._oprot.trans.flush()
2374 
 
2375 
  def recv_getOrderForCustomer(self, ):
2376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2377 
    if mtype == TMessageType.EXCEPTION:
2378 
      x = TApplicationException()
2379 
      x.read(self._iprot)
2380 
      self._iprot.readMessageEnd()
2381 
      raise x
2382 
    result = getOrderForCustomer_result()
2383 
    result.read(self._iprot)
2384 
    self._iprot.readMessageEnd()
3431 rajveer 2385 
    if result.success is not None:
1528 ankur.sing 2386 
      return result.success
3431 rajveer 2387 
    if result.ex is not None:
1528 ankur.sing 2388 
      raise result.ex
2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2390 
 
4444 rajveer 2391 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2392 
    """
2393 
    Parameters:
4394 rajveer 2394 
     - type
4444 rajveer 2395 
     - warehouseId
4394 rajveer 2396 
     - status
2397 
     - timestamp
3064 chandransh 2398 
    """
4444 rajveer 2399 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2400 
    return self.recv_getAlerts()
2401 
 
4444 rajveer 2402 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2403 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2404 
    args = getAlerts_args()
4394 rajveer 2405 
    args.type = type
4444 rajveer 2406 
    args.warehouseId = warehouseId
4394 rajveer 2407 
    args.status = status
2408 
    args.timestamp = timestamp
3064 chandransh 2409 
    args.write(self._oprot)
2410 
    self._oprot.writeMessageEnd()
2411 
    self._oprot.trans.flush()
2412 
 
2413 
  def recv_getAlerts(self, ):
2414 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2415 
    if mtype == TMessageType.EXCEPTION:
2416 
      x = TApplicationException()
2417 
      x.read(self._iprot)
2418 
      self._iprot.readMessageEnd()
2419 
      raise x
2420 
    result = getAlerts_result()
2421 
    result.read(self._iprot)
2422 
    self._iprot.readMessageEnd()
3431 rajveer 2423 
    if result.success is not None:
3064 chandransh 2424 
      return result.success
2425 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2426 
 
4444 rajveer 2427 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2428 
    """
2429 
    Parameters:
2430 
     - type
4444 rajveer 2431 
     - warehouseId
4394 rajveer 2432 
     - description
3064 chandransh 2433 
    """
4444 rajveer 2434 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2435 
    self.recv_addAlert()
3064 chandransh 2436 
 
4444 rajveer 2437 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2438 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2439 
    args = addAlert_args()
3064 chandransh 2440 
    args.type = type
4444 rajveer 2441 
    args.warehouseId = warehouseId
4394 rajveer 2442 
    args.description = description
3064 chandransh 2443 
    args.write(self._oprot)
2444 
    self._oprot.writeMessageEnd()
2445 
    self._oprot.trans.flush()
2446 
 
4394 rajveer 2447 
  def recv_addAlert(self, ):
3064 chandransh 2448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2449 
    if mtype == TMessageType.EXCEPTION:
2450 
      x = TApplicationException()
2451 
      x.read(self._iprot)
2452 
      self._iprot.readMessageEnd()
2453 
      raise x
4394 rajveer 2454 
    result = addAlert_result()
3064 chandransh 2455 
    result.read(self._iprot)
2456 
    self._iprot.readMessageEnd()
2457 
    return
2458 
 
4444 rajveer 2459 
  def markAlertsAsSeen(self, warehouseId):
2460 
    """
2461 
    Parameters:
2462 
     - warehouseId
2463 
    """
2464 
    self.send_markAlertsAsSeen(warehouseId)
2465 
    self.recv_markAlertsAsSeen()
2466 
 
2467 
  def send_markAlertsAsSeen(self, warehouseId):
2468 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2469 
    args = markAlertsAsSeen_args()
2470 
    args.warehouseId = warehouseId
2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
2475 
  def recv_markAlertsAsSeen(self, ):
2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
2482 
    result = markAlertsAsSeen_result()
2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
2485 
    return
2486 
 
3064 chandransh 2487 
  def getValidOrderCount(self, ):
2488 
    """
2489 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2490 
    """
2491 
    self.send_getValidOrderCount()
2492 
    return self.recv_getValidOrderCount()
2493 
 
2494 
  def send_getValidOrderCount(self, ):
2495 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2496 
    args = getValidOrderCount_args()
2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
2501 
  def recv_getValidOrderCount(self, ):
2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
2508 
    result = getValidOrderCount_result()
2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
3431 rajveer 2511 
    if result.success is not None:
3064 chandransh 2512 
      return result.success
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2514 
 
2515 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2516 
    """
2517 
    Returns the number of distinct customers who have done successful transactions
2518 
    """
2519 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2520 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2521 
 
2522 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2523 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2524 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2525 
    args.write(self._oprot)
2526 
    self._oprot.writeMessageEnd()
2527 
    self._oprot.trans.flush()
2528 
 
2529 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2531 
    if mtype == TMessageType.EXCEPTION:
2532 
      x = TApplicationException()
2533 
      x.read(self._iprot)
2534 
      self._iprot.readMessageEnd()
2535 
      raise x
2536 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2537 
    result.read(self._iprot)
2538 
    self._iprot.readMessageEnd()
3431 rajveer 2539 
    if result.success is not None:
3064 chandransh 2540 
      return result.success
2541 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2542 
 
2543 
  def getValidOrdersAmountRange(self, ):
2544 
    """
2545 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2546 
    List contains two values, first minimum amount and second maximum amount.
2547 
    """
2548 
    self.send_getValidOrdersAmountRange()
2549 
    return self.recv_getValidOrdersAmountRange()
2550 
 
2551 
  def send_getValidOrdersAmountRange(self, ):
2552 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2553 
    args = getValidOrdersAmountRange_args()
2554 
    args.write(self._oprot)
2555 
    self._oprot.writeMessageEnd()
2556 
    self._oprot.trans.flush()
2557 
 
2558 
  def recv_getValidOrdersAmountRange(self, ):
2559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2560 
    if mtype == TMessageType.EXCEPTION:
2561 
      x = TApplicationException()
2562 
      x.read(self._iprot)
2563 
      self._iprot.readMessageEnd()
2564 
      raise x
2565 
    result = getValidOrdersAmountRange_result()
2566 
    result.read(self._iprot)
2567 
    self._iprot.readMessageEnd()
3431 rajveer 2568 
    if result.success is not None:
3064 chandransh 2569 
      return result.success
2570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2571 
 
5874 rajveer 2572 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2573 
    """
2574 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2575 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2576 
 
3064 chandransh 2577 
    Parameters:
2578 
     - limit
5874 rajveer 2579 
     - onlyStore
3064 chandransh 2580 
    """
5874 rajveer 2581 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2582 
    return self.recv_getValidOrders()
2583 
 
5874 rajveer 2584 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2585 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2586 
    args = getValidOrders_args()
2587 
    args.limit = limit
5874 rajveer 2588 
    args.onlyStore = onlyStore
3064 chandransh 2589 
    args.write(self._oprot)
2590 
    self._oprot.writeMessageEnd()
2591 
    self._oprot.trans.flush()
2592 
 
2593 
  def recv_getValidOrders(self, ):
2594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2595 
    if mtype == TMessageType.EXCEPTION:
2596 
      x = TApplicationException()
2597 
      x.read(self._iprot)
2598 
      self._iprot.readMessageEnd()
2599 
      raise x
2600 
    result = getValidOrders_result()
2601 
    result.read(self._iprot)
2602 
    self._iprot.readMessageEnd()
3431 rajveer 2603 
    if result.success is not None:
3064 chandransh 2604 
      return result.success
2605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2606 
 
1220 chandransh 2607 
  def batchOrders(self, warehouseId):
2608 
    """
2609 
    Create a batch of all the pending orders for the given warehouse.
2610 
    The returned list is orderd by created_timestamp.
2611 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2612 
 
1220 chandransh 2613 
    Parameters:
2614 
     - warehouseId
2615 
    """
2616 
    self.send_batchOrders(warehouseId)
2617 
    return self.recv_batchOrders()
2618 
 
2619 
  def send_batchOrders(self, warehouseId):
2620 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2621 
    args = batchOrders_args()
2622 
    args.warehouseId = warehouseId
2623 
    args.write(self._oprot)
2624 
    self._oprot.writeMessageEnd()
2625 
    self._oprot.trans.flush()
2626 
 
2627 
  def recv_batchOrders(self, ):
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
2634 
    result = batchOrders_result()
2635 
    result.read(self._iprot)
2636 
    self._iprot.readMessageEnd()
3431 rajveer 2637 
    if result.success is not None:
1220 chandransh 2638 
      return result.success
3431 rajveer 2639 
    if result.ex is not None:
1220 chandransh 2640 
      raise result.ex
2641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2642 
 
1208 chandransh 2643 
  def markOrderAsOutOfStock(self, orderId):
2644 
    """
2645 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2646 
 
1208 chandransh 2647 
    Parameters:
2648 
     - orderId
2649 
    """
2650 
    self.send_markOrderAsOutOfStock(orderId)
2651 
    return self.recv_markOrderAsOutOfStock()
2652 
 
2653 
  def send_markOrderAsOutOfStock(self, orderId):
2654 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2655 
    args = markOrderAsOutOfStock_args()
2656 
    args.orderId = orderId
2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
2661 
  def recv_markOrderAsOutOfStock(self, ):
2662 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2663 
    if mtype == TMessageType.EXCEPTION:
2664 
      x = TApplicationException()
2665 
      x.read(self._iprot)
2666 
      self._iprot.readMessageEnd()
2667 
      raise x
2668 
    result = markOrderAsOutOfStock_result()
2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
3431 rajveer 2671 
    if result.success is not None:
1208 chandransh 2672 
      return result.success
3431 rajveer 2673 
    if result.ex is not None:
1208 chandransh 2674 
      raise result.ex
2675 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2676 
 
3064 chandransh 2677 
  def verifyOrder(self, orderId):
759 chandransh 2678 
    """
3064 chandransh 2679 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2680 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2681 
    used for all other orders as well.
2682 
    Throws an exception if no such order exists.
3431 rajveer 2683 
 
759 chandransh 2684 
    Parameters:
3064 chandransh 2685 
     - orderId
759 chandransh 2686 
    """
3064 chandransh 2687 
    self.send_verifyOrder(orderId)
2688 
    return self.recv_verifyOrder()
759 chandransh 2689 
 
3064 chandransh 2690 
  def send_verifyOrder(self, orderId):
2691 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2692 
    args = verifyOrder_args()
2693 
    args.orderId = orderId
759 chandransh 2694 
    args.write(self._oprot)
2695 
    self._oprot.writeMessageEnd()
2696 
    self._oprot.trans.flush()
2697 
 
3064 chandransh 2698 
  def recv_verifyOrder(self, ):
759 chandransh 2699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2700 
    if mtype == TMessageType.EXCEPTION:
2701 
      x = TApplicationException()
2702 
      x.read(self._iprot)
2703 
      self._iprot.readMessageEnd()
2704 
      raise x
3064 chandransh 2705 
    result = verifyOrder_result()
759 chandransh 2706 
    result.read(self._iprot)
2707 
    self._iprot.readMessageEnd()
3431 rajveer 2708 
    if result.success is not None:
759 chandransh 2709 
      return result.success
3431 rajveer 2710 
    if result.ex is not None:
759 chandransh 2711 
      raise result.ex
3064 chandransh 2712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2713 
 
3064 chandransh 2714 
  def acceptOrder(self, orderId):
1113 chandransh 2715 
    """
3064 chandransh 2716 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2717 
    given order is not a COD order, it also captures the payment if the same has
2718 
    not been captured.
2719 
    Throws an exception if no such order exists.
3431 rajveer 2720 
 
1113 chandransh 2721 
    Parameters:
3064 chandransh 2722 
     - orderId
1113 chandransh 2723 
    """
3064 chandransh 2724 
    self.send_acceptOrder(orderId)
2725 
    return self.recv_acceptOrder()
1113 chandransh 2726 
 
3064 chandransh 2727 
  def send_acceptOrder(self, orderId):
2728 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2729 
    args = acceptOrder_args()
2730 
    args.orderId = orderId
1113 chandransh 2731 
    args.write(self._oprot)
2732 
    self._oprot.writeMessageEnd()
2733 
    self._oprot.trans.flush()
2734 
 
3064 chandransh 2735 
  def recv_acceptOrder(self, ):
1113 chandransh 2736 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2737 
    if mtype == TMessageType.EXCEPTION:
2738 
      x = TApplicationException()
2739 
      x.read(self._iprot)
2740 
      self._iprot.readMessageEnd()
2741 
      raise x
3064 chandransh 2742 
    result = acceptOrder_result()
1113 chandransh 2743 
    result.read(self._iprot)
2744 
    self._iprot.readMessageEnd()
3431 rajveer 2745 
    if result.success is not None:
1113 chandransh 2746 
      return result.success
3431 rajveer 2747 
    if result.ex is not None:
1113 chandransh 2748 
      raise result.ex
3064 chandransh 2749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2750 
 
5110 mandeep.dh 2751 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2752 
    """
3064 chandransh 2753 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2754 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2755 
    the IMEI no. if a -1 is supplied.
2756 
    Also, it generates an invoice number for the order, marks the order as
2757 
    BILLED and sets the billing timestamp.
2758 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2759 
 
1135 chandransh 2760 
    Parameters:
3064 chandransh 2761 
     - orderId
2762 
     - invoice_number
4658 mandeep.dh 2763 
     - serialNumber
4283 anupam.sin 2764 
     - itemNumber
3064 chandransh 2765 
     - billed_by
4264 rajveer 2766 
     - jacketNumber
4283 anupam.sin 2767 
     - billingType
5110 mandeep.dh 2768 
     - fulfilmentWarehouseId
4763 rajveer 2769 
     - authorize
1135 chandransh 2770 
    """
5110 mandeep.dh 2771 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2772 
    return self.recv_addBillingDetails()
1135 chandransh 2773 
 
5110 mandeep.dh 2774 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2775 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2776 
    args = addBillingDetails_args()
2777 
    args.orderId = orderId
2778 
    args.invoice_number = invoice_number
4658 mandeep.dh 2779 
    args.serialNumber = serialNumber
4283 anupam.sin 2780 
    args.itemNumber = itemNumber
3064 chandransh 2781 
    args.billed_by = billed_by
4264 rajveer 2782 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2783 
    args.billingType = billingType
5110 mandeep.dh 2784 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2785 
    args.authorize = authorize
1135 chandransh 2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
3064 chandransh 2790 
  def recv_addBillingDetails(self, ):
1135 chandransh 2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
3064 chandransh 2797 
    result = addBillingDetails_result()
1135 chandransh 2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
3431 rajveer 2800 
    if result.success is not None:
3064 chandransh 2801 
      return result.success
3431 rajveer 2802 
    if result.ex is not None:
1135 chandransh 2803 
      raise result.ex
3064 chandransh 2804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2805 
 
6756 amar.kumar 2806 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2807 
    """
2808 
    Add the invoice number to the order.
2809 
 
2810 
    Parameters:
2811 
     - orderId
2812 
     - invoiceNumber
4763 rajveer 2813 
     - color
6756 amar.kumar 2814 
     - serialNumber
2815 
     - itemNumber
4579 rajveer 2816 
    """
6756 amar.kumar 2817 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2818 
    self.recv_addInvoiceNumber()
2819 
 
6756 amar.kumar 2820 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2821 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2822 
    args = addInvoiceNumber_args()
2823 
    args.orderId = orderId
2824 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2825 
    args.color = color
6756 amar.kumar 2826 
    args.serialNumber = serialNumber
2827 
    args.itemNumber = itemNumber
4579 rajveer 2828 
    args.write(self._oprot)
2829 
    self._oprot.writeMessageEnd()
2830 
    self._oprot.trans.flush()
2831 
 
2832 
  def recv_addInvoiceNumber(self, ):
2833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2834 
    if mtype == TMessageType.EXCEPTION:
2835 
      x = TApplicationException()
2836 
      x.read(self._iprot)
2837 
      self._iprot.readMessageEnd()
2838 
      raise x
2839 
    result = addInvoiceNumber_result()
2840 
    result.read(self._iprot)
2841 
    self._iprot.readMessageEnd()
2842 
    if result.ex is not None:
2843 
      raise result.ex
2844 
    return
2845 
 
4910 phani.kuma 2846 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2847 
    """
3064 chandransh 2848 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2849 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2850 
 
1408 ankur.sing 2851 
    Parameters:
3064 chandransh 2852 
     - warehouseId
1408 ankur.sing 2853 
     - providerId
3064 chandransh 2854 
     - cod
4910 phani.kuma 2855 
     - orderIds
1408 ankur.sing 2856 
    """
4910 phani.kuma 2857 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2858 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2859 
 
4910 phani.kuma 2860 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2861 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2862 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2863 
    args.warehouseId = warehouseId
1408 ankur.sing 2864 
    args.providerId = providerId
3064 chandransh 2865 
    args.cod = cod
4910 phani.kuma 2866 
    args.orderIds = orderIds
1408 ankur.sing 2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
4910 phani.kuma 2871 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
4910 phani.kuma 2878 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
3431 rajveer 2881 
    if result.success is not None:
1408 ankur.sing 2882 
      return result.success
3431 rajveer 2883 
    if result.ex is not None:
3064 chandransh 2884 
      raise result.ex
4910 phani.kuma 2885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2886 
 
5713 rajveer 2887 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2888 
    """
2889 
    Parameters:
2890 
     - providerId
2891 
     - orderIds
5713 rajveer 2892 
     - awbs
5676 rajveer 2893 
    """
5713 rajveer 2894 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2895 
    return self.recv_markOrdersAsReturnedFromStore()
2896 
 
5713 rajveer 2897 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2898 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2899 
    args = markOrdersAsReturnedFromStore_args()
2900 
    args.providerId = providerId
2901 
    args.orderIds = orderIds
5713 rajveer 2902 
    args.awbs = awbs
5676 rajveer 2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
2907 
  def recv_markOrdersAsReturnedFromStore(self, ):
2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
2914 
    result = markOrdersAsReturnedFromStore_result()
2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
2917 
    if result.success is not None:
2918 
      return result.success
2919 
    if result.ex is not None:
2920 
      raise result.ex
2921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2922 
 
4910 phani.kuma 2923 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2924 
    """
4910 phani.kuma 2925 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2926 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2927 
 
2928 
    Parameters:
2929 
     - providerId
4910 phani.kuma 2930 
     - pickupDetails
4410 rajveer 2931 
    """
4910 phani.kuma 2932 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2933 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2934 
 
4910 phani.kuma 2935 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2936 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2937 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2938 
    args.providerId = providerId
4910 phani.kuma 2939 
    args.pickupDetails = pickupDetails
4410 rajveer 2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
4910 phani.kuma 2944 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
4910 phani.kuma 2951 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.ex is not None:
2955 
      raise result.ex
4910 phani.kuma 2956 
    return
4410 rajveer 2957 
 
4910 phani.kuma 2958 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2959 
    """
3064 chandransh 2960 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2961 
 
94 ashish 2962 
    Parameters:
3064 chandransh 2963 
     - providerId
304 ashish 2964 
    """
4910 phani.kuma 2965 
    self.send_getOrdersNotPickedUp(providerId)
2966 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2967 
 
4910 phani.kuma 2968 
  def send_getOrdersNotPickedUp(self, providerId):
2969 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2970 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2971 
    args.providerId = providerId
304 ashish 2972 
    args.write(self._oprot)
2973 
    self._oprot.writeMessageEnd()
2974 
    self._oprot.trans.flush()
2975 
 
4910 phani.kuma 2976 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 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 = getOrdersNotPickedUp_result()
304 ashish 2984 
    result.read(self._iprot)
2985 
    self._iprot.readMessageEnd()
3431 rajveer 2986 
    if result.success is not None:
304 ashish 2987 
      return result.success
4910 phani.kuma 2988 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2989 
 
3064 chandransh 2990 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2991 
    """
3064 chandransh 2992 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2993 
    the name of the receiver.
2994 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2995 
 
304 ashish 2996 
    Parameters:
3064 chandransh 2997 
     - providerId
2998 
     - deliveredOrders
304 ashish 2999 
    """
3064 chandransh 3000 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3001 
    self.recv_markOrdersAsDelivered()
304 ashish 3002 
 
3064 chandransh 3003 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3004 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3005 
    args = markOrdersAsDelivered_args()
3006 
    args.providerId = providerId
3007 
    args.deliveredOrders = deliveredOrders
304 ashish 3008 
    args.write(self._oprot)
3009 
    self._oprot.writeMessageEnd()
3010 
    self._oprot.trans.flush()
3011 
 
3064 chandransh 3012 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3014 
    if mtype == TMessageType.EXCEPTION:
3015 
      x = TApplicationException()
3016 
      x.read(self._iprot)
3017 
      self._iprot.readMessageEnd()
3018 
      raise x
3064 chandransh 3019 
    result = markOrdersAsDelivered_result()
304 ashish 3020 
    result.read(self._iprot)
3021 
    self._iprot.readMessageEnd()
3431 rajveer 3022 
    if result.ex is not None:
3064 chandransh 3023 
      raise result.ex
304 ashish 3024 
    return
3025 
 
4910 phani.kuma 3026 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3027 
    """
4910 phani.kuma 3028 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3029 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3030 
 
3064 chandransh 3031 
    Parameters:
3032 
     - providerId
3033 
     - returnedOrders
1596 ankur.sing 3034 
    """
4910 phani.kuma 3035 
    self.send_markAsRTOrders(providerId, returnedOrders)
3036 
    self.recv_markAsRTOrders()
304 ashish 3037 
 
4910 phani.kuma 3038 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3039 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3040 
    args = markAsRTOrders_args()
3064 chandransh 3041 
    args.providerId = providerId
3042 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3043 
    args.write(self._oprot)
3044 
    self._oprot.writeMessageEnd()
3045 
    self._oprot.trans.flush()
3046 
 
4910 phani.kuma 3047 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3049 
    if mtype == TMessageType.EXCEPTION:
3050 
      x = TApplicationException()
3051 
      x.read(self._iprot)
3052 
      self._iprot.readMessageEnd()
3053 
      raise x
4910 phani.kuma 3054 
    result = markAsRTOrders_result()
1596 ankur.sing 3055 
    result.read(self._iprot)
3056 
    self._iprot.readMessageEnd()
3431 rajveer 3057 
    if result.ex is not None:
3064 chandransh 3058 
      raise result.ex
3059 
    return
1596 ankur.sing 3060 
 
4910 phani.kuma 3061 
  def getRTOrders(self, providerId):
3062 
    """
3063 
    Returns a list of orders that were returned by courier.
3064 
 
3065 
    Parameters:
3066 
     - providerId
3067 
    """
3068 
    self.send_getRTOrders(providerId)
3069 
    return self.recv_getRTOrders()
3070 
 
3071 
  def send_getRTOrders(self, providerId):
3072 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3073 
    args = getRTOrders_args()
3074 
    args.providerId = providerId
3075 
    args.write(self._oprot)
3076 
    self._oprot.writeMessageEnd()
3077 
    self._oprot.trans.flush()
3078 
 
3079 
  def recv_getRTOrders(self, ):
3080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3081 
    if mtype == TMessageType.EXCEPTION:
3082 
      x = TApplicationException()
3083 
      x.read(self._iprot)
3084 
      self._iprot.readMessageEnd()
3085 
      raise x
3086 
    result = getRTOrders_result()
3087 
    result.read(self._iprot)
3088 
    self._iprot.readMessageEnd()
3089 
    if result.success is not None:
3090 
      return result.success
3091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3092 
 
3064 chandransh 3093 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3094 
    """
3064 chandransh 3095 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3096 
 
3064 chandransh 3097 
    Parameters:
3098 
     - providerId
3099 
     - undeliveredOrders
1627 ankur.sing 3100 
    """
3064 chandransh 3101 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3102 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3103 
 
3064 chandransh 3104 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3105 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3106 
    args = updateNonDeliveryReason_args()
3107 
    args.providerId = providerId
3108 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3109 
    args.write(self._oprot)
3110 
    self._oprot.writeMessageEnd()
3111 
    self._oprot.trans.flush()
3112 
 
3064 chandransh 3113 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3115 
    if mtype == TMessageType.EXCEPTION:
3116 
      x = TApplicationException()
3117 
      x.read(self._iprot)
3118 
      self._iprot.readMessageEnd()
3119 
      raise x
3064 chandransh 3120 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3121 
    result.read(self._iprot)
3122 
    self._iprot.readMessageEnd()
4910 phani.kuma 3123 
    if result.ex is not None:
3124 
      raise result.ex
3125 
    return
3126 
 
3127 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3128 
    """
3129 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3130 
 
3131 
    Parameters:
3132 
     - providerId
3133 
    """
3134 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3135 
    return self.recv_getNonDeliveredOrdersbyCourier()
3136 
 
3137 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3138 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3139 
    args = getNonDeliveredOrdersbyCourier_args()
3140 
    args.providerId = providerId
3141 
    args.write(self._oprot)
3142 
    self._oprot.writeMessageEnd()
3143 
    self._oprot.trans.flush()
3144 
 
3145 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3147 
    if mtype == TMessageType.EXCEPTION:
3148 
      x = TApplicationException()
3149 
      x.read(self._iprot)
3150 
      self._iprot.readMessageEnd()
3151 
      raise x
3152 
    result = getNonDeliveredOrdersbyCourier_result()
3153 
    result.read(self._iprot)
3154 
    self._iprot.readMessageEnd()
4581 phani.kuma 3155 
    if result.success is not None:
3156 
      return result.success
4910 phani.kuma 3157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3158 
 
3159 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3160 
    """
3161 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3162 
 
3163 
    Parameters:
3164 
     - providerId
3165 
     - local_connected_orders
3166 
    """
3167 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3168 
    self.recv_markOrdersAsLocalConnected()
3169 
 
3170 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3171 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3172 
    args = markOrdersAsLocalConnected_args()
3173 
    args.providerId = providerId
3174 
    args.local_connected_orders = local_connected_orders
3175 
    args.write(self._oprot)
3176 
    self._oprot.writeMessageEnd()
3177 
    self._oprot.trans.flush()
3178 
 
3179 
  def recv_markOrdersAsLocalConnected(self, ):
3180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3181 
    if mtype == TMessageType.EXCEPTION:
3182 
      x = TApplicationException()
3183 
      x.read(self._iprot)
3184 
      self._iprot.readMessageEnd()
3185 
      raise x
3186 
    result = markOrdersAsLocalConnected_result()
3187 
    result.read(self._iprot)
3188 
    self._iprot.readMessageEnd()
3431 rajveer 3189 
    if result.ex is not None:
3064 chandransh 3190 
      raise result.ex
4910 phani.kuma 3191 
    return
1627 ankur.sing 3192 
 
4910 phani.kuma 3193 
  def getOrdersNotLocalConnected(self, providerId):
3194 
    """
3195 
    Returns a list of orders that were picked up or shipped but pending local connection.
3196 
 
3197 
    Parameters:
3198 
     - providerId
3199 
    """
3200 
    self.send_getOrdersNotLocalConnected(providerId)
3201 
    return self.recv_getOrdersNotLocalConnected()
3202 
 
3203 
  def send_getOrdersNotLocalConnected(self, providerId):
3204 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3205 
    args = getOrdersNotLocalConnected_args()
3206 
    args.providerId = providerId
3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_getOrdersNotLocalConnected(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = getOrdersNotLocalConnected_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.success is not None:
3222 
      return result.success
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3224 
 
3225 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3226 
    """
3227 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3228 
 
3229 
    Parameters:
3230 
     - providerId
3231 
     - destination_city_reached_orders
3232 
    """
3233 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3234 
    self.recv_markOrdersAsDestinationCityReached()
3235 
 
3236 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3237 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3238 
    args = markOrdersAsDestinationCityReached_args()
3239 
    args.providerId = providerId
3240 
    args.destination_city_reached_orders = destination_city_reached_orders
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_markOrdersAsDestinationCityReached(self, ):
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
3252 
    result = markOrdersAsDestinationCityReached_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3255 
    if result.ex is not None:
3256 
      raise result.ex
3257 
    return
3258 
 
3259 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3260 
    """
3261 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3262 
 
3263 
    Parameters:
3264 
     - providerId
3265 
     - first_atdl_orders
3266 
    """
3267 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3268 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3269 
 
3270 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3271 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3272 
    args = markOrdersAsFirstDeliveryAttempted_args()
3273 
    args.providerId = providerId
3274 
    args.first_atdl_orders = first_atdl_orders
3275 
    args.write(self._oprot)
3276 
    self._oprot.writeMessageEnd()
3277 
    self._oprot.trans.flush()
3278 
 
3279 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3281 
    if mtype == TMessageType.EXCEPTION:
3282 
      x = TApplicationException()
3283 
      x.read(self._iprot)
3284 
      self._iprot.readMessageEnd()
3285 
      raise x
3286 
    result = markOrdersAsFirstDeliveryAttempted_result()
3287 
    result.read(self._iprot)
3288 
    self._iprot.readMessageEnd()
3289 
    if result.ex is not None:
3290 
      raise result.ex
3291 
    return
3292 
 
3064 chandransh 3293 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3294 
    """
3064 chandransh 3295 
    Returns the list of orders whose delivery time has passed but have not been
3296 
    delivered yet for the given provider and warehouse. To get a complete list of
3297 
    undelivered orders, pass them as -1.
3298 
    Returns an empty list if no such orders exist.
3431 rajveer 3299 
 
1886 ankur.sing 3300 
    Parameters:
3064 chandransh 3301 
     - providerId
3302 
     - warehouseId
1886 ankur.sing 3303 
    """
3064 chandransh 3304 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3305 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3306 
 
3064 chandransh 3307 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3308 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3309 
    args = getUndeliveredOrders_args()
3310 
    args.providerId = providerId
3311 
    args.warehouseId = warehouseId
1886 ankur.sing 3312 
    args.write(self._oprot)
3313 
    self._oprot.writeMessageEnd()
3314 
    self._oprot.trans.flush()
3315 
 
3064 chandransh 3316 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3318 
    if mtype == TMessageType.EXCEPTION:
3319 
      x = TApplicationException()
3320 
      x.read(self._iprot)
3321 
      self._iprot.readMessageEnd()
3322 
      raise x
3064 chandransh 3323 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3324 
    result.read(self._iprot)
3325 
    self._iprot.readMessageEnd()
3431 rajveer 3326 
    if result.success is not None:
1886 ankur.sing 3327 
      return result.success
3064 chandransh 3328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3329 
 
4783 phani.kuma 3330 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3331 
    """
3332 
    Returns the list of orders whose expected delivery date has passed but have not been
3333 
    delivered yet.
3334 
    Returns an empty list if no such orders exist.
3335 
    """
3336 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3337 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3338 
 
3339 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3340 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3341 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3342 
    args.write(self._oprot)
3343 
    self._oprot.writeMessageEnd()
3344 
    self._oprot.trans.flush()
3345 
 
3346 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3348 
    if mtype == TMessageType.EXCEPTION:
3349 
      x = TApplicationException()
3350 
      x.read(self._iprot)
3351 
      self._iprot.readMessageEnd()
3352 
      raise x
3353 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3354 
    result.read(self._iprot)
3355 
    self._iprot.readMessageEnd()
3356 
    if result.success is not None:
3357 
      return result.success
3358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3359 
 
2536 chandransh 3360 
  def toggleDOAFlag(self, orderId):
3361 
    """
3362 
    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.
3363 
    Returns the final flag status.
3364 
    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 3365 
 
2536 chandransh 3366 
    Parameters:
3367 
     - orderId
3368 
    """
3369 
    self.send_toggleDOAFlag(orderId)
3370 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3371 
 
2536 chandransh 3372 
  def send_toggleDOAFlag(self, orderId):
3373 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3374 
    args = toggleDOAFlag_args()
3375 
    args.orderId = orderId
3376 
    args.write(self._oprot)
3377 
    self._oprot.writeMessageEnd()
3378 
    self._oprot.trans.flush()
3379 
 
3380 
  def recv_toggleDOAFlag(self, ):
3381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3382 
    if mtype == TMessageType.EXCEPTION:
3383 
      x = TApplicationException()
3384 
      x.read(self._iprot)
3385 
      self._iprot.readMessageEnd()
3386 
      raise x
3387 
    result = toggleDOAFlag_result()
3388 
    result.read(self._iprot)
3389 
    self._iprot.readMessageEnd()
3431 rajveer 3390 
    if result.success is not None:
2536 chandransh 3391 
      return result.success
3431 rajveer 3392 
    if result.ex is not None:
2536 chandransh 3393 
      raise result.ex
3394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3395 
 
4712 rajveer 3396 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3397 
    """
3398 
    Parameters:
3399 
     - orderId
3400 
     - deliveryTimestamp
3401 
     - receiver
3402 
    """
3403 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3404 
    self.recv_markOrderAsDelivered()
3405 
 
3406 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3407 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3408 
    args = markOrderAsDelivered_args()
3409 
    args.orderId = orderId
3410 
    args.deliveryTimestamp = deliveryTimestamp
3411 
    args.receiver = receiver
3412 
    args.write(self._oprot)
3413 
    self._oprot.writeMessageEnd()
3414 
    self._oprot.trans.flush()
3415 
 
3416 
  def recv_markOrderAsDelivered(self, ):
3417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3418 
    if mtype == TMessageType.EXCEPTION:
3419 
      x = TApplicationException()
3420 
      x.read(self._iprot)
3421 
      self._iprot.readMessageEnd()
3422 
      raise x
3423 
    result = markOrderAsDelivered_result()
3424 
    result.read(self._iprot)
3425 
    self._iprot.readMessageEnd()
3426 
    if result.ex is not None:
3427 
      raise result.ex
3428 
    return
3429 
 
5553 rajveer 3430 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3431 
    """
3432 
    Parameters:
3433 
     - orderId
3434 
     - deliveryTimestamp
3435 
    """
3436 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3437 
    self.recv_markOrderAsReceivedAtStore()
3438 
 
3439 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3440 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3441 
    args = markOrderAsReceivedAtStore_args()
3442 
    args.orderId = orderId
3443 
    args.deliveryTimestamp = deliveryTimestamp
3444 
    args.write(self._oprot)
3445 
    self._oprot.writeMessageEnd()
3446 
    self._oprot.trans.flush()
3447 
 
3448 
  def recv_markOrderAsReceivedAtStore(self, ):
3449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3450 
    if mtype == TMessageType.EXCEPTION:
3451 
      x = TApplicationException()
3452 
      x.read(self._iprot)
3453 
      self._iprot.readMessageEnd()
3454 
      raise x
3455 
    result = markOrderAsReceivedAtStore_result()
3456 
    result.read(self._iprot)
3457 
    self._iprot.readMessageEnd()
3458 
    if result.ex is not None:
3459 
      raise result.ex
3460 
    return
3461 
 
4454 rajveer 3462 
  def markOrderDoaRequestReceived(self, orderId):
3463 
    """
3464 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3465 
 
3466 
    Parameters:
3467 
     - orderId
3468 
    """
3469 
    self.send_markOrderDoaRequestReceived(orderId)
3470 
    return self.recv_markOrderDoaRequestReceived()
3471 
 
3472 
  def send_markOrderDoaRequestReceived(self, orderId):
3473 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3474 
    args = markOrderDoaRequestReceived_args()
3475 
    args.orderId = orderId
3476 
    args.write(self._oprot)
3477 
    self._oprot.writeMessageEnd()
3478 
    self._oprot.trans.flush()
3479 
 
3480 
  def recv_markOrderDoaRequestReceived(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 = markOrderDoaRequestReceived_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, "markOrderDoaRequestReceived failed: unknown result");
3495 
 
3496 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3497 
    """
3498 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3499 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3500 
 
3501 
    Parameters:
3502 
     - orderId
3503 
     - isAuthorized
3504 
    """
3505 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3506 
    return self.recv_markOrderDoaRequestAuthorized()
3507 
 
3508 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3509 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3510 
    args = markOrderDoaRequestAuthorized_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_markOrderDoaRequestAuthorized(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 = markOrderDoaRequestAuthorized_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, "markOrderDoaRequestAuthorized failed: unknown result");
3532 
 
4488 rajveer 3533 
  def markOrderReturnRequestReceived(self, orderId):
3534 
    """
3535 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3536 
 
3537 
    Parameters:
3538 
     - orderId
3539 
    """
3540 
    self.send_markOrderReturnRequestReceived(orderId)
3541 
    return self.recv_markOrderReturnRequestReceived()
3542 
 
3543 
  def send_markOrderReturnRequestReceived(self, orderId):
3544 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3545 
    args = markOrderReturnRequestReceived_args()
3546 
    args.orderId = orderId
3547 
    args.write(self._oprot)
3548 
    self._oprot.writeMessageEnd()
3549 
    self._oprot.trans.flush()
3550 
 
3551 
  def recv_markOrderReturnRequestReceived(self, ):
3552 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3553 
    if mtype == TMessageType.EXCEPTION:
3554 
      x = TApplicationException()
3555 
      x.read(self._iprot)
3556 
      self._iprot.readMessageEnd()
3557 
      raise x
3558 
    result = markOrderReturnRequestReceived_result()
3559 
    result.read(self._iprot)
3560 
    self._iprot.readMessageEnd()
3561 
    if result.success is not None:
3562 
      return result.success
3563 
    if result.ex is not None:
3564 
      raise result.ex
3565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3566 
 
3567 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3568 
    """
3569 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3570 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3571 
 
3572 
    Parameters:
3573 
     - orderId
3574 
     - isAuthorized
3575 
    """
3576 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3577 
    return self.recv_markOrderReturnRequestAuthorized()
3578 
 
3579 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3580 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3581 
    args = markOrderReturnRequestAuthorized_args()
3582 
    args.orderId = orderId
3583 
    args.isAuthorized = isAuthorized
3584 
    args.write(self._oprot)
3585 
    self._oprot.writeMessageEnd()
3586 
    self._oprot.trans.flush()
3587 
 
3588 
  def recv_markOrderReturnRequestAuthorized(self, ):
3589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3590 
    if mtype == TMessageType.EXCEPTION:
3591 
      x = TApplicationException()
3592 
      x.read(self._iprot)
3593 
      self._iprot.readMessageEnd()
3594 
      raise x
3595 
    result = markOrderReturnRequestAuthorized_result()
3596 
    result.read(self._iprot)
3597 
    self._iprot.readMessageEnd()
3598 
    if result.success is not None:
3599 
      return result.success
3600 
    if result.ex is not None:
3601 
      raise result.ex
3602 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3603 
 
4579 rajveer 3604 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3605 
    """
3606 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3607 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3608 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3609 
    For any other status, it returns false.
3610 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3611 
 
2536 chandransh 3612 
    Parameters:
3613 
     - orderId
4579 rajveer 3614 
     - providerId
2536 chandransh 3615 
    """
4579 rajveer 3616 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3617 
    return self.recv_requestPickupNumber()
3618 
 
4579 rajveer 3619 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3620 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3621 
    args = requestPickupNumber_args()
3622 
    args.orderId = orderId
4579 rajveer 3623 
    args.providerId = providerId
2536 chandransh 3624 
    args.write(self._oprot)
3625 
    self._oprot.writeMessageEnd()
3626 
    self._oprot.trans.flush()
3627 
 
3628 
  def recv_requestPickupNumber(self, ):
3629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3630 
    if mtype == TMessageType.EXCEPTION:
3631 
      x = TApplicationException()
3632 
      x.read(self._iprot)
3633 
      self._iprot.readMessageEnd()
3634 
      raise x
3635 
    result = requestPickupNumber_result()
3636 
    result.read(self._iprot)
3637 
    self._iprot.readMessageEnd()
3431 rajveer 3638 
    if result.success is not None:
2536 chandransh 3639 
      return result.success
3431 rajveer 3640 
    if result.ex is not None:
2536 chandransh 3641 
      raise result.ex
3642 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3643 
 
4602 rajveer 3644 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3645 
    """
4452 rajveer 3646 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3647 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3648 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3649 
    	3. Returns true
2591 chandransh 3650 
    If the order is in any other status, it returns false.
2536 chandransh 3651 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3652 
 
2536 chandransh 3653 
    Parameters:
3654 
     - orderId
3655 
     - pickupNumber
4602 rajveer 3656 
     - providerId
2536 chandransh 3657 
    """
4602 rajveer 3658 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3659 
    return self.recv_authorizePickup()
3660 
 
4602 rajveer 3661 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3662 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3663 
    args = authorizePickup_args()
3664 
    args.orderId = orderId
3665 
    args.pickupNumber = pickupNumber
4602 rajveer 3666 
    args.providerId = providerId
2536 chandransh 3667 
    args.write(self._oprot)
3668 
    self._oprot.writeMessageEnd()
3669 
    self._oprot.trans.flush()
3670 
 
3671 
  def recv_authorizePickup(self, ):
3672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3673 
    if mtype == TMessageType.EXCEPTION:
3674 
      x = TApplicationException()
3675 
      x.read(self._iprot)
3676 
      self._iprot.readMessageEnd()
3677 
      raise x
3678 
    result = authorizePickup_result()
3679 
    result.read(self._iprot)
3680 
    self._iprot.readMessageEnd()
3431 rajveer 3681 
    if result.success is not None:
2536 chandransh 3682 
      return result.success
3431 rajveer 3683 
    if result.ex is not None:
2536 chandransh 3684 
      raise result.ex
3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3686 
 
2764 chandransh 3687 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3688 
    """
3689 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3690 
 
2764 chandransh 3691 
    Parameters:
3692 
     - providerId
3693 
     - pickupDetails
3694 
    """
3695 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3696 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3697 
 
3698 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3699 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3700 
    args = markDoasAsPickedUp_args()
3701 
    args.providerId = providerId
3702 
    args.pickupDetails = pickupDetails
3703 
    args.write(self._oprot)
3704 
    self._oprot.writeMessageEnd()
3705 
    self._oprot.trans.flush()
3706 
 
3707 
  def recv_markDoasAsPickedUp(self, ):
3708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3709 
    if mtype == TMessageType.EXCEPTION:
3710 
      x = TApplicationException()
3711 
      x.read(self._iprot)
3712 
      self._iprot.readMessageEnd()
3713 
      raise x
3714 
    result = markDoasAsPickedUp_result()
3715 
    result.read(self._iprot)
3716 
    self._iprot.readMessageEnd()
4910 phani.kuma 3717 
    return
3718 
 
3719 
  def getDoasNotPickedUp(self, providerId):
3720 
    """
3721 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3722 
 
3723 
    Parameters:
3724 
     - providerId
3725 
    """
3726 
    self.send_getDoasNotPickedUp(providerId)
3727 
    return self.recv_getDoasNotPickedUp()
3728 
 
3729 
  def send_getDoasNotPickedUp(self, providerId):
3730 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3731 
    args = getDoasNotPickedUp_args()
3732 
    args.providerId = providerId
3733 
    args.write(self._oprot)
3734 
    self._oprot.writeMessageEnd()
3735 
    self._oprot.trans.flush()
3736 
 
3737 
  def recv_getDoasNotPickedUp(self, ):
3738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3739 
    if mtype == TMessageType.EXCEPTION:
3740 
      x = TApplicationException()
3741 
      x.read(self._iprot)
3742 
      self._iprot.readMessageEnd()
3743 
      raise x
3744 
    result = getDoasNotPickedUp_result()
3745 
    result.read(self._iprot)
3746 
    self._iprot.readMessageEnd()
3431 rajveer 3747 
    if result.success is not None:
2764 chandransh 3748 
      return result.success
4910 phani.kuma 3749 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3750 
 
4741 phani.kuma 3751 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3752 
    """
3753 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3754 
 
3755 
    Parameters:
3756 
     - providerId
3757 
     - pickupDetails
3758 
    """
3759 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3760 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3761 
 
3762 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3763 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3764 
    args = markReturnOrdersAsPickedUp_args()
3765 
    args.providerId = providerId
3766 
    args.pickupDetails = pickupDetails
3767 
    args.write(self._oprot)
3768 
    self._oprot.writeMessageEnd()
3769 
    self._oprot.trans.flush()
3770 
 
3771 
  def recv_markReturnOrdersAsPickedUp(self, ):
3772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3773 
    if mtype == TMessageType.EXCEPTION:
3774 
      x = TApplicationException()
3775 
      x.read(self._iprot)
3776 
      self._iprot.readMessageEnd()
3777 
      raise x
3778 
    result = markReturnOrdersAsPickedUp_result()
3779 
    result.read(self._iprot)
3780 
    self._iprot.readMessageEnd()
4910 phani.kuma 3781 
    return
3782 
 
3783 
  def getReturnOrdersNotPickedUp(self, providerId):
3784 
    """
3785 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3786 
 
3787 
    Parameters:
3788 
     - providerId
3789 
    """
3790 
    self.send_getReturnOrdersNotPickedUp(providerId)
3791 
    return self.recv_getReturnOrdersNotPickedUp()
3792 
 
3793 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3794 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3795 
    args = getReturnOrdersNotPickedUp_args()
3796 
    args.providerId = providerId
3797 
    args.write(self._oprot)
3798 
    self._oprot.writeMessageEnd()
3799 
    self._oprot.trans.flush()
3800 
 
3801 
  def recv_getReturnOrdersNotPickedUp(self, ):
3802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3803 
    if mtype == TMessageType.EXCEPTION:
3804 
      x = TApplicationException()
3805 
      x.read(self._iprot)
3806 
      self._iprot.readMessageEnd()
3807 
      raise x
3808 
    result = getReturnOrdersNotPickedUp_result()
3809 
    result.read(self._iprot)
3810 
    self._iprot.readMessageEnd()
4741 phani.kuma 3811 
    if result.success is not None:
3812 
      return result.success
4910 phani.kuma 3813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3814 
 
4479 rajveer 3815 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3816 
    """
4452 rajveer 3817 
    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 3818 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3819 
    If the order is in any other state, it returns false.
3820 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3821 
 
2591 chandransh 3822 
    Parameters:
3823 
     - orderId
4479 rajveer 3824 
     - receiveCondition
2591 chandransh 3825 
    """
4479 rajveer 3826 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3827 
    return self.recv_receiveReturn()
2536 chandransh 3828 
 
4479 rajveer 3829 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3830 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3831 
    args = receiveReturn_args()
2591 chandransh 3832 
    args.orderId = orderId
4479 rajveer 3833 
    args.receiveCondition = receiveCondition
2591 chandransh 3834 
    args.write(self._oprot)
3835 
    self._oprot.writeMessageEnd()
3836 
    self._oprot.trans.flush()
3837 
 
2616 chandransh 3838 
  def recv_receiveReturn(self, ):
2591 chandransh 3839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3840 
    if mtype == TMessageType.EXCEPTION:
3841 
      x = TApplicationException()
3842 
      x.read(self._iprot)
3843 
      self._iprot.readMessageEnd()
3844 
      raise x
2616 chandransh 3845 
    result = receiveReturn_result()
2591 chandransh 3846 
    result.read(self._iprot)
3847 
    self._iprot.readMessageEnd()
3431 rajveer 3848 
    if result.success is not None:
2591 chandransh 3849 
      return result.success
3431 rajveer 3850 
    if result.ex is not None:
2591 chandransh 3851 
      raise result.ex
2616 chandransh 3852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3853 
 
3854 
  def validateDoa(self, orderId, isValid):
3855 
    """
4452 rajveer 3856 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3857 
    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 3858 
    If the order is in any other state, it returns false.
3859 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3860 
 
2591 chandransh 3861 
    Parameters:
3862 
     - orderId
3863 
     - isValid
3864 
    """
3865 
    self.send_validateDoa(orderId, isValid)
3866 
    return self.recv_validateDoa()
3867 
 
3868 
  def send_validateDoa(self, orderId, isValid):
3869 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3870 
    args = validateDoa_args()
3871 
    args.orderId = orderId
3872 
    args.isValid = isValid
3873 
    args.write(self._oprot)
3874 
    self._oprot.writeMessageEnd()
3875 
    self._oprot.trans.flush()
3876 
 
3877 
  def recv_validateDoa(self, ):
3878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3879 
    if mtype == TMessageType.EXCEPTION:
3880 
      x = TApplicationException()
3881 
      x.read(self._iprot)
3882 
      self._iprot.readMessageEnd()
3883 
      raise x
3884 
    result = validateDoa_result()
3885 
    result.read(self._iprot)
3886 
    self._iprot.readMessageEnd()
3431 rajveer 3887 
    if result.success is not None:
2591 chandransh 3888 
      return result.success
3431 rajveer 3889 
    if result.ex is not None:
2591 chandransh 3890 
      raise result.ex
3891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3892 
 
4495 rajveer 3893 
  def validateReturnProduct(self, orderId, isUsable):
3894 
    """
3895 
    Parameters:
3896 
     - orderId
3897 
     - isUsable
3898 
    """
3899 
    self.send_validateReturnProduct(orderId, isUsable)
3900 
    return self.recv_validateReturnProduct()
3901 
 
3902 
  def send_validateReturnProduct(self, orderId, isUsable):
3903 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3904 
    args = validateReturnProduct_args()
3905 
    args.orderId = orderId
3906 
    args.isUsable = isUsable
3907 
    args.write(self._oprot)
3908 
    self._oprot.writeMessageEnd()
3909 
    self._oprot.trans.flush()
3910 
 
3911 
  def recv_validateReturnProduct(self, ):
3912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3913 
    if mtype == TMessageType.EXCEPTION:
3914 
      x = TApplicationException()
3915 
      x.read(self._iprot)
3916 
      self._iprot.readMessageEnd()
3917 
      raise x
3918 
    result = validateReturnProduct_result()
3919 
    result.read(self._iprot)
3920 
    self._iprot.readMessageEnd()
3921 
    if result.success is not None:
3922 
      return result.success
3923 
    if result.ex is not None:
3924 
      raise result.ex
3925 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3926 
 
2616 chandransh 3927 
  def reshipOrder(self, orderId):
3928 
    """
4484 rajveer 3929 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3930 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3931 
    	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 3932 
 
3933 
    If the order is in DOA_CERT_VALID state, it does the following:
3934 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3935 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3936 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3937 
 
2616 chandransh 3938 
    Returns the id of the newly created order.
3431 rajveer 3939 
 
2616 chandransh 3940 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3941 
 
2616 chandransh 3942 
    Parameters:
3943 
     - orderId
3944 
    """
3945 
    self.send_reshipOrder(orderId)
3946 
    return self.recv_reshipOrder()
2591 chandransh 3947 
 
2616 chandransh 3948 
  def send_reshipOrder(self, orderId):
3949 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3950 
    args = reshipOrder_args()
3951 
    args.orderId = orderId
3952 
    args.write(self._oprot)
3953 
    self._oprot.writeMessageEnd()
3954 
    self._oprot.trans.flush()
3955 
 
3956 
  def recv_reshipOrder(self, ):
3957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3958 
    if mtype == TMessageType.EXCEPTION:
3959 
      x = TApplicationException()
3960 
      x.read(self._iprot)
3961 
      self._iprot.readMessageEnd()
3962 
      raise x
3963 
    result = reshipOrder_result()
3964 
    result.read(self._iprot)
3965 
    self._iprot.readMessageEnd()
3431 rajveer 3966 
    if result.success is not None:
2616 chandransh 3967 
      return result.success
3431 rajveer 3968 
    if result.ex is not None:
2616 chandransh 3969 
      raise result.ex
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3971 
 
3226 chandransh 3972 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3973 
    """
4484 rajveer 3974 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3975 
    	1. Creates a refund request for batch processing.
3976 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3977 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3978 
 
2616 chandransh 3979 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3980 
    	1. Creates a refund request for batch processing.
3226 chandransh 3981 
    	2. Cancels the reservation of the item in the warehouse.
3982 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3983 
 
3226 chandransh 3984 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3985 
    	1. Cancels the reservation of the item in the warehouse.
3986 
    	2. Marks the current order as CANCELED.
3987 
 
3988 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3989 
 
2616 chandransh 3990 
    Returns True if it is successful, False otherwise.
3431 rajveer 3991 
 
2616 chandransh 3992 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3993 
 
2616 chandransh 3994 
    Parameters:
3995 
     - orderId
3226 chandransh 3996 
     - refundedBy
3997 
     - reason
2616 chandransh 3998 
    """
3226 chandransh 3999 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4000 
    return self.recv_refundOrder()
4001 
 
3226 chandransh 4002 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4003 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4004 
    args = refundOrder_args()
4005 
    args.orderId = orderId
3226 chandransh 4006 
    args.refundedBy = refundedBy
4007 
    args.reason = reason
2616 chandransh 4008 
    args.write(self._oprot)
4009 
    self._oprot.writeMessageEnd()
4010 
    self._oprot.trans.flush()
4011 
 
4012 
  def recv_refundOrder(self, ):
4013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4014 
    if mtype == TMessageType.EXCEPTION:
4015 
      x = TApplicationException()
4016 
      x.read(self._iprot)
4017 
      self._iprot.readMessageEnd()
4018 
      raise x
4019 
    result = refundOrder_result()
4020 
    result.read(self._iprot)
4021 
    self._iprot.readMessageEnd()
3431 rajveer 4022 
    if result.success is not None:
2616 chandransh 4023 
      return result.success
3431 rajveer 4024 
    if result.ex is not None:
2616 chandransh 4025 
      raise result.ex
4026 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4027 
 
2690 chandransh 4028 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4029 
    """
4030 
    Get all return orders created between the from and to dates for the given warehouse.
4031 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4032 
 
2690 chandransh 4033 
    Parameters:
4034 
     - warehouseId
4035 
     - fromDate
4036 
     - toDate
4037 
    """
4038 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4039 
    return self.recv_getReturnOrders()
2616 chandransh 4040 
 
2690 chandransh 4041 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4042 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4043 
    args = getReturnOrders_args()
4044 
    args.warehouseId = warehouseId
4045 
    args.fromDate = fromDate
4046 
    args.toDate = toDate
4047 
    args.write(self._oprot)
4048 
    self._oprot.writeMessageEnd()
4049 
    self._oprot.trans.flush()
4050 
 
4051 
  def recv_getReturnOrders(self, ):
4052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4053 
    if mtype == TMessageType.EXCEPTION:
4054 
      x = TApplicationException()
4055 
      x.read(self._iprot)
4056 
      self._iprot.readMessageEnd()
4057 
      raise x
4058 
    result = getReturnOrders_result()
4059 
    result.read(self._iprot)
4060 
    self._iprot.readMessageEnd()
3431 rajveer 4061 
    if result.success is not None:
2690 chandransh 4062 
      return result.success
4063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4064 
 
5481 phani.kuma 4065 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4066 
    """
4067 
    Get all return orders created between the from and to dates.
4068 
 
4069 
    Parameters:
4070 
     - onlyNotProcessed
4071 
     - fromDate
4072 
     - toDate
4073 
    """
4074 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4075 
    return self.recv_getAllReturnOrders()
4076 
 
4077 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4078 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4079 
    args = getAllReturnOrders_args()
4080 
    args.onlyNotProcessed = onlyNotProcessed
4081 
    args.fromDate = fromDate
4082 
    args.toDate = toDate
4083 
    args.write(self._oprot)
4084 
    self._oprot.writeMessageEnd()
4085 
    self._oprot.trans.flush()
4086 
 
4087 
  def recv_getAllReturnOrders(self, ):
4088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4089 
    if mtype == TMessageType.EXCEPTION:
4090 
      x = TApplicationException()
4091 
      x.read(self._iprot)
4092 
      self._iprot.readMessageEnd()
4093 
      raise x
4094 
    result = getAllReturnOrders_result()
4095 
    result.read(self._iprot)
4096 
    self._iprot.readMessageEnd()
4097 
    if result.success is not None:
4098 
      return result.success
4099 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4100 
 
2700 chandransh 4101 
  def getReturnOrder(self, id):
4102 
    """
4103 
    Returns the ReturnOrder corresponding to the given id.
4104 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4105 
 
2700 chandransh 4106 
    Parameters:
4107 
     - id
4108 
    """
4109 
    self.send_getReturnOrder(id)
4110 
    return self.recv_getReturnOrder()
4111 
 
4112 
  def send_getReturnOrder(self, id):
4113 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4114 
    args = getReturnOrder_args()
4115 
    args.id = id
4116 
    args.write(self._oprot)
4117 
    self._oprot.writeMessageEnd()
4118 
    self._oprot.trans.flush()
4119 
 
4120 
  def recv_getReturnOrder(self, ):
4121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4122 
    if mtype == TMessageType.EXCEPTION:
4123 
      x = TApplicationException()
4124 
      x.read(self._iprot)
4125 
      self._iprot.readMessageEnd()
4126 
      raise x
4127 
    result = getReturnOrder_result()
4128 
    result.read(self._iprot)
4129 
    self._iprot.readMessageEnd()
3431 rajveer 4130 
    if result.success is not None:
2700 chandransh 4131 
      return result.success
3431 rajveer 4132 
    if result.ex is not None:
2700 chandransh 4133 
      raise result.ex
4134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4135 
 
2690 chandransh 4136 
  def processReturn(self, returnOrderId):
4137 
    """
4138 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4139 
 
2690 chandransh 4140 
    Parameters:
4141 
     - returnOrderId
4142 
    """
4143 
    self.send_processReturn(returnOrderId)
4144 
    self.recv_processReturn()
4145 
 
4146 
  def send_processReturn(self, returnOrderId):
4147 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4148 
    args = processReturn_args()
4149 
    args.returnOrderId = returnOrderId
4150 
    args.write(self._oprot)
4151 
    self._oprot.writeMessageEnd()
4152 
    self._oprot.trans.flush()
4153 
 
4154 
  def recv_processReturn(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 = processReturn_result()
4162 
    result.read(self._iprot)
4163 
    self._iprot.readMessageEnd()
3431 rajveer 4164 
    if result.ex is not None:
2690 chandransh 4165 
      raise result.ex
4166 
    return
4167 
 
3451 chandransh 4168 
  def updateWeight(self, orderId, weight):
4169 
    """
4170 
    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 4171 
 
3451 chandransh 4172 
    Parameters:
4173 
     - orderId
4174 
     - weight
4175 
    """
4176 
    self.send_updateWeight(orderId, weight)
4177 
    return self.recv_updateWeight()
4178 
 
4179 
  def send_updateWeight(self, orderId, weight):
4180 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4181 
    args = updateWeight_args()
4182 
    args.orderId = orderId
4183 
    args.weight = weight
4184 
    args.write(self._oprot)
4185 
    self._oprot.writeMessageEnd()
4186 
    self._oprot.trans.flush()
4187 
 
4188 
  def recv_updateWeight(self, ):
4189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4190 
    if mtype == TMessageType.EXCEPTION:
4191 
      x = TApplicationException()
4192 
      x.read(self._iprot)
4193 
      self._iprot.readMessageEnd()
4194 
      raise x
4195 
    result = updateWeight_result()
4196 
    result.read(self._iprot)
4197 
    self._iprot.readMessageEnd()
4198 
    if result.success is not None:
4199 
      return result.success
4200 
    if result.ex is not None:
4201 
      raise result.ex
4202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4203 
 
3469 chandransh 4204 
  def changeItem(self, orderId, itemId):
4205 
    """
4206 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4207 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4208 
 
3469 chandransh 4209 
    Parameters:
4210 
     - orderId
4211 
     - itemId
4212 
    """
4213 
    self.send_changeItem(orderId, itemId)
4214 
    return self.recv_changeItem()
4215 
 
4216 
  def send_changeItem(self, orderId, itemId):
4217 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4218 
    args = changeItem_args()
4219 
    args.orderId = orderId
4220 
    args.itemId = itemId
4221 
    args.write(self._oprot)
4222 
    self._oprot.writeMessageEnd()
4223 
    self._oprot.trans.flush()
4224 
 
4225 
  def recv_changeItem(self, ):
4226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4227 
    if mtype == TMessageType.EXCEPTION:
4228 
      x = TApplicationException()
4229 
      x.read(self._iprot)
4230 
      self._iprot.readMessageEnd()
4231 
      raise x
4232 
    result = changeItem_result()
4233 
    result.read(self._iprot)
4234 
    self._iprot.readMessageEnd()
4235 
    if result.success is not None:
4236 
      return result.success
4237 
    if result.ex is not None:
4238 
      raise result.ex
4239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4240 
 
4241 
  def shiftToWarehouse(self, orderId, warehouseId):
4242 
    """
4243 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4244 
 
4245 
    Parameters:
4246 
     - orderId
4247 
     - warehouseId
4248 
    """
4249 
    self.send_shiftToWarehouse(orderId, warehouseId)
4250 
    return self.recv_shiftToWarehouse()
4251 
 
4252 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4253 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4254 
    args = shiftToWarehouse_args()
4255 
    args.orderId = orderId
4256 
    args.warehouseId = warehouseId
4257 
    args.write(self._oprot)
4258 
    self._oprot.writeMessageEnd()
4259 
    self._oprot.trans.flush()
4260 
 
4261 
  def recv_shiftToWarehouse(self, ):
4262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4263 
    if mtype == TMessageType.EXCEPTION:
4264 
      x = TApplicationException()
4265 
      x.read(self._iprot)
4266 
      self._iprot.readMessageEnd()
4267 
      raise x
4268 
    result = shiftToWarehouse_result()
4269 
    result.read(self._iprot)
4270 
    self._iprot.readMessageEnd()
4271 
    if result.success is not None:
4272 
      return result.success
4273 
    if result.ex is not None:
4274 
      raise result.ex
4275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4276 
 
4647 rajveer 4277 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4278 
    """
4279 
    Adds the given delay reason to the given order.
3986 chandransh 4280 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4281 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4282 
 
3553 chandransh 4283 
    Parameters:
4284 
     - orderId
4285 
     - delayReason
3986 chandransh 4286 
     - furtherDelay
4647 rajveer 4287 
     - delayReasonText
3553 chandransh 4288 
    """
4647 rajveer 4289 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4290 
    return self.recv_addDelayReason()
4291 
 
4647 rajveer 4292 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4293 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4294 
    args = addDelayReason_args()
4295 
    args.orderId = orderId
4296 
    args.delayReason = delayReason
3986 chandransh 4297 
    args.furtherDelay = furtherDelay
4647 rajveer 4298 
    args.delayReasonText = delayReasonText
3553 chandransh 4299 
    args.write(self._oprot)
4300 
    self._oprot.writeMessageEnd()
4301 
    self._oprot.trans.flush()
4302 
 
4303 
  def recv_addDelayReason(self, ):
4304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4305 
    if mtype == TMessageType.EXCEPTION:
4306 
      x = TApplicationException()
4307 
      x.read(self._iprot)
4308 
      self._iprot.readMessageEnd()
4309 
      raise x
4310 
    result = addDelayReason_result()
4311 
    result.read(self._iprot)
4312 
    self._iprot.readMessageEnd()
4313 
    if result.success is not None:
4314 
      return result.success
4315 
    if result.ex is not None:
4316 
      raise result.ex
4317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4318 
 
3956 chandransh 4319 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4320 
    """
4321 
    Marks the COD orders with given AWB nos. as having been processed.
4322 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4323 
 
3956 chandransh 4324 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4325 
    1. There is no order corresponding to an AWB number.
4326 
    2. The captured amount for a payment exceeds the total payment.
4327 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4328 
 
4329 
    Parameters:
4330 
     - collectedAmountMap
4331 
     - xferBy
4332 
     - xferTxnId
4333 
     - xferDate
4334 
    """
4335 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4336 
    return self.recv_reconcileCodCollection()
4337 
 
4338 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4339 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4340 
    args = reconcileCodCollection_args()
4341 
    args.collectedAmountMap = collectedAmountMap
4342 
    args.xferBy = xferBy
4343 
    args.xferTxnId = xferTxnId
4344 
    args.xferDate = xferDate
4345 
    args.write(self._oprot)
4346 
    self._oprot.writeMessageEnd()
4347 
    self._oprot.trans.flush()
4348 
 
4349 
  def recv_reconcileCodCollection(self, ):
4350 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4351 
    if mtype == TMessageType.EXCEPTION:
4352 
      x = TApplicationException()
4353 
      x.read(self._iprot)
4354 
      self._iprot.readMessageEnd()
4355 
      raise x
4356 
    result = reconcileCodCollection_result()
4357 
    result.read(self._iprot)
4358 
    self._iprot.readMessageEnd()
4359 
    if result.success is not None:
4360 
      return result.success
4361 
    if result.ex is not None:
4362 
      raise result.ex
4363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4364 
 
4008 mandeep.dh 4365 
  def getTransactionsRequiringExtraProcessing(self, category):
4366 
    """
4065 mandeep.dh 4367 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4368 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4369 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4370 
 
4008 mandeep.dh 4371 
    Parameters:
4372 
     - category
4373 
    """
4374 
    self.send_getTransactionsRequiringExtraProcessing(category)
4375 
    return self.recv_getTransactionsRequiringExtraProcessing()
4376 
 
4377 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4378 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4379 
    args = getTransactionsRequiringExtraProcessing_args()
4380 
    args.category = category
4381 
    args.write(self._oprot)
4382 
    self._oprot.writeMessageEnd()
4383 
    self._oprot.trans.flush()
4384 
 
4385 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4387 
    if mtype == TMessageType.EXCEPTION:
4388 
      x = TApplicationException()
4389 
      x.read(self._iprot)
4390 
      self._iprot.readMessageEnd()
4391 
      raise x
4392 
    result = getTransactionsRequiringExtraProcessing_result()
4393 
    result.read(self._iprot)
4394 
    self._iprot.readMessageEnd()
4395 
    if result.success is not None:
4396 
      return result.success
4397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4398 
 
4399 
  def markTransactionAsProcessed(self, transactionId, category):
4400 
    """
4401 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4402 
    It essentially deletes the transaction id record for a particular
4403 
    processing type category (if present) from DB.
4404 
    This is currently used by CRM application.
4008 mandeep.dh 4405 
 
4406 
    Parameters:
4407 
     - transactionId
4408 
     - category
4409 
    """
4410 
    self.send_markTransactionAsProcessed(transactionId, category)
4411 
    self.recv_markTransactionAsProcessed()
4412 
 
4413 
  def send_markTransactionAsProcessed(self, transactionId, category):
4414 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4415 
    args = markTransactionAsProcessed_args()
4416 
    args.transactionId = transactionId
4417 
    args.category = category
4418 
    args.write(self._oprot)
4419 
    self._oprot.writeMessageEnd()
4420 
    self._oprot.trans.flush()
4421 
 
4422 
  def recv_markTransactionAsProcessed(self, ):
4423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4424 
    if mtype == TMessageType.EXCEPTION:
4425 
      x = TApplicationException()
4426 
      x.read(self._iprot)
4427 
      self._iprot.readMessageEnd()
4428 
      raise x
4429 
    result = markTransactionAsProcessed_result()
4430 
    result.read(self._iprot)
4431 
    self._iprot.readMessageEnd()
4432 
    return
4433 
 
4018 chandransh 4434 
  def getItemWiseRiskyOrdersCount(self, ):
4435 
    """
4436 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4437 
    is defined as one whose shipping date is about to expire.
4438 
    """
4439 
    self.send_getItemWiseRiskyOrdersCount()
4440 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4441 
 
4018 chandransh 4442 
  def send_getItemWiseRiskyOrdersCount(self, ):
4443 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4444 
    args = getItemWiseRiskyOrdersCount_args()
4445 
    args.write(self._oprot)
4446 
    self._oprot.writeMessageEnd()
4447 
    self._oprot.trans.flush()
4448 
 
4449 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4450 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4451 
    if mtype == TMessageType.EXCEPTION:
4452 
      x = TApplicationException()
4453 
      x.read(self._iprot)
4454 
      self._iprot.readMessageEnd()
4455 
      raise x
4456 
    result = getItemWiseRiskyOrdersCount_result()
4457 
    result.read(self._iprot)
4458 
    self._iprot.readMessageEnd()
4459 
    if result.success is not None:
4460 
      return result.success
4461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4462 
 
4295 varun.gupt 4463 
  def getOrdersForItemIds(self, itemIds):
4464 
    """
4465 
    Returns a list of all orders which have items with given id
4466 
 
4467 
    Parameters:
4468 
     - itemIds
4469 
    """
4470 
    self.send_getOrdersForItemIds(itemIds)
4471 
    return self.recv_getOrdersForItemIds()
4472 
 
4473 
  def send_getOrdersForItemIds(self, itemIds):
4474 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4475 
    args = getOrdersForItemIds_args()
4476 
    args.itemIds = itemIds
4477 
    args.write(self._oprot)
4478 
    self._oprot.writeMessageEnd()
4479 
    self._oprot.trans.flush()
4480 
 
4481 
  def recv_getOrdersForItemIds(self, ):
4482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4483 
    if mtype == TMessageType.EXCEPTION:
4484 
      x = TApplicationException()
4485 
      x.read(self._iprot)
4486 
      self._iprot.readMessageEnd()
4487 
      raise x
4488 
    result = getOrdersForItemIds_result()
4489 
    result.read(self._iprot)
4490 
    self._iprot.readMessageEnd()
4491 
    if result.success is not None:
4492 
      return result.success
4493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4494 
 
4247 rajveer 4495 
  def markOrderCancellationRequestReceived(self, orderId):
4496 
    """
4497 
    Mark order as cancellation request received. If customer sends request of cancellation of
4498 
    a particular order, this method will be called. It will just change status of the order
4499 
    depending on its current status. It also records the previous status, so that we can move
4500 
    back to that status if cancellation request is denied.
4018 chandransh 4501 
 
4247 rajveer 4502 
    Parameters:
4503 
     - orderId
4504 
    """
4505 
    self.send_markOrderCancellationRequestReceived(orderId)
4506 
    self.recv_markOrderCancellationRequestReceived()
4507 
 
4508 
  def send_markOrderCancellationRequestReceived(self, orderId):
4509 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4510 
    args = markOrderCancellationRequestReceived_args()
4511 
    args.orderId = orderId
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_markOrderCancellationRequestReceived(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = markOrderCancellationRequestReceived_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.ex is not None:
4527 
      raise result.ex
4528 
    return
4529 
 
4530 
  def markOrderCancellationRequestConfirmed(self, orderId):
4531 
    """
4532 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4533 
    cancellation request confirmed. After this OM will be able to cancel the order.
4534 
 
4535 
    Parameters:
4536 
     - orderId
4537 
    """
4538 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4539 
    self.recv_markOrderCancellationRequestConfirmed()
4540 
 
4541 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4542 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4543 
    args = markOrderCancellationRequestConfirmed_args()
4544 
    args.orderId = orderId
4545 
    args.write(self._oprot)
4546 
    self._oprot.writeMessageEnd()
4547 
    self._oprot.trans.flush()
4548 
 
4549 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4551 
    if mtype == TMessageType.EXCEPTION:
4552 
      x = TApplicationException()
4553 
      x.read(self._iprot)
4554 
      self._iprot.readMessageEnd()
4555 
      raise x
4556 
    result = markOrderCancellationRequestConfirmed_result()
4557 
    result.read(self._iprot)
4558 
    self._iprot.readMessageEnd()
4559 
    if result.ex is not None:
4560 
      raise result.ex
4561 
    return
4562 
 
4563 
  def markOrderCancellationRequestDenied(self, orderId):
4564 
    """
4565 
    If we decide to not to cancel order, we will move the order ro previous status.
4566 
 
4567 
    Parameters:
4568 
     - orderId
4569 
    """
4570 
    self.send_markOrderCancellationRequestDenied(orderId)
4571 
    self.recv_markOrderCancellationRequestDenied()
4572 
 
4573 
  def send_markOrderCancellationRequestDenied(self, orderId):
4574 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4575 
    args = markOrderCancellationRequestDenied_args()
4576 
    args.orderId = orderId
4577 
    args.write(self._oprot)
4578 
    self._oprot.writeMessageEnd()
4579 
    self._oprot.trans.flush()
4580 
 
4581 
  def recv_markOrderCancellationRequestDenied(self, ):
4582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4583 
    if mtype == TMessageType.EXCEPTION:
4584 
      x = TApplicationException()
4585 
      x.read(self._iprot)
4586 
      self._iprot.readMessageEnd()
4587 
      raise x
4588 
    result = markOrderCancellationRequestDenied_result()
4589 
    result.read(self._iprot)
4590 
    self._iprot.readMessageEnd()
4591 
    if result.ex is not None:
4592 
      raise result.ex
4593 
    return
4594 
 
4258 rajveer 4595 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4596 
    """
4258 rajveer 4597 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4598 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4599 
 
4600 
    Parameters:
4258 rajveer 4601 
     - transactionId
4247 rajveer 4602 
    """
4258 rajveer 4603 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4604 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4605 
 
4258 rajveer 4606 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4607 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4608 
    args = markTransactionAsPaymentFlagRemoved_args()
4609 
    args.transactionId = transactionId
4247 rajveer 4610 
    args.write(self._oprot)
4611 
    self._oprot.writeMessageEnd()
4612 
    self._oprot.trans.flush()
4613 
 
4258 rajveer 4614 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4616 
    if mtype == TMessageType.EXCEPTION:
4617 
      x = TApplicationException()
4618 
      x.read(self._iprot)
4619 
      self._iprot.readMessageEnd()
4620 
      raise x
4258 rajveer 4621 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4622 
    result.read(self._iprot)
4623 
    self._iprot.readMessageEnd()
4624 
    if result.ex is not None:
4625 
      raise result.ex
4626 
    return
4627 
 
4259 anupam.sin 4628 
  def refundTransaction(self, transactionId, refundedBy, reason):
4629 
    """
4630 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4631 
    need to be cancelled
4247 rajveer 4632 
 
4259 anupam.sin 4633 
    Parameters:
4634 
     - transactionId
4635 
     - refundedBy
4636 
     - reason
4637 
    """
4638 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4639 
    self.recv_refundTransaction()
4640 
 
4641 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4642 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4643 
    args = refundTransaction_args()
4644 
    args.transactionId = transactionId
4645 
    args.refundedBy = refundedBy
4646 
    args.reason = reason
4647 
    args.write(self._oprot)
4648 
    self._oprot.writeMessageEnd()
4649 
    self._oprot.trans.flush()
4650 
 
4651 
  def recv_refundTransaction(self, ):
4652 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4653 
    if mtype == TMessageType.EXCEPTION:
4654 
      x = TApplicationException()
4655 
      x.read(self._iprot)
4656 
      self._iprot.readMessageEnd()
4657 
      raise x
4658 
    result = refundTransaction_result()
4659 
    result.read(self._iprot)
4660 
    self._iprot.readMessageEnd()
4661 
    if result.ex is not None:
4662 
      raise result.ex
4663 
    return
4664 
 
4324 mandeep.dh 4665 
  def updateShipmentAddress(self, orderId, addressId):
4666 
    """
4667 
    Updates shipment address of an order. Delivery and shipping date estimates
4668 
    etc. are also updated here.
4669 
 
4670 
    Throws TransactionServiceException in case address change is not
4671 
    possible due to certain reasons such as new pincode in address is
4672 
    not serviceable etc.
4673 
 
4674 
    Parameters:
4675 
     - orderId
4676 
     - addressId
4677 
    """
4678 
    self.send_updateShipmentAddress(orderId, addressId)
4679 
    self.recv_updateShipmentAddress()
4680 
 
4681 
  def send_updateShipmentAddress(self, orderId, addressId):
4682 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4683 
    args = updateShipmentAddress_args()
4684 
    args.orderId = orderId
4685 
    args.addressId = addressId
4686 
    args.write(self._oprot)
4687 
    self._oprot.writeMessageEnd()
4688 
    self._oprot.trans.flush()
4689 
 
4690 
  def recv_updateShipmentAddress(self, ):
4691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4692 
    if mtype == TMessageType.EXCEPTION:
4693 
      x = TApplicationException()
4694 
      x.read(self._iprot)
4695 
      self._iprot.readMessageEnd()
4696 
      raise x
4697 
    result = updateShipmentAddress_result()
4698 
    result.read(self._iprot)
4699 
    self._iprot.readMessageEnd()
4700 
    if result.ex is not None:
4701 
      raise result.ex
4702 
    return
4703 
 
4285 rajveer 4704 
  def acceptOrdersForItemId(self, itemId, inventory):
4705 
    """
4706 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4707 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4708 
 
4285 rajveer 4709 
    Parameters:
4710 
     - itemId
4711 
     - inventory
4712 
    """
4713 
    self.send_acceptOrdersForItemId(itemId, inventory)
4714 
    return self.recv_acceptOrdersForItemId()
4715 
 
4716 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4717 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4718 
    args = acceptOrdersForItemId_args()
4719 
    args.itemId = itemId
4720 
    args.inventory = inventory
4721 
    args.write(self._oprot)
4722 
    self._oprot.writeMessageEnd()
4723 
    self._oprot.trans.flush()
4724 
 
4725 
  def recv_acceptOrdersForItemId(self, ):
4726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4727 
    if mtype == TMessageType.EXCEPTION:
4728 
      x = TApplicationException()
4729 
      x.read(self._iprot)
4730 
      self._iprot.readMessageEnd()
4731 
      raise x
4732 
    result = acceptOrdersForItemId_result()
4733 
    result.read(self._iprot)
4734 
    self._iprot.readMessageEnd()
4735 
    if result.success is not None:
4736 
      return result.success
4737 
    if result.ex is not None:
4738 
      raise result.ex
4739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4740 
 
4369 rajveer 4741 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4742 
    """
4743 
    Parameters:
4744 
     - vendorId
4745 
     - itemId
4746 
     - quantity
4747 
     - estimate
4369 rajveer 4748 
     - isReminder
4303 rajveer 4749 
    """
4369 rajveer 4750 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4751 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4752 
 
4369 rajveer 4753 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4754 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4755 
    args = markOrdersAsPORaised_args()
4756 
    args.vendorId = vendorId
4757 
    args.itemId = itemId
4758 
    args.quantity = quantity
4759 
    args.estimate = estimate
4369 rajveer 4760 
    args.isReminder = isReminder
4303 rajveer 4761 
    args.write(self._oprot)
4762 
    self._oprot.writeMessageEnd()
4763 
    self._oprot.trans.flush()
4764 
 
4765 
  def recv_markOrdersAsPORaised(self, ):
4766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4767 
    if mtype == TMessageType.EXCEPTION:
4768 
      x = TApplicationException()
4769 
      x.read(self._iprot)
4770 
      self._iprot.readMessageEnd()
4771 
      raise x
4772 
    result = markOrdersAsPORaised_result()
4773 
    result.read(self._iprot)
4774 
    self._iprot.readMessageEnd()
4775 
    if result.ex is not None:
4776 
      raise result.ex
4777 
    return
4778 
 
4369 rajveer 4779 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4780 
    """
4781 
    Parameters:
4782 
     - vendorId
4783 
     - itemId
4784 
     - quantity
4785 
     - estimate
4369 rajveer 4786 
     - isReminder
4303 rajveer 4787 
    """
4369 rajveer 4788 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4789 
    self.recv_markOrdersAsReversalInitiated()
4790 
 
4369 rajveer 4791 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4792 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4793 
    args = markOrdersAsReversalInitiated_args()
4794 
    args.vendorId = vendorId
4795 
    args.itemId = itemId
4796 
    args.quantity = quantity
4797 
    args.estimate = estimate
4369 rajveer 4798 
    args.isReminder = isReminder
4303 rajveer 4799 
    args.write(self._oprot)
4800 
    self._oprot.writeMessageEnd()
4801 
    self._oprot.trans.flush()
4802 
 
4803 
  def recv_markOrdersAsReversalInitiated(self, ):
4804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4805 
    if mtype == TMessageType.EXCEPTION:
4806 
      x = TApplicationException()
4807 
      x.read(self._iprot)
4808 
      self._iprot.readMessageEnd()
4809 
      raise x
4810 
    result = markOrdersAsReversalInitiated_result()
4811 
    result.read(self._iprot)
4812 
    self._iprot.readMessageEnd()
4813 
    if result.ex is not None:
4814 
      raise result.ex
4815 
    return
4816 
 
4369 rajveer 4817 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4818 
    """
4819 
    Parameters:
4820 
     - vendorId
4821 
     - itemId
4822 
     - quantity
4823 
     - estimate
4369 rajveer 4824 
     - isReminder
4303 rajveer 4825 
    """
4369 rajveer 4826 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4827 
    self.recv_markOrdersAsNotAvailabke()
4828 
 
4369 rajveer 4829 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4830 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4831 
    args = markOrdersAsNotAvailabke_args()
4832 
    args.vendorId = vendorId
4833 
    args.itemId = itemId
4834 
    args.quantity = quantity
4835 
    args.estimate = estimate
4369 rajveer 4836 
    args.isReminder = isReminder
4303 rajveer 4837 
    args.write(self._oprot)
4838 
    self._oprot.writeMessageEnd()
4839 
    self._oprot.trans.flush()
4840 
 
4841 
  def recv_markOrdersAsNotAvailabke(self, ):
4842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4843 
    if mtype == TMessageType.EXCEPTION:
4844 
      x = TApplicationException()
4845 
      x.read(self._iprot)
4846 
      self._iprot.readMessageEnd()
4847 
      raise x
4848 
    result = markOrdersAsNotAvailabke_result()
4849 
    result.read(self._iprot)
4850 
    self._iprot.readMessageEnd()
4851 
    if result.ex is not None:
4852 
      raise result.ex
4853 
    return
4854 
 
4369 rajveer 4855 
  def markOrdersAsTimeout(self, vendorId):
4856 
    """
4857 
    Parameters:
4858 
     - vendorId
4859 
    """
4860 
    self.send_markOrdersAsTimeout(vendorId)
4861 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4862 
 
4369 rajveer 4863 
  def send_markOrdersAsTimeout(self, vendorId):
4864 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4865 
    args = markOrdersAsTimeout_args()
4866 
    args.vendorId = vendorId
4867 
    args.write(self._oprot)
4868 
    self._oprot.writeMessageEnd()
4869 
    self._oprot.trans.flush()
4870 
 
4871 
  def recv_markOrdersAsTimeout(self, ):
4872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4873 
    if mtype == TMessageType.EXCEPTION:
4874 
      x = TApplicationException()
4875 
      x.read(self._iprot)
4876 
      self._iprot.readMessageEnd()
4877 
      raise x
4878 
    result = markOrdersAsTimeout_result()
4879 
    result.read(self._iprot)
4880 
    self._iprot.readMessageEnd()
4881 
    if result.success is not None:
4882 
      return result.success
4883 
    if result.ex is not None:
4884 
      raise result.ex
4885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4886 
 
4662 rajveer 4887 
  def markOrderAsLostInTransit(self, orderId):
4888 
    """
4889 
    Mark order as LOST_IN_TRANSIT
4890 
 
4891 
    Parameters:
4892 
     - orderId
4893 
    """
4894 
    self.send_markOrderAsLostInTransit(orderId)
4895 
    return self.recv_markOrderAsLostInTransit()
4896 
 
4897 
  def send_markOrderAsLostInTransit(self, orderId):
4898 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4899 
    args = markOrderAsLostInTransit_args()
4900 
    args.orderId = orderId
4901 
    args.write(self._oprot)
4902 
    self._oprot.writeMessageEnd()
4903 
    self._oprot.trans.flush()
4904 
 
4905 
  def recv_markOrderAsLostInTransit(self, ):
4906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4907 
    if mtype == TMessageType.EXCEPTION:
4908 
      x = TApplicationException()
4909 
      x.read(self._iprot)
4910 
      self._iprot.readMessageEnd()
4911 
      raise x
4912 
    result = markOrderAsLostInTransit_result()
4913 
    result.read(self._iprot)
4914 
    self._iprot.readMessageEnd()
4915 
    if result.success is not None:
4916 
      return result.success
4917 
    if result.ex is not None:
4918 
      raise result.ex
4919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4920 
 
4386 anupam.sin 4921 
  def getOrderForAwb(self, awb):
4922 
    """
4923 
    Returns the order corresponding to an AWB number
4369 rajveer 4924 
 
4386 anupam.sin 4925 
    Parameters:
4926 
     - awb
4927 
    """
4928 
    self.send_getOrderForAwb(awb)
4929 
    return self.recv_getOrderForAwb()
4930 
 
4931 
  def send_getOrderForAwb(self, awb):
4932 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4933 
    args = getOrderForAwb_args()
4934 
    args.awb = awb
4935 
    args.write(self._oprot)
4936 
    self._oprot.writeMessageEnd()
4937 
    self._oprot.trans.flush()
4938 
 
4939 
  def recv_getOrderForAwb(self, ):
4940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4941 
    if mtype == TMessageType.EXCEPTION:
4942 
      x = TApplicationException()
4943 
      x.read(self._iprot)
4944 
      self._iprot.readMessageEnd()
4945 
      raise x
4946 
    result = getOrderForAwb_result()
4947 
    result.read(self._iprot)
4948 
    self._iprot.readMessageEnd()
4949 
    if result.success is not None:
4950 
      return result.success
4951 
    if result.ex is not None:
4952 
      raise result.ex
4953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4954 
 
4910 phani.kuma 4955 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4956 
    """
4910 phani.kuma 4957 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4958 
 
4506 phani.kuma 4959 
    Parameters:
4960 
     - logistics_provider_id
4910 phani.kuma 4961 
     - order_status_list
4506 phani.kuma 4962 
    """
4910 phani.kuma 4963 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4964 
    return self.recv_getOrdersForProviderForStatus()
4965 
 
4910 phani.kuma 4966 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4967 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4968 
    args = getOrdersForProviderForStatus_args()
4969 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4970 
    args.order_status_list = order_status_list
4506 phani.kuma 4971 
    args.write(self._oprot)
4972 
    self._oprot.writeMessageEnd()
4973 
    self._oprot.trans.flush()
4974 
 
4975 
  def recv_getOrdersForProviderForStatus(self, ):
4976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4977 
    if mtype == TMessageType.EXCEPTION:
4978 
      x = TApplicationException()
4979 
      x.read(self._iprot)
4980 
      self._iprot.readMessageEnd()
4981 
      raise x
4982 
    result = getOrdersForProviderForStatus_result()
4983 
    result.read(self._iprot)
4984 
    self._iprot.readMessageEnd()
4985 
    if result.success is not None:
4986 
      return result.success
4987 
    if result.ex is not None:
4988 
      raise result.ex
4989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4990 
 
4600 varun.gupt 4991 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4992 
    """
4993 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4994 
 
4600 varun.gupt 4995 
    Parameters:
4996 
     - vendorId
4997 
     - billingDateFrom
4998 
     - billingDateTo
4999 
    """
5000 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5001 
    return self.recv_getBilledOrdersForVendor()
5002 
 
5003 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5004 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5005 
    args = getBilledOrdersForVendor_args()
5006 
    args.vendorId = vendorId
5007 
    args.billingDateFrom = billingDateFrom
5008 
    args.billingDateTo = billingDateTo
5009 
    args.write(self._oprot)
5010 
    self._oprot.writeMessageEnd()
5011 
    self._oprot.trans.flush()
5012 
 
5013 
  def recv_getBilledOrdersForVendor(self, ):
5014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5015 
    if mtype == TMessageType.EXCEPTION:
5016 
      x = TApplicationException()
5017 
      x.read(self._iprot)
5018 
      self._iprot.readMessageEnd()
5019 
      raise x
5020 
    result = getBilledOrdersForVendor_result()
5021 
    result.read(self._iprot)
5022 
    self._iprot.readMessageEnd()
5023 
    if result.success is not None:
5024 
      return result.success
5025 
    if result.ex is not None:
5026 
      raise result.ex
5027 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5028 
 
4607 rajveer 5029 
  def getSlippedSippingDateOrders(self, ):
5030 
    self.send_getSlippedSippingDateOrders()
5031 
    return self.recv_getSlippedSippingDateOrders()
5032 
 
5033 
  def send_getSlippedSippingDateOrders(self, ):
5034 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5035 
    args = getSlippedSippingDateOrders_args()
5036 
    args.write(self._oprot)
5037 
    self._oprot.writeMessageEnd()
5038 
    self._oprot.trans.flush()
5039 
 
5040 
  def recv_getSlippedSippingDateOrders(self, ):
5041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5042 
    if mtype == TMessageType.EXCEPTION:
5043 
      x = TApplicationException()
5044 
      x.read(self._iprot)
5045 
      self._iprot.readMessageEnd()
5046 
      raise x
5047 
    result = getSlippedSippingDateOrders_result()
5048 
    result.read(self._iprot)
5049 
    self._iprot.readMessageEnd()
5050 
    if result.success is not None:
5051 
      return result.success
5052 
    if result.ex is not None:
5053 
      raise result.ex
5054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5055 
 
4709 rajveer 5056 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5057 
    """
5058 
    Parameters:
5059 
     - cancelDateFrom
5060 
     - cancelDateTo
5061 
    """
5062 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5063 
    return self.recv_getCancelledOrders()
5064 
 
5065 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5066 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5067 
    args = getCancelledOrders_args()
5068 
    args.cancelDateFrom = cancelDateFrom
5069 
    args.cancelDateTo = cancelDateTo
5070 
    args.write(self._oprot)
5071 
    self._oprot.writeMessageEnd()
5072 
    self._oprot.trans.flush()
5073 
 
5074 
  def recv_getCancelledOrders(self, ):
5075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5076 
    if mtype == TMessageType.EXCEPTION:
5077 
      x = TApplicationException()
5078 
      x.read(self._iprot)
5079 
      self._iprot.readMessageEnd()
5080 
      raise x
5081 
    result = getCancelledOrders_result()
5082 
    result.read(self._iprot)
5083 
    self._iprot.readMessageEnd()
5084 
    if result.success is not None:
5085 
      return result.success
5086 
    if result.ex is not None:
5087 
      raise result.ex
5088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5089 
 
4600 varun.gupt 5090 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5091 
    """
5092 
    Parameters:
5093 
     - mapAWBAndAmount
5094 
    """
5095 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5096 
    self.recv_saveBluedartSettlements()
5097 
 
5098 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5099 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5100 
    args = saveBluedartSettlements_args()
5101 
    args.mapAWBAndAmount = mapAWBAndAmount
5102 
    args.write(self._oprot)
5103 
    self._oprot.writeMessageEnd()
5104 
    self._oprot.trans.flush()
5105 
 
5106 
  def recv_saveBluedartSettlements(self, ):
5107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5108 
    if mtype == TMessageType.EXCEPTION:
5109 
      x = TApplicationException()
5110 
      x.read(self._iprot)
5111 
      self._iprot.readMessageEnd()
5112 
      raise x
5113 
    result = saveBluedartSettlements_result()
5114 
    result.read(self._iprot)
5115 
    self._iprot.readMessageEnd()
5116 
    if result.ex is not None:
5117 
      raise result.ex
5118 
    return
5119 
 
4905 varun.gupt 5120 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5121 
    """
5122 
    Parameters:
5123 
     - settlementDate
5124 
     - paymentGatewayId
4905 varun.gupt 5125 
     - referenceId
4600 varun.gupt 5126 
     - serviceTax
5127 
     - otherCharges
5128 
     - netCollection
5129 
    """
4905 varun.gupt 5130 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5131 
    self.recv_savePaymentSettlements()
5132 
 
4905 varun.gupt 5133 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5134 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5135 
    args = savePaymentSettlements_args()
5136 
    args.settlementDate = settlementDate
5137 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5138 
    args.referenceId = referenceId
4600 varun.gupt 5139 
    args.serviceTax = serviceTax
5140 
    args.otherCharges = otherCharges
5141 
    args.netCollection = netCollection
5142 
    args.write(self._oprot)
5143 
    self._oprot.writeMessageEnd()
5144 
    self._oprot.trans.flush()
5145 
 
5146 
  def recv_savePaymentSettlements(self, ):
5147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5148 
    if mtype == TMessageType.EXCEPTION:
5149 
      x = TApplicationException()
5150 
      x.read(self._iprot)
5151 
      self._iprot.readMessageEnd()
5152 
      raise x
5153 
    result = savePaymentSettlements_result()
5154 
    result.read(self._iprot)
5155 
    self._iprot.readMessageEnd()
5156 
    if result.ex is not None:
5157 
      raise result.ex
5158 
    return
5159 
 
5160 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5161 
    """
5162 
    Parameters:
5163 
     - settlementId
5164 
     - settlementDate
5165 
     - transactionDateFrom
5166 
     - transactionDateTo
5167 
     - amount
5168 
    """
5169 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5170 
    self.recv_saveEBSSettlementSummary()
5171 
 
5172 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5173 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5174 
    args = saveEBSSettlementSummary_args()
5175 
    args.settlementId = settlementId
5176 
    args.settlementDate = settlementDate
5177 
    args.transactionDateFrom = transactionDateFrom
5178 
    args.transactionDateTo = transactionDateTo
5179 
    args.amount = amount
5180 
    args.write(self._oprot)
5181 
    self._oprot.writeMessageEnd()
5182 
    self._oprot.trans.flush()
5183 
 
5184 
  def recv_saveEBSSettlementSummary(self, ):
5185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5186 
    if mtype == TMessageType.EXCEPTION:
5187 
      x = TApplicationException()
5188 
      x.read(self._iprot)
5189 
      self._iprot.readMessageEnd()
5190 
      raise x
5191 
    result = saveEBSSettlementSummary_result()
5192 
    result.read(self._iprot)
5193 
    self._iprot.readMessageEnd()
5194 
    if result.ex is not None:
5195 
      raise result.ex
5196 
    return
5197 
 
5386 phani.kuma 5198 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5199 
    """
5200 
    Parameters:
5189 varun.gupt 5201 
     - referenceId
5202 
     - isRefund
4600 varun.gupt 5203 
    """
5386 phani.kuma 5204 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5205 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5206 
 
5386 phani.kuma 5207 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5208 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5209 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5210 
    args.referenceId = referenceId
5211 
    args.isRefund = isRefund
4600 varun.gupt 5212 
    args.write(self._oprot)
5213 
    self._oprot.writeMessageEnd()
5214 
    self._oprot.trans.flush()
5215 
 
5386 phani.kuma 5216 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5218 
    if mtype == TMessageType.EXCEPTION:
5219 
      x = TApplicationException()
5220 
      x.read(self._iprot)
5221 
      self._iprot.readMessageEnd()
5222 
      raise x
5386 phani.kuma 5223 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5224 
    result.read(self._iprot)
5225 
    self._iprot.readMessageEnd()
5226 
    if result.success is not None:
5227 
      return result.success
5228 
    if result.ex is not None:
5229 
      raise result.ex
5386 phani.kuma 5230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5231 
 
5386 phani.kuma 5232 
  def getSettlementForCod(self, orderId, isRefund):
5233 
    """
5234 
    Parameters:
5235 
     - orderId
5236 
     - isRefund
5237 
    """
5238 
    self.send_getSettlementForCod(orderId, isRefund)
5239 
    return self.recv_getSettlementForCod()
5240 
 
5241 
  def send_getSettlementForCod(self, orderId, isRefund):
5242 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5243 
    args = getSettlementForCod_args()
5244 
    args.orderId = orderId
5245 
    args.isRefund = isRefund
5246 
    args.write(self._oprot)
5247 
    self._oprot.writeMessageEnd()
5248 
    self._oprot.trans.flush()
5249 
 
5250 
  def recv_getSettlementForCod(self, ):
5251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5252 
    if mtype == TMessageType.EXCEPTION:
5253 
      x = TApplicationException()
5254 
      x.read(self._iprot)
5255 
      self._iprot.readMessageEnd()
5256 
      raise x
5257 
    result = getSettlementForCod_result()
5258 
    result.read(self._iprot)
5259 
    self._iprot.readMessageEnd()
5260 
    if result.success is not None:
5261 
      return result.success
5262 
    if result.ex is not None:
5263 
      raise result.ex
5264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5265 
 
4600 varun.gupt 5266 
  def getEBSSettlementSummaries(self, ):
5267 
    self.send_getEBSSettlementSummaries()
5268 
    return self.recv_getEBSSettlementSummaries()
5269 
 
5270 
  def send_getEBSSettlementSummaries(self, ):
5271 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5272 
    args = getEBSSettlementSummaries_args()
5273 
    args.write(self._oprot)
5274 
    self._oprot.writeMessageEnd()
5275 
    self._oprot.trans.flush()
5276 
 
5277 
  def recv_getEBSSettlementSummaries(self, ):
5278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5279 
    if mtype == TMessageType.EXCEPTION:
5280 
      x = TApplicationException()
5281 
      x.read(self._iprot)
5282 
      self._iprot.readMessageEnd()
5283 
      raise x
5284 
    result = getEBSSettlementSummaries_result()
5285 
    result.read(self._iprot)
5286 
    self._iprot.readMessageEnd()
5287 
    if result.success is not None:
5288 
      return result.success
5289 
    if result.ex is not None:
5290 
      raise result.ex
5291 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5292 
 
5293 
  def markEBSSettlementUploaded(self, settlementId):
5294 
    """
5295 
    Parameters:
5296 
     - settlementId
5297 
    """
5298 
    self.send_markEBSSettlementUploaded(settlementId)
5299 
    self.recv_markEBSSettlementUploaded()
5300 
 
5301 
  def send_markEBSSettlementUploaded(self, settlementId):
5302 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5303 
    args = markEBSSettlementUploaded_args()
5304 
    args.settlementId = settlementId
5305 
    args.write(self._oprot)
5306 
    self._oprot.writeMessageEnd()
5307 
    self._oprot.trans.flush()
5308 
 
5309 
  def recv_markEBSSettlementUploaded(self, ):
5310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5311 
    if mtype == TMessageType.EXCEPTION:
5312 
      x = TApplicationException()
5313 
      x.read(self._iprot)
5314 
      self._iprot.readMessageEnd()
5315 
      raise x
5316 
    result = markEBSSettlementUploaded_result()
5317 
    result.read(self._iprot)
5318 
    self._iprot.readMessageEnd()
5319 
    if result.ex is not None:
5320 
      raise result.ex
5321 
    return
5322 
 
5323 
  def getEBSSettlementDate(self, settlementId):
5324 
    """
5325 
    Parameters:
5326 
     - settlementId
5327 
    """
5328 
    self.send_getEBSSettlementDate(settlementId)
5329 
    return self.recv_getEBSSettlementDate()
5330 
 
5331 
  def send_getEBSSettlementDate(self, settlementId):
5332 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5333 
    args = getEBSSettlementDate_args()
5334 
    args.settlementId = settlementId
5335 
    args.write(self._oprot)
5336 
    self._oprot.writeMessageEnd()
5337 
    self._oprot.trans.flush()
5338 
 
5339 
  def recv_getEBSSettlementDate(self, ):
5340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5341 
    if mtype == TMessageType.EXCEPTION:
5342 
      x = TApplicationException()
5343 
      x.read(self._iprot)
5344 
      self._iprot.readMessageEnd()
5345 
      raise x
5346 
    result = getEBSSettlementDate_result()
5347 
    result.read(self._iprot)
5348 
    self._iprot.readMessageEnd()
5349 
    if result.success is not None:
5350 
      return result.success
5351 
    if result.ex is not None:
5352 
      raise result.ex
5353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5354 
 
4715 varun.gupt 5355 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5356 
    """
5357 
    Parameters:
5358 
     - settlementDateFrom
5359 
     - settlementDateTo
5360 
     - isRefund
5361 
    """
5362 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5363 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5364 
 
4715 varun.gupt 5365 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5366 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5367 
    args = getSettlementsByDate_args()
5368 
    args.settlementDateFrom = settlementDateFrom
5369 
    args.settlementDateTo = settlementDateTo
5370 
    args.isRefund = isRefund
5371 
    args.write(self._oprot)
5372 
    self._oprot.writeMessageEnd()
5373 
    self._oprot.trans.flush()
5374 
 
5375 
  def recv_getSettlementsByDate(self, ):
5376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5377 
    if mtype == TMessageType.EXCEPTION:
5378 
      x = TApplicationException()
5379 
      x.read(self._iprot)
5380 
      self._iprot.readMessageEnd()
5381 
      raise x
5382 
    result = getSettlementsByDate_result()
5383 
    result.read(self._iprot)
5384 
    self._iprot.readMessageEnd()
5385 
    if result.success is not None:
5386 
      return result.success
5387 
    if result.ex is not None:
5388 
      raise result.ex
5389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5390 
 
5391 
  def getReshippedOrderIds(self, orderIds):
5392 
    """
5393 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5394 
 
5395 
    Parameters:
5396 
     - orderIds
5397 
    """
5398 
    self.send_getReshippedOrderIds(orderIds)
5399 
    return self.recv_getReshippedOrderIds()
5400 
 
5401 
  def send_getReshippedOrderIds(self, orderIds):
5402 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5403 
    args = getReshippedOrderIds_args()
5404 
    args.orderIds = orderIds
5405 
    args.write(self._oprot)
5406 
    self._oprot.writeMessageEnd()
5407 
    self._oprot.trans.flush()
5408 
 
5409 
  def recv_getReshippedOrderIds(self, ):
5410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5411 
    if mtype == TMessageType.EXCEPTION:
5412 
      x = TApplicationException()
5413 
      x.read(self._iprot)
5414 
      self._iprot.readMessageEnd()
5415 
      raise x
5416 
    result = getReshippedOrderIds_result()
5417 
    result.read(self._iprot)
5418 
    self._iprot.readMessageEnd()
5419 
    if result.success is not None:
5420 
      return result.success
5421 
    if result.ex is not None:
5422 
      raise result.ex
5423 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5424 
 
5481 phani.kuma 5425 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5426 
    """
5427 
    Parameters:
5428 
     - vendorId
5481 phani.kuma 5429 
     - onlyVendorNotPaid
5430 
     - billingDateFrom
5431 
     - billingDateTo
4875 varun.gupt 5432 
    """
5481 phani.kuma 5433 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5434 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5435 
 
5481 phani.kuma 5436 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5437 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5438 
    args = getBilledOrders_args()
4875 varun.gupt 5439 
    args.vendorId = vendorId
5481 phani.kuma 5440 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5441 
    args.billingDateFrom = billingDateFrom
5442 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5443 
    args.write(self._oprot)
5444 
    self._oprot.writeMessageEnd()
5445 
    self._oprot.trans.flush()
5446 
 
5481 phani.kuma 5447 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5448 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5449 
    if mtype == TMessageType.EXCEPTION:
5450 
      x = TApplicationException()
5451 
      x.read(self._iprot)
5452 
      self._iprot.readMessageEnd()
5453 
      raise x
5481 phani.kuma 5454 
    result = getBilledOrders_result()
4875 varun.gupt 5455 
    result.read(self._iprot)
5456 
    self._iprot.readMessageEnd()
5457 
    if result.success is not None:
5458 
      return result.success
5459 
    if result.ex is not None:
5460 
      raise result.ex
5481 phani.kuma 5461 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5462 
 
5031 varun.gupt 5463 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5464 
    """
5465 
    Parameters:
5466 
     - startDate
5467 
     - endDate
5468 
    """
5469 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5470 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5471 
 
5031 varun.gupt 5472 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5473 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5474 
    args = getStatusDistributionOfOrders_args()
5475 
    args.startDate = startDate
5476 
    args.endDate = endDate
5477 
    args.write(self._oprot)
5478 
    self._oprot.writeMessageEnd()
5479 
    self._oprot.trans.flush()
5480 
 
5481 
  def recv_getStatusDistributionOfOrders(self, ):
5482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5483 
    if mtype == TMessageType.EXCEPTION:
5484 
      x = TApplicationException()
5485 
      x.read(self._iprot)
5486 
      self._iprot.readMessageEnd()
5487 
      raise x
5488 
    result = getStatusDistributionOfOrders_result()
5489 
    result.read(self._iprot)
5490 
    self._iprot.readMessageEnd()
5491 
    if result.success is not None:
5492 
      return result.success
5493 
    if result.ex is not None:
5494 
      raise result.ex
5495 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5496 
 
5067 varun.gupt 5497 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5498 
    """
5499 
    Parameters:
5500 
     - status
5501 
     - startDatetime
5502 
     - endDatetime
5503 
    """
5504 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5505 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5506 
 
5067 varun.gupt 5507 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5508 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5509 
    args = getOrderIdsForStatus_args()
5510 
    args.status = status
5511 
    args.startDatetime = startDatetime
5512 
    args.endDatetime = endDatetime
5513 
    args.write(self._oprot)
5514 
    self._oprot.writeMessageEnd()
5515 
    self._oprot.trans.flush()
5516 
 
5517 
  def recv_getOrderIdsForStatus(self, ):
5518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5519 
    if mtype == TMessageType.EXCEPTION:
5520 
      x = TApplicationException()
5521 
      x.read(self._iprot)
5522 
      self._iprot.readMessageEnd()
5523 
      raise x
5524 
    result = getOrderIdsForStatus_result()
5525 
    result.read(self._iprot)
5526 
    self._iprot.readMessageEnd()
5527 
    if result.success is not None:
5528 
      return result.success
5529 
    if result.ex is not None:
5530 
      raise result.ex
5531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5532 
 
5348 anupam.sin 5533 
  def updateCODAgent(self, agent, orderId):
5534 
    """
5535 
    Updates the agent who handled the COD verification call
5536 
 
5537 
    Parameters:
5538 
     - agent
5539 
     - orderId
5540 
    """
5541 
    self.send_updateCODAgent(agent, orderId)
5542 
    self.recv_updateCODAgent()
5543 
 
5544 
  def send_updateCODAgent(self, agent, orderId):
5545 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5546 
    args = updateCODAgent_args()
5547 
    args.agent = agent
5548 
    args.orderId = orderId
5549 
    args.write(self._oprot)
5550 
    self._oprot.writeMessageEnd()
5551 
    self._oprot.trans.flush()
5552 
 
5553 
  def recv_updateCODAgent(self, ):
5554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5555 
    if mtype == TMessageType.EXCEPTION:
5556 
      x = TApplicationException()
5557 
      x.read(self._iprot)
5558 
      self._iprot.readMessageEnd()
5559 
      raise x
5560 
    result = updateCODAgent_result()
5561 
    result.read(self._iprot)
5562 
    self._iprot.readMessageEnd()
5563 
    if result.ex is not None:
5564 
      raise result.ex
5565 
    return
5566 
 
5099 varun.gupt 5567 
  def updateOrderAsPaidToVendor(self, orderId):
5568 
    """
5569 
    Parameters:
5570 
     - orderId
5571 
    """
5572 
    self.send_updateOrderAsPaidToVendor(orderId)
5573 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5574 
 
5099 varun.gupt 5575 
  def send_updateOrderAsPaidToVendor(self, orderId):
5576 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5577 
    args = updateOrderAsPaidToVendor_args()
5578 
    args.orderId = orderId
5579 
    args.write(self._oprot)
5580 
    self._oprot.writeMessageEnd()
5581 
    self._oprot.trans.flush()
5582 
 
5583 
  def recv_updateOrderAsPaidToVendor(self, ):
5584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5585 
    if mtype == TMessageType.EXCEPTION:
5586 
      x = TApplicationException()
5587 
      x.read(self._iprot)
5588 
      self._iprot.readMessageEnd()
5589 
      raise x
5590 
    result = updateOrderAsPaidToVendor_result()
5591 
    result.read(self._iprot)
5592 
    self._iprot.readMessageEnd()
5593 
    if result.ex is not None:
5594 
      raise result.ex
5595 
    return
5596 
 
5386 phani.kuma 5597 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5598 
    """
5599 
    Parameters:
5600 
     - orderId
5601 
    """
5602 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5603 
    self.recv_updateOrderOnlyAsPaidToVendor()
5604 
 
5605 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5606 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5607 
    args = updateOrderOnlyAsPaidToVendor_args()
5608 
    args.orderId = orderId
5609 
    args.write(self._oprot)
5610 
    self._oprot.writeMessageEnd()
5611 
    self._oprot.trans.flush()
5612 
 
5613 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5615 
    if mtype == TMessageType.EXCEPTION:
5616 
      x = TApplicationException()
5617 
      x.read(self._iprot)
5618 
      self._iprot.readMessageEnd()
5619 
      raise x
5620 
    result = updateOrderOnlyAsPaidToVendor_result()
5621 
    result.read(self._iprot)
5622 
    self._iprot.readMessageEnd()
5623 
    if result.ex is not None:
5624 
      raise result.ex
5625 
    return
5626 
 
5208 varun.gupt 5627 
  def getRefundedOrdersMarkedPaid(self, ):
5628 
    self.send_getRefundedOrdersMarkedPaid()
5629 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5630 
 
5208 varun.gupt 5631 
  def send_getRefundedOrdersMarkedPaid(self, ):
5632 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5633 
    args = getRefundedOrdersMarkedPaid_args()
5634 
    args.write(self._oprot)
5635 
    self._oprot.writeMessageEnd()
5636 
    self._oprot.trans.flush()
5637 
 
5638 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5640 
    if mtype == TMessageType.EXCEPTION:
5641 
      x = TApplicationException()
5642 
      x.read(self._iprot)
5643 
      self._iprot.readMessageEnd()
5644 
      raise x
5645 
    result = getRefundedOrdersMarkedPaid_result()
5646 
    result.read(self._iprot)
5647 
    self._iprot.readMessageEnd()
5648 
    if result.success is not None:
5649 
      return result.success
5650 
    if result.ex is not None:
5651 
      raise result.ex
5652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5653 
 
5447 anupam.sin 5654 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5655 
    """
5656 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5657 
 
5447 anupam.sin 5658 
 
5659 
    Parameters:
5660 
     - minOrderId
5661 
     - maxOrderId
5662 
    """
5663 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5664 
    return self.recv_getAllVerificationAgents()
5665 
 
5666 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5667 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5668 
    args = getAllVerificationAgents_args()
5669 
    args.minOrderId = minOrderId
5670 
    args.maxOrderId = maxOrderId
5671 
    args.write(self._oprot)
5672 
    self._oprot.writeMessageEnd()
5673 
    self._oprot.trans.flush()
5674 
 
5675 
  def recv_getAllVerificationAgents(self, ):
5676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5677 
    if mtype == TMessageType.EXCEPTION:
5678 
      x = TApplicationException()
5679 
      x.read(self._iprot)
5680 
      self._iprot.readMessageEnd()
5681 
      raise x
5682 
    result = getAllVerificationAgents_result()
5683 
    result.read(self._iprot)
5684 
    self._iprot.readMessageEnd()
5685 
    if result.success is not None:
5686 
      return result.success
5687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5688 
 
5527 anupam.sin 5689 
  def getAllAttributesForOrderId(self, orderId):
5690 
    """
5691 
    gets all attributes for a given orderId
5447 anupam.sin 5692 
 
5527 anupam.sin 5693 
    Parameters:
5694 
     - orderId
5695 
    """
5696 
    self.send_getAllAttributesForOrderId(orderId)
5697 
    return self.recv_getAllAttributesForOrderId()
5698 
 
5699 
  def send_getAllAttributesForOrderId(self, orderId):
5700 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5701 
    args = getAllAttributesForOrderId_args()
5702 
    args.orderId = orderId
5703 
    args.write(self._oprot)
5704 
    self._oprot.writeMessageEnd()
5705 
    self._oprot.trans.flush()
5706 
 
5707 
  def recv_getAllAttributesForOrderId(self, ):
5708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5709 
    if mtype == TMessageType.EXCEPTION:
5710 
      x = TApplicationException()
5711 
      x.read(self._iprot)
5712 
      self._iprot.readMessageEnd()
5713 
      raise x
5714 
    result = getAllAttributesForOrderId_result()
5715 
    result.read(self._iprot)
5716 
    self._iprot.readMessageEnd()
5717 
    if result.success is not None:
5718 
      return result.success
5719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5720 
 
5676 rajveer 5721 
  def setOrderAttributes(self, orderId, attributes):
5722 
    """
5723 
    sets attributes for an order
5724 
 
5725 
    Parameters:
5726 
     - orderId
5727 
     - attributes
5728 
    """
5729 
    self.send_setOrderAttributes(orderId, attributes)
5730 
    self.recv_setOrderAttributes()
5731 
 
5732 
  def send_setOrderAttributes(self, orderId, attributes):
5733 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5734 
    args = setOrderAttributes_args()
5735 
    args.orderId = orderId
5736 
    args.attributes = attributes
5737 
    args.write(self._oprot)
5738 
    self._oprot.writeMessageEnd()
5739 
    self._oprot.trans.flush()
5740 
 
5741 
  def recv_setOrderAttributes(self, ):
5742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5743 
    if mtype == TMessageType.EXCEPTION:
5744 
      x = TApplicationException()
5745 
      x.read(self._iprot)
5746 
      self._iprot.readMessageEnd()
5747 
      raise x
5748 
    result = setOrderAttributes_result()
5749 
    result.read(self._iprot)
5750 
    self._iprot.readMessageEnd()
5751 
    return
5752 
 
5527 anupam.sin 5753 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5754 
    """
5755 
    sets attributes for all orders in a transaction
5756 
 
5757 
    Parameters:
5758 
     - transactionId
5759 
     - attribute
5760 
    """
5761 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5762 
    self.recv_setOrderAttributeForTransaction()
5763 
 
5764 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5765 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5766 
    args = setOrderAttributeForTransaction_args()
5767 
    args.transactionId = transactionId
5768 
    args.attribute = attribute
5769 
    args.write(self._oprot)
5770 
    self._oprot.writeMessageEnd()
5771 
    self._oprot.trans.flush()
5772 
 
5773 
  def recv_setOrderAttributeForTransaction(self, ):
5774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5775 
    if mtype == TMessageType.EXCEPTION:
5776 
      x = TApplicationException()
5777 
      x.read(self._iprot)
5778 
      self._iprot.readMessageEnd()
5779 
      raise x
5780 
    result = setOrderAttributeForTransaction_result()
5781 
    result.read(self._iprot)
5782 
    self._iprot.readMessageEnd()
5783 
    return
5784 
 
5553 rajveer 5785 
  def getReceivePendingOrders(self, storeId):
5786 
    """
5787 
    Parameters:
5788 
     - storeId
5789 
    """
5790 
    self.send_getReceivePendingOrders(storeId)
5791 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5792 
 
5553 rajveer 5793 
  def send_getReceivePendingOrders(self, storeId):
5794 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5795 
    args = getReceivePendingOrders_args()
5796 
    args.storeId = storeId
5797 
    args.write(self._oprot)
5798 
    self._oprot.writeMessageEnd()
5799 
    self._oprot.trans.flush()
5800 
 
5801 
  def recv_getReceivePendingOrders(self, ):
5802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5803 
    if mtype == TMessageType.EXCEPTION:
5804 
      x = TApplicationException()
5805 
      x.read(self._iprot)
5806 
      self._iprot.readMessageEnd()
5807 
      raise x
5808 
    result = getReceivePendingOrders_result()
5809 
    result.read(self._iprot)
5810 
    self._iprot.readMessageEnd()
5811 
    if result.success is not None:
5812 
      return result.success
5813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5814 
 
5815 
  def getReceivedAtStoreOrders(self, storeId):
5816 
    """
5817 
    Parameters:
5818 
     - storeId
5819 
    """
5820 
    self.send_getReceivedAtStoreOrders(storeId)
5821 
    return self.recv_getReceivedAtStoreOrders()
5822 
 
5823 
  def send_getReceivedAtStoreOrders(self, storeId):
5824 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5825 
    args = getReceivedAtStoreOrders_args()
5826 
    args.storeId = storeId
5827 
    args.write(self._oprot)
5828 
    self._oprot.writeMessageEnd()
5829 
    self._oprot.trans.flush()
5830 
 
5831 
  def recv_getReceivedAtStoreOrders(self, ):
5832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5833 
    if mtype == TMessageType.EXCEPTION:
5834 
      x = TApplicationException()
5835 
      x.read(self._iprot)
5836 
      self._iprot.readMessageEnd()
5837 
      raise x
5838 
    result = getReceivedAtStoreOrders_result()
5839 
    result.read(self._iprot)
5840 
    self._iprot.readMessageEnd()
5841 
    if result.success is not None:
5842 
      return result.success
5843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5844 
 
5713 rajveer 5845 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5846 
    """
5847 
    Parameters:
5848 
     - storeId
5849 
     - fromDate
5850 
     - toDate
5851 
     - onlyCod
5852 
    """
5853 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5854 
    return self.recv_getOrdersCollectionAtStore()
5855 
 
5856 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5857 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5858 
    args = getOrdersCollectionAtStore_args()
5859 
    args.storeId = storeId
5860 
    args.fromDate = fromDate
5861 
    args.toDate = toDate
5862 
    args.onlyCod = onlyCod
5863 
    args.write(self._oprot)
5864 
    self._oprot.writeMessageEnd()
5865 
    self._oprot.trans.flush()
5866 
 
5867 
  def recv_getOrdersCollectionAtStore(self, ):
5868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5869 
    if mtype == TMessageType.EXCEPTION:
5870 
      x = TApplicationException()
5871 
      x.read(self._iprot)
5872 
      self._iprot.readMessageEnd()
5873 
      raise x
5874 
    result = getOrdersCollectionAtStore_result()
5875 
    result.read(self._iprot)
5876 
    self._iprot.readMessageEnd()
5877 
    if result.success is not None:
5878 
      return result.success
5879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5880 
 
5833 rajveer 5881 
  def getOrderAttributeValue(self, orderId, attributeName):
5882 
    """
5883 
    Parameters:
5884 
     - orderId
5885 
     - attributeName
5886 
    """
5887 
    self.send_getOrderAttributeValue(orderId, attributeName)
5888 
    return self.recv_getOrderAttributeValue()
5889 
 
5890 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5891 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5892 
    args = getOrderAttributeValue_args()
5893 
    args.orderId = orderId
5894 
    args.attributeName = attributeName
5895 
    args.write(self._oprot)
5896 
    self._oprot.writeMessageEnd()
5897 
    self._oprot.trans.flush()
5898 
 
5899 
  def recv_getOrderAttributeValue(self, ):
5900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5901 
    if mtype == TMessageType.EXCEPTION:
5902 
      x = TApplicationException()
5903 
      x.read(self._iprot)
5904 
      self._iprot.readMessageEnd()
5905 
      raise x
5906 
    result = getOrderAttributeValue_result()
5907 
    result.read(self._iprot)
5908 
    self._iprot.readMessageEnd()
5909 
    if result.success is not None:
5910 
      return result.success
5911 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5912 
 
6019 rajveer 5913 
  def changeJacketNumber(self, orderId, jacketNumber):
5914 
    """
5915 
    Parameters:
5916 
     - orderId
5917 
     - jacketNumber
5918 
    """
5919 
    self.send_changeJacketNumber(orderId, jacketNumber)
5920 
    return self.recv_changeJacketNumber()
5921 
 
5922 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5923 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5924 
    args = changeJacketNumber_args()
5925 
    args.orderId = orderId
5926 
    args.jacketNumber = jacketNumber
5927 
    args.write(self._oprot)
5928 
    self._oprot.writeMessageEnd()
5929 
    self._oprot.trans.flush()
5930 
 
5931 
  def recv_changeJacketNumber(self, ):
5932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5933 
    if mtype == TMessageType.EXCEPTION:
5934 
      x = TApplicationException()
5935 
      x.read(self._iprot)
5936 
      self._iprot.readMessageEnd()
5937 
      raise x
5938 
    result = changeJacketNumber_result()
5939 
    result.read(self._iprot)
5940 
    self._iprot.readMessageEnd()
5941 
    if result.success is not None:
5942 
      return result.success
5943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5944 
 
5945 
  def markOrderAsRtoInTransit(self, orderId):
5946 
    """
5947 
    Parameters:
5948 
     - orderId
5949 
    """
5950 
    self.send_markOrderAsRtoInTransit(orderId)
5951 
    return self.recv_markOrderAsRtoInTransit()
5952 
 
5953 
  def send_markOrderAsRtoInTransit(self, orderId):
5954 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5955 
    args = markOrderAsRtoInTransit_args()
5956 
    args.orderId = orderId
5957 
    args.write(self._oprot)
5958 
    self._oprot.writeMessageEnd()
5959 
    self._oprot.trans.flush()
5960 
 
5961 
  def recv_markOrderAsRtoInTransit(self, ):
5962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5963 
    if mtype == TMessageType.EXCEPTION:
5964 
      x = TApplicationException()
5965 
      x.read(self._iprot)
5966 
      self._iprot.readMessageEnd()
5967 
      raise x
5968 
    result = markOrderAsRtoInTransit_result()
5969 
    result.read(self._iprot)
5970 
    self._iprot.readMessageEnd()
5971 
    if result.success is not None:
5972 
      return result.success
5973 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5974 
 
5593 mandeep.dh 5975 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5976 
    """
5977 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5978 
    invoked while scanning IN of items.
5553 rajveer 5979 
 
5593 mandeep.dh 5980 
    Parameters:
5981 
     - itemId
5982 
     - quantity
5983 
     - fulfilmentWarehouseId
5984 
     - billingWarehouseId
5985 
    """
5986 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5987 
    self.recv_acceptOrderForItem()
5988 
 
5989 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5990 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5991 
    args = acceptOrderForItem_args()
5992 
    args.itemId = itemId
5993 
    args.quantity = quantity
5994 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5995 
    args.billingWarehouseId = billingWarehouseId
5996 
    args.write(self._oprot)
5997 
    self._oprot.writeMessageEnd()
5998 
    self._oprot.trans.flush()
5999 
 
6000 
  def recv_acceptOrderForItem(self, ):
6001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6002 
    if mtype == TMessageType.EXCEPTION:
6003 
      x = TApplicationException()
6004 
      x.read(self._iprot)
6005 
      self._iprot.readMessageEnd()
6006 
      raise x
6007 
    result = acceptOrderForItem_result()
6008 
    result.read(self._iprot)
6009 
    self._iprot.readMessageEnd()
6010 
    return
6011 
 
6000 mandeep.dh 6012 
  def createRechargeOrder(self, rechargeOrder):
6013 
    """
6014 
    Parameters:
6015 
     - rechargeOrder
6016 
    """
6017 
    self.send_createRechargeOrder(rechargeOrder)
6018 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6019 
 
6000 mandeep.dh 6020 
  def send_createRechargeOrder(self, rechargeOrder):
6021 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6022 
    args = createRechargeOrder_args()
6023 
    args.rechargeOrder = rechargeOrder
6024 
    args.write(self._oprot)
6025 
    self._oprot.writeMessageEnd()
6026 
    self._oprot.trans.flush()
6027 
 
6028 
  def recv_createRechargeOrder(self, ):
6029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6030 
    if mtype == TMessageType.EXCEPTION:
6031 
      x = TApplicationException()
6032 
      x.read(self._iprot)
6033 
      self._iprot.readMessageEnd()
6034 
      raise x
6035 
    result = createRechargeOrder_result()
6036 
    result.read(self._iprot)
6037 
    self._iprot.readMessageEnd()
6038 
    if result.success is not None:
6039 
      return result.success
6040 
    if result.ex is not None:
6041 
      raise result.ex
6042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6043 
 
6031 rajveer 6044 
  def getRechargeOrder(self, rechargeRrderId):
6045 
    """
6046 
    Parameters:
6047 
     - rechargeRrderId
6048 
    """
6049 
    self.send_getRechargeOrder(rechargeRrderId)
6050 
    return self.recv_getRechargeOrder()
6051 
 
6052 
  def send_getRechargeOrder(self, rechargeRrderId):
6053 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6054 
    args = getRechargeOrder_args()
6055 
    args.rechargeRrderId = rechargeRrderId
6056 
    args.write(self._oprot)
6057 
    self._oprot.writeMessageEnd()
6058 
    self._oprot.trans.flush()
6059 
 
6060 
  def recv_getRechargeOrder(self, ):
6061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6062 
    if mtype == TMessageType.EXCEPTION:
6063 
      x = TApplicationException()
6064 
      x.read(self._iprot)
6065 
      self._iprot.readMessageEnd()
6066 
      raise x
6067 
    result = getRechargeOrder_result()
6068 
    result.read(self._iprot)
6069 
    self._iprot.readMessageEnd()
6070 
    if result.success is not None:
6071 
      return result.success
6072 
    if result.ex is not None:
6073 
      raise result.ex
6074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6075 
 
6076 
  def getRechargeOrders(self, userId):
6077 
    """
6078 
    Parameters:
6079 
     - userId
6080 
    """
6081 
    self.send_getRechargeOrders(userId)
6082 
    return self.recv_getRechargeOrders()
6083 
 
6084 
  def send_getRechargeOrders(self, userId):
6085 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6086 
    args = getRechargeOrders_args()
6087 
    args.userId = userId
6088 
    args.write(self._oprot)
6089 
    self._oprot.writeMessageEnd()
6090 
    self._oprot.trans.flush()
6091 
 
6092 
  def recv_getRechargeOrders(self, ):
6093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6094 
    if mtype == TMessageType.EXCEPTION:
6095 
      x = TApplicationException()
6096 
      x.read(self._iprot)
6097 
      self._iprot.readMessageEnd()
6098 
      raise x
6099 
    result = getRechargeOrders_result()
6100 
    result.read(self._iprot)
6101 
    self._iprot.readMessageEnd()
6102 
    if result.success is not None:
6103 
      return result.success
6104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6105 
 
6000 mandeep.dh 6106 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6107 
    """
6108 
    Parameters:
6109 
     - rechargeOrderId
6110 
     - rechargeOrderStatus
6111 
    """
6112 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6113 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6114 
 
6115 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6116 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6117 
    args = updateRechargeOrderStatus_args()
6118 
    args.rechargeOrderId = rechargeOrderId
6119 
    args.rechargeOrderStatus = rechargeOrderStatus
6120 
    args.write(self._oprot)
6121 
    self._oprot.writeMessageEnd()
6122 
    self._oprot.trans.flush()
6123 
 
6124 
  def recv_updateRechargeOrderStatus(self, ):
6125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6126 
    if mtype == TMessageType.EXCEPTION:
6127 
      x = TApplicationException()
6128 
      x.read(self._iprot)
6129 
      self._iprot.readMessageEnd()
6130 
      raise x
6131 
    result = updateRechargeOrderStatus_result()
6132 
    result.read(self._iprot)
6133 
    self._iprot.readMessageEnd()
6031 rajveer 6134 
    if result.success is not None:
6135 
      return result.success
6000 mandeep.dh 6136 
    if result.ex is not None:
6137 
      raise result.ex
6031 rajveer 6138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6139 
 
6031 rajveer 6140 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6141 
    """
6142 
    Parameters:
6031 rajveer 6143 
     - rechargeOrderId
6000 mandeep.dh 6144 
    """
6031 rajveer 6145 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6146 
    return self.recv_activateRechargeTxn()
6147 
 
6031 rajveer 6148 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6149 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6150 
    args = activateRechargeTxn_args()
6031 rajveer 6151 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6152 
    args.write(self._oprot)
6153 
    self._oprot.writeMessageEnd()
6154 
    self._oprot.trans.flush()
6155 
 
6156 
  def recv_activateRechargeTxn(self, ):
6157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6158 
    if mtype == TMessageType.EXCEPTION:
6159 
      x = TApplicationException()
6160 
      x.read(self._iprot)
6161 
      self._iprot.readMessageEnd()
6162 
      raise x
6163 
    result = activateRechargeTxn_result()
6164 
    result.read(self._iprot)
6165 
    self._iprot.readMessageEnd()
6166 
    if result.success is not None:
6167 
      return result.success
6168 
    if result.ex is not None:
6169 
      raise result.ex
6170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6171 
 
6031 rajveer 6172 
  def getUserWallet(self, userId):
6000 mandeep.dh 6173 
    """
6174 
    Parameters:
6031 rajveer 6175 
     - userId
6000 mandeep.dh 6176 
    """
6031 rajveer 6177 
    self.send_getUserWallet(userId)
6178 
    return self.recv_getUserWallet()
6000 mandeep.dh 6179 
 
6031 rajveer 6180 
  def send_getUserWallet(self, userId):
6181 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6182 
    args = getUserWallet_args()
6183 
    args.userId = userId
6000 mandeep.dh 6184 
    args.write(self._oprot)
6185 
    self._oprot.writeMessageEnd()
6186 
    self._oprot.trans.flush()
6187 
 
6031 rajveer 6188 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6190 
    if mtype == TMessageType.EXCEPTION:
6191 
      x = TApplicationException()
6192 
      x.read(self._iprot)
6193 
      self._iprot.readMessageEnd()
6194 
      raise x
6031 rajveer 6195 
    result = getUserWallet_result()
6000 mandeep.dh 6196 
    result.read(self._iprot)
6197 
    self._iprot.readMessageEnd()
6198 
    if result.success is not None:
6199 
      return result.success
6031 rajveer 6200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6201 
 
6031 rajveer 6202 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6203 
    """
6204 
    Parameters:
6031 rajveer 6205 
     - userId
6000 mandeep.dh 6206 
    """
6031 rajveer 6207 
    self.send_getUserWalletHistory(userId)
6208 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6209 
 
6031 rajveer 6210 
  def send_getUserWalletHistory(self, userId):
6211 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6212 
    args = getUserWalletHistory_args()
6213 
    args.userId = userId
6000 mandeep.dh 6214 
    args.write(self._oprot)
6215 
    self._oprot.writeMessageEnd()
6216 
    self._oprot.trans.flush()
6217 
 
6031 rajveer 6218 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6220 
    if mtype == TMessageType.EXCEPTION:
6221 
      x = TApplicationException()
6222 
      x.read(self._iprot)
6223 
      self._iprot.readMessageEnd()
6224 
      raise x
6031 rajveer 6225 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6226 
    result.read(self._iprot)
6227 
    self._iprot.readMessageEnd()
6228 
    if result.success is not None:
6229 
      return result.success
6031 rajveer 6230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6231 
 
6050 anupam.sin 6232 
  def getRechargeOrdersForTransaction(self, txnId):
6233 
    """
6234 
    Returns a recharge order for a given transactionId
6235 
 
6236 
    Parameters:
6237 
     - txnId
6238 
    """
6239 
    self.send_getRechargeOrdersForTransaction(txnId)
6240 
    return self.recv_getRechargeOrdersForTransaction()
6241 
 
6242 
  def send_getRechargeOrdersForTransaction(self, txnId):
6243 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6244 
    args = getRechargeOrdersForTransaction_args()
6245 
    args.txnId = txnId
6246 
    args.write(self._oprot)
6247 
    self._oprot.writeMessageEnd()
6248 
    self._oprot.trans.flush()
6249 
 
6250 
  def recv_getRechargeOrdersForTransaction(self, ):
6251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6252 
    if mtype == TMessageType.EXCEPTION:
6253 
      x = TApplicationException()
6254 
      x.read(self._iprot)
6255 
      self._iprot.readMessageEnd()
6256 
      raise x
6257 
    result = getRechargeOrdersForTransaction_result()
6258 
    result.read(self._iprot)
6259 
    self._iprot.readMessageEnd()
6260 
    if result.success is not None:
6261 
      return result.success
6262 
    if result.ex is not None:
6263 
      raise result.ex
6264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6265 
 
6206 rajveer 6266 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6267 
    """
6268 
    Parameters:
6269 
     - rechargeType
6206 rajveer 6270 
     - onlyActive
6048 rajveer 6271 
    """
6206 rajveer 6272 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6273 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6274 
 
6206 rajveer 6275 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6276 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6277 
    args = getServiceProviders_args()
6278 
    args.rechargeType = rechargeType
6206 rajveer 6279 
    args.onlyActive = onlyActive
6048 rajveer 6280 
    args.write(self._oprot)
6281 
    self._oprot.writeMessageEnd()
6282 
    self._oprot.trans.flush()
6283 
 
6284 
  def recv_getServiceProviders(self, ):
6285 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6286 
    if mtype == TMessageType.EXCEPTION:
6287 
      x = TApplicationException()
6288 
      x.read(self._iprot)
6289 
      self._iprot.readMessageEnd()
6290 
      raise x
6291 
    result = getServiceProviders_result()
6292 
    result.read(self._iprot)
6293 
    self._iprot.readMessageEnd()
6294 
    if result.success is not None:
6295 
      return result.success
6296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6297 
 
6049 rajveer 6298 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6299 
    """
6300 
    Parameters:
6049 rajveer 6301 
     - rechargeType
6048 rajveer 6302 
     - deviceNumber
6303 
    """
6049 rajveer 6304 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6305 
    return self.recv_getServiceProviderForDevice()
6306 
 
6049 rajveer 6307 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6308 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6309 
    args = getServiceProviderForDevice_args()
6049 rajveer 6310 
    args.rechargeType = rechargeType
6048 rajveer 6311 
    args.deviceNumber = deviceNumber
6312 
    args.write(self._oprot)
6313 
    self._oprot.writeMessageEnd()
6314 
    self._oprot.trans.flush()
6315 
 
6316 
  def recv_getServiceProviderForDevice(self, ):
6317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6318 
    if mtype == TMessageType.EXCEPTION:
6319 
      x = TApplicationException()
6320 
      x.read(self._iprot)
6321 
      self._iprot.readMessageEnd()
6322 
      raise x
6323 
    result = getServiceProviderForDevice_result()
6324 
    result.read(self._iprot)
6325 
    self._iprot.readMessageEnd()
6326 
    if result.success is not None:
6327 
      return result.success
6328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6329 
 
6591 anupam.sin 6330 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6331 
    """
6332 
    Parameters:
6333 
     - rechargeType
6334 
     - deviceNumber
6307 anupam.sin 6335 
     - userSelectedProviderId
6591 anupam.sin 6336 
     - clientAddress
6269 rajveer 6337 
    """
6591 anupam.sin 6338 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6339 
    return self.recv_validateRecharge()
6340 
 
6591 anupam.sin 6341 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6342 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6343 
    args = validateRecharge_args()
6344 
    args.rechargeType = rechargeType
6345 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6346 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6347 
    args.clientAddress = clientAddress
6269 rajveer 6348 
    args.write(self._oprot)
6349 
    self._oprot.writeMessageEnd()
6350 
    self._oprot.trans.flush()
6351 
 
6352 
  def recv_validateRecharge(self, ):
6353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6354 
    if mtype == TMessageType.EXCEPTION:
6355 
      x = TApplicationException()
6356 
      x.read(self._iprot)
6357 
      self._iprot.readMessageEnd()
6358 
      raise x
6359 
    result = validateRecharge_result()
6360 
    result.read(self._iprot)
6361 
    self._iprot.readMessageEnd()
6362 
    if result.success is not None:
6363 
      return result.success
6364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6365 
 
6094 rajveer 6366 
  def getRechargeOrdersForDevice(self, deviceNumber):
6367 
    """
6368 
    Parameters:
6369 
     - deviceNumber
6370 
    """
6371 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6372 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6373 
 
6094 rajveer 6374 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6375 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6376 
    args = getRechargeOrdersForDevice_args()
6377 
    args.deviceNumber = deviceNumber
6378 
    args.write(self._oprot)
6379 
    self._oprot.writeMessageEnd()
6380 
    self._oprot.trans.flush()
6381 
 
6382 
  def recv_getRechargeOrdersForDevice(self, ):
6383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6384 
    if mtype == TMessageType.EXCEPTION:
6385 
      x = TApplicationException()
6386 
      x.read(self._iprot)
6387 
      self._iprot.readMessageEnd()
6388 
      raise x
6389 
    result = getRechargeOrdersForDevice_result()
6390 
    result.read(self._iprot)
6391 
    self._iprot.readMessageEnd()
6392 
    if result.success is not None:
6393 
      return result.success
6394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6395 
 
6396 
  def addAmountToWallet(self, userId, orderId, amount):
6397 
    """
6398 
    Parameters:
6399 
     - userId
6400 
     - orderId
6401 
     - amount
6402 
    """
6403 
    self.send_addAmountToWallet(userId, orderId, amount)
6404 
    self.recv_addAmountToWallet()
6405 
 
6406 
  def send_addAmountToWallet(self, userId, orderId, amount):
6407 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6408 
    args = addAmountToWallet_args()
6409 
    args.userId = userId
6410 
    args.orderId = orderId
6411 
    args.amount = amount
6412 
    args.write(self._oprot)
6413 
    self._oprot.writeMessageEnd()
6414 
    self._oprot.trans.flush()
6415 
 
6416 
  def recv_addAmountToWallet(self, ):
6417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6418 
    if mtype == TMessageType.EXCEPTION:
6419 
      x = TApplicationException()
6420 
      x.read(self._iprot)
6421 
      self._iprot.readMessageEnd()
6422 
      raise x
6423 
    result = addAmountToWallet_result()
6424 
    result.read(self._iprot)
6425 
    self._iprot.readMessageEnd()
6426 
    return
6427 
 
6188 rajveer 6428 
  def getRechargeStatistics(self, ):
6429 
    self.send_getRechargeStatistics()
6430 
    return self.recv_getRechargeStatistics()
6431 
 
6432 
  def send_getRechargeStatistics(self, ):
6433 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6434 
    args = getRechargeStatistics_args()
6435 
    args.write(self._oprot)
6436 
    self._oprot.writeMessageEnd()
6437 
    self._oprot.trans.flush()
6438 
 
6439 
  def recv_getRechargeStatistics(self, ):
6440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6441 
    if mtype == TMessageType.EXCEPTION:
6442 
      x = TApplicationException()
6443 
      x.read(self._iprot)
6444 
      self._iprot.readMessageEnd()
6445 
      raise x
6446 
    result = getRechargeStatistics_result()
6447 
    result.read(self._iprot)
6448 
    self._iprot.readMessageEnd()
6449 
    if result.success is not None:
6450 
      return result.success
6451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6452 
 
6154 rajveer 6453 
  def getRechargeOrdersForStatus(self, status):
6454 
    """
6455 
    Parameters:
6456 
     - status
6457 
    """
6458 
    self.send_getRechargeOrdersForStatus(status)
6459 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6460 
 
6154 rajveer 6461 
  def send_getRechargeOrdersForStatus(self, status):
6462 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6463 
    args = getRechargeOrdersForStatus_args()
6464 
    args.status = status
6465 
    args.write(self._oprot)
6466 
    self._oprot.writeMessageEnd()
6467 
    self._oprot.trans.flush()
6468 
 
6469 
  def recv_getRechargeOrdersForStatus(self, ):
6470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6471 
    if mtype == TMessageType.EXCEPTION:
6472 
      x = TApplicationException()
6473 
      x.read(self._iprot)
6474 
      self._iprot.readMessageEnd()
6475 
      raise x
6476 
    result = getRechargeOrdersForStatus_result()
6477 
    result.read(self._iprot)
6478 
    self._iprot.readMessageEnd()
6479 
    if result.success is not None:
6480 
      return result.success
6481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6482 
 
6159 rajveer 6483 
  def getPlansForOperator(self, operatorId):
6484 
    """
6485 
    Parameters:
6486 
     - operatorId
6487 
    """
6488 
    self.send_getPlansForOperator(operatorId)
6489 
    return self.recv_getPlansForOperator()
6154 rajveer 6490 
 
6159 rajveer 6491 
  def send_getPlansForOperator(self, operatorId):
6492 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6493 
    args = getPlansForOperator_args()
6494 
    args.operatorId = operatorId
6495 
    args.write(self._oprot)
6496 
    self._oprot.writeMessageEnd()
6497 
    self._oprot.trans.flush()
6498 
 
6499 
  def recv_getPlansForOperator(self, ):
6500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6501 
    if mtype == TMessageType.EXCEPTION:
6502 
      x = TApplicationException()
6503 
      x.read(self._iprot)
6504 
      self._iprot.readMessageEnd()
6505 
      raise x
6506 
    result = getPlansForOperator_result()
6507 
    result.read(self._iprot)
6508 
    self._iprot.readMessageEnd()
6509 
    if result.success is not None:
6510 
      return result.success
6511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6512 
 
6307 anupam.sin 6513 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6514 
    """
6515 
    Returns denominations for a given operator and circle
6159 rajveer 6516 
 
6289 anupam.sin 6517 
    Parameters:
6518 
     - operatorId
6307 anupam.sin 6519 
     - circleCode
6289 anupam.sin 6520 
     - denominationType
6521 
    """
6307 anupam.sin 6522 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6523 
    return self.recv_getRechargeDenominations()
6524 
 
6307 anupam.sin 6525 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6526 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6527 
    args = getRechargeDenominations_args()
6528 
    args.operatorId = operatorId
6307 anupam.sin 6529 
    args.circleCode = circleCode
6289 anupam.sin 6530 
    args.denominationType = denominationType
6531 
    args.write(self._oprot)
6532 
    self._oprot.writeMessageEnd()
6533 
    self._oprot.trans.flush()
6534 
 
6535 
  def recv_getRechargeDenominations(self, ):
6536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6537 
    if mtype == TMessageType.EXCEPTION:
6538 
      x = TApplicationException()
6539 
      x.read(self._iprot)
6540 
      self._iprot.readMessageEnd()
6541 
      raise x
6542 
    result = getRechargeDenominations_result()
6543 
    result.read(self._iprot)
6544 
    self._iprot.readMessageEnd()
6545 
    if result.success is not None:
6546 
      return result.success
6547 
    if result.ex is not None:
6548 
      raise result.ex
6549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6550 
 
6371 rajveer 6551 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6552 
    """
6553 
    Parameters:
6554 
     - operatorId
6555 
     - circleId
6556 
     - isAvailable
6557 
    """
6558 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6559 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6560 
 
6371 rajveer 6561 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6562 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6563 
    args = updateAvailabilityStatus_args()
6564 
    args.operatorId = operatorId
6565 
    args.circleId = circleId
6566 
    args.isAvailable = isAvailable
6567 
    args.write(self._oprot)
6568 
    self._oprot.writeMessageEnd()
6569 
    self._oprot.trans.flush()
6570 
 
6571 
  def recv_updateAvailabilityStatus(self, ):
6572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6573 
    if mtype == TMessageType.EXCEPTION:
6574 
      x = TApplicationException()
6575 
      x.read(self._iprot)
6576 
      self._iprot.readMessageEnd()
6577 
      raise x
6578 
    result = updateAvailabilityStatus_result()
6579 
    result.read(self._iprot)
6580 
    self._iprot.readMessageEnd()
6581 
    return
6582 
 
6389 rajveer 6583 
  def getAvailableEmiSchemes(self, ):
6584 
    self.send_getAvailableEmiSchemes()
6585 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6586 
 
6389 rajveer 6587 
  def send_getAvailableEmiSchemes(self, ):
6588 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6589 
    args = getAvailableEmiSchemes_args()
6590 
    args.write(self._oprot)
6591 
    self._oprot.writeMessageEnd()
6592 
    self._oprot.trans.flush()
6593 
 
6594 
  def recv_getAvailableEmiSchemes(self, ):
6595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6596 
    if mtype == TMessageType.EXCEPTION:
6597 
      x = TApplicationException()
6598 
      x.read(self._iprot)
6599 
      self._iprot.readMessageEnd()
6600 
      raise x
6601 
    result = getAvailableEmiSchemes_result()
6602 
    result.read(self._iprot)
6603 
    self._iprot.readMessageEnd()
6604 
    if result.success is not None:
6605 
      return result.success
6606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6607 
 
6608 
  def getMiscCharges(self, transactionId):
6609 
    """
6610 
    Parameters:
6611 
     - transactionId
6612 
    """
6613 
    self.send_getMiscCharges(transactionId)
6614 
    return self.recv_getMiscCharges()
6615 
 
6616 
  def send_getMiscCharges(self, transactionId):
6617 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6618 
    args = getMiscCharges_args()
6619 
    args.transactionId = transactionId
6620 
    args.write(self._oprot)
6621 
    self._oprot.writeMessageEnd()
6622 
    self._oprot.trans.flush()
6623 
 
6624 
  def recv_getMiscCharges(self, ):
6625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6626 
    if mtype == TMessageType.EXCEPTION:
6627 
      x = TApplicationException()
6628 
      x.read(self._iprot)
6629 
      self._iprot.readMessageEnd()
6630 
      raise x
6631 
    result = getMiscCharges_result()
6632 
    result.read(self._iprot)
6633 
    self._iprot.readMessageEnd()
6634 
    if result.success is not None:
6635 
      return result.success
6636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6637 
 
6507 anupam.sin 6638 
  def refundRechargeOrder(self, rechargeOrderId):
6639 
    """
6640 
    Parameters:
6641 
     - rechargeOrderId
6642 
    """
6643 
    self.send_refundRechargeOrder(rechargeOrderId)
6644 
    return self.recv_refundRechargeOrder()
6389 rajveer 6645 
 
6507 anupam.sin 6646 
  def send_refundRechargeOrder(self, rechargeOrderId):
6647 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6648 
    args = refundRechargeOrder_args()
6649 
    args.rechargeOrderId = rechargeOrderId
6650 
    args.write(self._oprot)
6651 
    self._oprot.writeMessageEnd()
6652 
    self._oprot.trans.flush()
6653 
 
6654 
  def recv_refundRechargeOrder(self, ):
6655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6656 
    if mtype == TMessageType.EXCEPTION:
6657 
      x = TApplicationException()
6658 
      x.read(self._iprot)
6659 
      self._iprot.readMessageEnd()
6660 
      raise x
6661 
    result = refundRechargeOrder_result()
6662 
    result.read(self._iprot)
6663 
    self._iprot.readMessageEnd()
6664 
    if result.success is not None:
6665 
      return result.success
6666 
    if result.ex is not None:
6667 
      raise result.ex
6668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6669 
 
6821 amar.kumar 6670 
  def getPhysicalOrders(self, fromDate, toDate):
6671 
    """
6672 
    Parameters:
6673 
     - fromDate
6674 
     - toDate
6675 
    """
6676 
    self.send_getPhysicalOrders(fromDate, toDate)
6677 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6678 
 
6821 amar.kumar 6679 
  def send_getPhysicalOrders(self, fromDate, toDate):
6680 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6681 
    args = getPhysicalOrders_args()
6682 
    args.fromDate = fromDate
6683 
    args.toDate = toDate
6684 
    args.write(self._oprot)
6685 
    self._oprot.writeMessageEnd()
6686 
    self._oprot.trans.flush()
6687 
 
6688 
  def recv_getPhysicalOrders(self, ):
6689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6690 
    if mtype == TMessageType.EXCEPTION:
6691 
      x = TApplicationException()
6692 
      x.read(self._iprot)
6693 
      self._iprot.readMessageEnd()
6694 
      raise x
6695 
    result = getPhysicalOrders_result()
6696 
    result.read(self._iprot)
6697 
    self._iprot.readMessageEnd()
6698 
    if result.success is not None:
6699 
      return result.success
6700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6701 
 
6906 rajveer 6702 
  def getDocument(self, docType, docSource):
6703 
    """
6704 
    Parameters:
6705 
     - docType
6706 
     - docSource
6707 
    """
6708 
    self.send_getDocument(docType, docSource)
6709 
    return self.recv_getDocument()
6821 amar.kumar 6710 
 
6906 rajveer 6711 
  def send_getDocument(self, docType, docSource):
6712 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6713 
    args = getDocument_args()
6714 
    args.docType = docType
6715 
    args.docSource = docSource
6716 
    args.write(self._oprot)
6717 
    self._oprot.writeMessageEnd()
6718 
    self._oprot.trans.flush()
6719 
 
6720 
  def recv_getDocument(self, ):
6721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6722 
    if mtype == TMessageType.EXCEPTION:
6723 
      x = TApplicationException()
6724 
      x.read(self._iprot)
6725 
      self._iprot.readMessageEnd()
6726 
      raise x
6727 
    result = getDocument_result()
6728 
    result.read(self._iprot)
6729 
    self._iprot.readMessageEnd()
6730 
    if result.success is not None:
6731 
      return result.success
6732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6733 
 
6985 anupam.sin 6734 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6735 
    """
6736 
    Parameters:
6737 
     - orderId
6738 
     - line1
6739 
     - line2
6740 
     - city
6741 
     - state
6742 
     - pin
6743 
    """
6744 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6745 
    return self.recv_changeShippingAddress()
6906 rajveer 6746 
 
6985 anupam.sin 6747 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6748 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6749 
    args = changeShippingAddress_args()
6750 
    args.orderId = orderId
6751 
    args.line1 = line1
6752 
    args.line2 = line2
6753 
    args.city = city
6754 
    args.state = state
6755 
    args.pin = pin
6756 
    args.write(self._oprot)
6757 
    self._oprot.writeMessageEnd()
6758 
    self._oprot.trans.flush()
6759 
 
6760 
  def recv_changeShippingAddress(self, ):
6761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6762 
    if mtype == TMessageType.EXCEPTION:
6763 
      x = TApplicationException()
6764 
      x.read(self._iprot)
6765 
      self._iprot.readMessageEnd()
6766 
      raise x
6767 
    result = changeShippingAddress_result()
6768 
    result.read(self._iprot)
6769 
    self._iprot.readMessageEnd()
6770 
    if result.success is not None:
6771 
      return result.success
6772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6773 
 
7075 rajveer 6774 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6775 
    """
6776 
    Parameters:
6777 
     - orderId
7075 rajveer 6778 
     - userId
6988 rajveer 6779 
    """
7075 rajveer 6780 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6781 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6782 
 
7075 rajveer 6783 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6784 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6785 
    args = retrieveInvoice_args()
6786 
    args.orderId = orderId
7075 rajveer 6787 
    args.userId = userId
6988 rajveer 6788 
    args.write(self._oprot)
6789 
    self._oprot.writeMessageEnd()
6790 
    self._oprot.trans.flush()
6791 
 
6792 
  def recv_retrieveInvoice(self, ):
6793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6794 
    if mtype == TMessageType.EXCEPTION:
6795 
      x = TApplicationException()
6796 
      x.read(self._iprot)
6797 
      self._iprot.readMessageEnd()
6798 
      raise x
6799 
    result = retrieveInvoice_result()
6800 
    result.read(self._iprot)
6801 
    self._iprot.readMessageEnd()
6802 
    if result.success is not None:
6803 
      return result.success
6804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6805 
 
7026 rajveer 6806 
  def receiveUpdatesForRedExpress(self, awbNumber):
6807 
    """
6808 
    Parameters:
6809 
     - awbNumber
6810 
    """
6811 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6812 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6813 
 
7026 rajveer 6814 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6815 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6816 
    args = receiveUpdatesForRedExpress_args()
6817 
    args.awbNumber = awbNumber
6818 
    args.write(self._oprot)
6819 
    self._oprot.writeMessageEnd()
6820 
    self._oprot.trans.flush()
6821 
 
6822 
  def recv_receiveUpdatesForRedExpress(self, ):
6823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6824 
    if mtype == TMessageType.EXCEPTION:
6825 
      x = TApplicationException()
6826 
      x.read(self._iprot)
6827 
      self._iprot.readMessageEnd()
6828 
      raise x
6829 
    result = receiveUpdatesForRedExpress_result()
6830 
    result.read(self._iprot)
6831 
    self._iprot.readMessageEnd()
6832 
    if result.success is not None:
6833 
      return result.success
6834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6835 
 
7073 anupam.sin 6836 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6837 
    """
6838 
    Parameters:
6839 
     - thriftRechargeTransaction
6840 
    """
6841 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6842 
    return self.recv_createRechargeTransaction()
7026 rajveer 6843 
 
7073 anupam.sin 6844 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6845 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6846 
    args = createRechargeTransaction_args()
6847 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6848 
    args.write(self._oprot)
6849 
    self._oprot.writeMessageEnd()
6850 
    self._oprot.trans.flush()
6851 
 
6852 
  def recv_createRechargeTransaction(self, ):
6853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6854 
    if mtype == TMessageType.EXCEPTION:
6855 
      x = TApplicationException()
6856 
      x.read(self._iprot)
6857 
      self._iprot.readMessageEnd()
6858 
      raise x
6859 
    result = createRechargeTransaction_result()
6860 
    result.read(self._iprot)
6861 
    self._iprot.readMessageEnd()
6862 
    if result.success is not None:
6863 
      return result.success
6864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6865 
 
7085 rajveer 6866 
  def getRechargeTransactions(self, storeId):
6867 
    """
6868 
    Parameters:
6869 
     - storeId
6870 
    """
6871 
    self.send_getRechargeTransactions(storeId)
6872 
    return self.recv_getRechargeTransactions()
6873 
 
6874 
  def send_getRechargeTransactions(self, storeId):
6875 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6876 
    args = getRechargeTransactions_args()
6877 
    args.storeId = storeId
6878 
    args.write(self._oprot)
6879 
    self._oprot.writeMessageEnd()
6880 
    self._oprot.trans.flush()
6881 
 
6882 
  def recv_getRechargeTransactions(self, ):
6883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6884 
    if mtype == TMessageType.EXCEPTION:
6885 
      x = TApplicationException()
6886 
      x.read(self._iprot)
6887 
      self._iprot.readMessageEnd()
6888 
      raise x
6889 
    result = getRechargeTransactions_result()
6890 
    result.read(self._iprot)
6891 
    self._iprot.readMessageEnd()
6892 
    if result.success is not None:
6893 
      return result.success
6894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6895 
 
7151 amit.gupta 6896 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6897 
    """
6898 
    Parameters:
6899 
     - storeId
6900 
     - startDate
6901 
     - endDate
6902 
     - status
6903 
    """
6904 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6905 
    return self.recv_getRechargeTrans()
6906 
 
6907 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6908 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6909 
    args = getRechargeTrans_args()
6910 
    args.storeId = storeId
6911 
    args.startDate = startDate
6912 
    args.endDate = endDate
6913 
    args.status = status
6914 
    args.write(self._oprot)
6915 
    self._oprot.writeMessageEnd()
6916 
    self._oprot.trans.flush()
6917 
 
6918 
  def recv_getRechargeTrans(self, ):
6919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6920 
    if mtype == TMessageType.EXCEPTION:
6921 
      x = TApplicationException()
6922 
      x.read(self._iprot)
6923 
      self._iprot.readMessageEnd()
6924 
      raise x
6925 
    result = getRechargeTrans_result()
6926 
    result.read(self._iprot)
6927 
    self._iprot.readMessageEnd()
6928 
    if result.success is not None:
6929 
      return result.success
6930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6931 
 
7080 anupam.sin 6932 
  def getRechargeTransaction(self, rechargeId):
6933 
    """
6934 
    Parameters:
6935 
     - rechargeId
6936 
    """
6937 
    self.send_getRechargeTransaction(rechargeId)
6938 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6939 
 
7080 anupam.sin 6940 
  def send_getRechargeTransaction(self, rechargeId):
6941 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6942 
    args = getRechargeTransaction_args()
6943 
    args.rechargeId = rechargeId
6944 
    args.write(self._oprot)
6945 
    self._oprot.writeMessageEnd()
6946 
    self._oprot.trans.flush()
6947 
 
6948 
  def recv_getRechargeTransaction(self, ):
6949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6950 
    if mtype == TMessageType.EXCEPTION:
6951 
      x = TApplicationException()
6952 
      x.read(self._iprot)
6953 
      self._iprot.readMessageEnd()
6954 
      raise x
6955 
    result = getRechargeTransaction_result()
6956 
    result.read(self._iprot)
6957 
    self._iprot.readMessageEnd()
6958 
    if result.success is not None:
6959 
      return result.success
6960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6961 
 
6962 
  def getFRCs(self, circleId, operatorId):
6963 
    """
6964 
    Parameters:
6965 
     - circleId
6966 
     - operatorId
6967 
    """
6968 
    self.send_getFRCs(circleId, operatorId)
6969 
    return self.recv_getFRCs()
6970 
 
6971 
  def send_getFRCs(self, circleId, operatorId):
6972 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6973 
    args = getFRCs_args()
6974 
    args.circleId = circleId
6975 
    args.operatorId = operatorId
6976 
    args.write(self._oprot)
6977 
    self._oprot.writeMessageEnd()
6978 
    self._oprot.trans.flush()
6979 
 
6980 
  def recv_getFRCs(self, ):
6981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6982 
    if mtype == TMessageType.EXCEPTION:
6983 
      x = TApplicationException()
6984 
      x.read(self._iprot)
6985 
      self._iprot.readMessageEnd()
6986 
      raise x
6987 
    result = getFRCs_result()
6988 
    result.read(self._iprot)
6989 
    self._iprot.readMessageEnd()
6990 
    if result.success is not None:
6991 
      return result.success
6992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
6993 
 
7096 anupam.sin 6994 
  def getHotspotStore(self, id, hotspotid):
6995 
    """
6996 
    Parameters:
6997 
     - id
6998 
     - hotspotid
6999 
    """
7000 
    self.send_getHotspotStore(id, hotspotid)
7001 
    return self.recv_getHotspotStore()
7080 anupam.sin 7002 
 
7096 anupam.sin 7003 
  def send_getHotspotStore(self, id, hotspotid):
7004 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7005 
    args = getHotspotStore_args()
7006 
    args.id = id
7007 
    args.hotspotid = hotspotid
7008 
    args.write(self._oprot)
7009 
    self._oprot.writeMessageEnd()
7010 
    self._oprot.trans.flush()
7011 
 
7012 
  def recv_getHotspotStore(self, ):
7013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7014 
    if mtype == TMessageType.EXCEPTION:
7015 
      x = TApplicationException()
7016 
      x.read(self._iprot)
7017 
      self._iprot.readMessageEnd()
7018 
      raise x
7019 
    result = getHotspotStore_result()
7020 
    result.read(self._iprot)
7021 
    self._iprot.readMessageEnd()
7022 
    if result.success is not None:
7023 
      return result.success
7024 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7025 
 
7026 
  def getTelecomCircle(self, id, code):
7027 
    """
7028 
    Parameters:
7029 
     - id
7030 
     - code
7031 
    """
7032 
    self.send_getTelecomCircle(id, code)
7033 
    return self.recv_getTelecomCircle()
7034 
 
7035 
  def send_getTelecomCircle(self, id, code):
7036 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7037 
    args = getTelecomCircle_args()
7038 
    args.id = id
7039 
    args.code = code
7040 
    args.write(self._oprot)
7041 
    self._oprot.writeMessageEnd()
7042 
    self._oprot.trans.flush()
7043 
 
7044 
  def recv_getTelecomCircle(self, ):
7045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7046 
    if mtype == TMessageType.EXCEPTION:
7047 
      x = TApplicationException()
7048 
      x.read(self._iprot)
7049 
      self._iprot.readMessageEnd()
7050 
      raise x
7051 
    result = getTelecomCircle_result()
7052 
    result.read(self._iprot)
7053 
    self._iprot.readMessageEnd()
7054 
    if result.success is not None:
7055 
      return result.success
7056 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7057 
 
7109 anupam.sin 7058 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7059 
    """
7060 
    Parameters:
7061 
     - rechargeId
7062 
    """
7063 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7064 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7065 
 
7109 anupam.sin 7066 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7067 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7068 
    args = retrieveHotspotRechargeInvoice_args()
7069 
    args.rechargeId = rechargeId
7070 
    args.write(self._oprot)
7071 
    self._oprot.writeMessageEnd()
7072 
    self._oprot.trans.flush()
7073 
 
7074 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7076 
    if mtype == TMessageType.EXCEPTION:
7077 
      x = TApplicationException()
7078 
      x.read(self._iprot)
7079 
      self._iprot.readMessageEnd()
7080 
      raise x
7081 
    result = retrieveHotspotRechargeInvoice_result()
7082 
    result.read(self._iprot)
7083 
    self._iprot.readMessageEnd()
7084 
    if result.success is not None:
7085 
      return result.success
7086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7087 
 
7172 anupam.sin 7088 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7089 
    """
7090 
    Parameters:
7091 
     - number
7172 anupam.sin 7092 
     - storeId
7169 anupam.sin 7093 
    """
7172 anupam.sin 7094 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7095 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7096 
 
7172 anupam.sin 7097 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7098 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7099 
    args = getRechargeTransactionsByNumber_args()
7100 
    args.number = number
7172 anupam.sin 7101 
    args.storeId = storeId
7169 anupam.sin 7102 
    args.write(self._oprot)
7103 
    self._oprot.writeMessageEnd()
7104 
    self._oprot.trans.flush()
7105 
 
7106 
  def recv_getRechargeTransactionsByNumber(self, ):
7107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7108 
    if mtype == TMessageType.EXCEPTION:
7109 
      x = TApplicationException()
7110 
      x.read(self._iprot)
7111 
      self._iprot.readMessageEnd()
7112 
      raise x
7113 
    result = getRechargeTransactionsByNumber_result()
7114 
    result.read(self._iprot)
7115 
    self._iprot.readMessageEnd()
7116 
    if result.success is not None:
7117 
      return result.success
7118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7119 
 
7120 
  def updateHotspotStorePassword(self, storeId, password):
7121 
    """
7122 
    Parameters:
7123 
     - storeId
7124 
     - password
7125 
    """
7126 
    self.send_updateHotspotStorePassword(storeId, password)
7127 
    return self.recv_updateHotspotStorePassword()
7128 
 
7129 
  def send_updateHotspotStorePassword(self, storeId, password):
7130 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7131 
    args = updateHotspotStorePassword_args()
7132 
    args.storeId = storeId
7133 
    args.password = password
7134 
    args.write(self._oprot)
7135 
    self._oprot.writeMessageEnd()
7136 
    self._oprot.trans.flush()
7137 
 
7138 
  def recv_updateHotspotStorePassword(self, ):
7139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7140 
    if mtype == TMessageType.EXCEPTION:
7141 
      x = TApplicationException()
7142 
      x.read(self._iprot)
7143 
      self._iprot.readMessageEnd()
7144 
      raise x
7145 
    result = updateHotspotStorePassword_result()
7146 
    result.read(self._iprot)
7147 
    self._iprot.readMessageEnd()
7148 
    if result.success is not None:
7149 
      return result.success
7150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7151 
 
7152 
 
3376 rajveer 7153 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7154 
  def __init__(self, handler):
3376 rajveer 7155 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7156 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7157 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7158 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7159 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7160 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7161 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7162 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7163 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7164 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7165 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7166 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7167 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7168 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7169 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7170 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7171 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7172 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7173 
    self._processMap["createOrder"] = Processor.process_createOrder
7174 
    self._processMap["getOrder"] = Processor.process_getOrder
7175 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7176 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7177 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7178 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7179 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7180 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7181 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7182 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7183 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7184 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7185 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7186 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7187 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7188 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7189 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7190 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7191 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7192 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7193 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7194 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7195 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7196 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7197 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7198 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7199 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7200 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7201 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7202 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7203 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7204 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7205 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7206 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7207 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7208 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7209 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7210 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7211 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7212 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7213 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7214 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7215 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7216 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7217 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7218 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7219 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7220 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7221 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7222 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7223 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7224 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7225 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7226 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7227 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7228 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7229 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7230 
    self._processMap["changeItem"] = Processor.process_changeItem
7231 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7232 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7233 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7234 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7235 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7236 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7237 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7238 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7239 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7240 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7241 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7242 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7243 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7244 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7245 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7246 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7247 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7248 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7249 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7250 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7251 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7252 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7253 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7254 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7255 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7256 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7257 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7258 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7259 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7260 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7261 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7262 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7263 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7264 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7265 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7266 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7267 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7268 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7269 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7270 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7271 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7272 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7273 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7274 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7275 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7276 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7277 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7278 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7279 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7280 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7281 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7282 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7283 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7284 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7285 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7286 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7287 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7288 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7289 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7290 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7291 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7292 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7293 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7294 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7295 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7296 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7297 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7298 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7299 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7300 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7301 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7302 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7303 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7304 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7305 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7306 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7307 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7308 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7309 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7310 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7311 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7312 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7313 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7314 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7315 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7316 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7169 anupam.sin 7317 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7318 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
94 ashish 7319 
 
7320 
  def process(self, iprot, oprot):
7321 
    (name, type, seqid) = iprot.readMessageBegin()
7322 
    if name not in self._processMap:
7323 
      iprot.skip(TType.STRUCT)
7324 
      iprot.readMessageEnd()
7325 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7326 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7327 
      x.write(oprot)
7328 
      oprot.writeMessageEnd()
7329 
      oprot.trans.flush()
7330 
      return
7331 
    else:
7332 
      self._processMap[name](self, seqid, iprot, oprot)
7333 
    return True
7334 
 
7335 
  def process_createTransaction(self, seqid, iprot, oprot):
7336 
    args = createTransaction_args()
7337 
    args.read(iprot)
7338 
    iprot.readMessageEnd()
7339 
    result = createTransaction_result()
7340 
    try:
132 ashish 7341 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7342 
    except TransactionServiceException, ex:
7343 
      result.ex = ex
7344 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7345 
    result.write(oprot)
7346 
    oprot.writeMessageEnd()
7347 
    oprot.trans.flush()
7348 
 
7349 
  def process_getTransaction(self, seqid, iprot, oprot):
7350 
    args = getTransaction_args()
7351 
    args.read(iprot)
7352 
    iprot.readMessageEnd()
7353 
    result = getTransaction_result()
7354 
    try:
7355 
      result.success = self._handler.getTransaction(args.id)
7356 
    except TransactionServiceException, ex:
7357 
      result.ex = ex
7358 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7359 
    result.write(oprot)
7360 
    oprot.writeMessageEnd()
7361 
    oprot.trans.flush()
7362 
 
7363 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7364 
    args = getTransactionsForCustomer_args()
7365 
    args.read(iprot)
7366 
    iprot.readMessageEnd()
7367 
    result = getTransactionsForCustomer_result()
7368 
    try:
7369 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7370 
    except TransactionServiceException, ex:
7371 
      result.ex = ex
7372 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
132 ashish 7377 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7378 
    args = getTransactionsForShoppingCartId_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = getTransactionsForShoppingCartId_result()
7382 
    try:
7383 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7384 
    except TransactionServiceException, ex:
7385 
      result.ex = ex
7386 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
7390 
 
94 ashish 7391 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7392 
    args = getTransactionStatus_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = getTransactionStatus_result()
7396 
    try:
7397 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7398 
    except TransactionServiceException, ex:
7399 
      result.ex = ex
7400 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7401 
    result.write(oprot)
7402 
    oprot.writeMessageEnd()
7403 
    oprot.trans.flush()
7404 
 
7405 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7406 
    args = changeTransactionStatus_args()
7407 
    args.read(iprot)
7408 
    iprot.readMessageEnd()
7409 
    result = changeTransactionStatus_result()
7410 
    try:
5527 anupam.sin 7411 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7412 
    except TransactionServiceException, ex:
7413 
      result.ex = ex
7414 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
7418 
 
1398 varun.gupt 7419 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7420 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
1398 varun.gupt 7423 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7424 
    try:
1398 varun.gupt 7425 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7426 
    except TransactionServiceException, ex:
7427 
      result.ex = ex
1398 varun.gupt 7428 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7429 
    result.write(oprot)
7430 
    oprot.writeMessageEnd()
7431 
    oprot.trans.flush()
7432 
 
483 rajveer 7433 
  def process_getAllOrders(self, seqid, iprot, oprot):
7434 
    args = getAllOrders_args()
94 ashish 7435 
    args.read(iprot)
7436 
    iprot.readMessageEnd()
483 rajveer 7437 
    result = getAllOrders_result()
94 ashish 7438 
    try:
4801 anupam.sin 7439 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7440 
    except TransactionServiceException, ex:
7441 
      result.ex = ex
483 rajveer 7442 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7443 
    result.write(oprot)
7444 
    oprot.writeMessageEnd()
7445 
    oprot.trans.flush()
7446 
 
4133 chandransh 7447 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7448 
    args = getOrdersInBatch_args()
7449 
    args.read(iprot)
7450 
    iprot.readMessageEnd()
7451 
    result = getOrdersInBatch_result()
7452 
    try:
7453 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7454 
    except TransactionServiceException, ex:
7455 
      result.ex = ex
7456 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7457 
    result.write(oprot)
7458 
    oprot.writeMessageEnd()
7459 
    oprot.trans.flush()
7460 
 
7461 
  def process_getOrderCount(self, seqid, iprot, oprot):
7462 
    args = getOrderCount_args()
7463 
    args.read(iprot)
7464 
    iprot.readMessageEnd()
7465 
    result = getOrderCount_result()
7466 
    try:
7467 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7468 
    except TransactionServiceException, ex:
7469 
      result.ex = ex
7470 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7471 
    result.write(oprot)
7472 
    oprot.writeMessageEnd()
7473 
    oprot.trans.flush()
7474 
 
999 varun.gupt 7475 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7476 
    args = getOrdersByBillingDate_args()
7477 
    args.read(iprot)
7478 
    iprot.readMessageEnd()
7479 
    result = getOrdersByBillingDate_result()
7480 
    try:
7481 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7482 
    except TransactionServiceException, ex:
7483 
      result.ex = ex
7484 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7485 
    result.write(oprot)
7486 
    oprot.writeMessageEnd()
7487 
    oprot.trans.flush()
7488 
 
3427 chandransh 7489 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7490 
    args = getOrdersByShippingDate_args()
7491 
    args.read(iprot)
7492 
    iprot.readMessageEnd()
7493 
    result = getOrdersByShippingDate_result()
7494 
    try:
3451 chandransh 7495 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7496 
    except TransactionServiceException, ex:
7497 
      result.ex = ex
7498 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7499 
    result.write(oprot)
7500 
    oprot.writeMessageEnd()
7501 
    oprot.trans.flush()
7502 
 
1382 varun.gupt 7503 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7504 
    args = getReturnableOrdersForCustomer_args()
7505 
    args.read(iprot)
7506 
    iprot.readMessageEnd()
7507 
    result = getReturnableOrdersForCustomer_result()
7508 
    try:
7509 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7510 
    except TransactionServiceException, ex:
7511 
      result.ex = ex
7512 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7513 
    result.write(oprot)
7514 
    oprot.writeMessageEnd()
7515 
    oprot.trans.flush()
7516 
 
7517 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7518 
    args = getCancellableOrdersForCustomer_args()
7519 
    args.read(iprot)
7520 
    iprot.readMessageEnd()
7521 
    result = getCancellableOrdersForCustomer_result()
7522 
    try:
7523 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7524 
    except TransactionServiceException, ex:
7525 
      result.ex = ex
7526 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7527 
    result.write(oprot)
7528 
    oprot.writeMessageEnd()
7529 
    oprot.trans.flush()
7530 
 
483 rajveer 7531 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7532 
    args = changeOrderStatus_args()
94 ashish 7533 
    args.read(iprot)
7534 
    iprot.readMessageEnd()
483 rajveer 7535 
    result = changeOrderStatus_result()
94 ashish 7536 
    try:
483 rajveer 7537 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7538 
    except TransactionServiceException, ex:
7539 
      result.ex = ex
483 rajveer 7540 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7541 
    result.write(oprot)
7542 
    oprot.writeMessageEnd()
7543 
    oprot.trans.flush()
7544 
 
483 rajveer 7545 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7546 
    args = getOrdersForTransaction_args()
94 ashish 7547 
    args.read(iprot)
7548 
    iprot.readMessageEnd()
483 rajveer 7549 
    result = getOrdersForTransaction_result()
94 ashish 7550 
    try:
1528 ankur.sing 7551 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7552 
    except TransactionServiceException, ex:
7553 
      result.ex = ex
483 rajveer 7554 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7555 
    result.write(oprot)
7556 
    oprot.writeMessageEnd()
7557 
    oprot.trans.flush()
7558 
 
483 rajveer 7559 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7560 
    args = getOrdersForCustomer_args()
94 ashish 7561 
    args.read(iprot)
7562 
    iprot.readMessageEnd()
483 rajveer 7563 
    result = getOrdersForCustomer_result()
94 ashish 7564 
    try:
3014 chandransh 7565 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7566 
    except TransactionServiceException, ex:
7567 
      result.ex = ex
483 rajveer 7568 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7569 
    result.write(oprot)
7570 
    oprot.writeMessageEnd()
7571 
    oprot.trans.flush()
7572 
 
483 rajveer 7573 
  def process_createOrder(self, seqid, iprot, oprot):
7574 
    args = createOrder_args()
94 ashish 7575 
    args.read(iprot)
7576 
    iprot.readMessageEnd()
483 rajveer 7577 
    result = createOrder_result()
94 ashish 7578 
    try:
483 rajveer 7579 
      result.success = self._handler.createOrder(args.order)
94 ashish 7580 
    except TransactionServiceException, ex:
7581 
      result.ex = ex
483 rajveer 7582 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7583 
    result.write(oprot)
7584 
    oprot.writeMessageEnd()
7585 
    oprot.trans.flush()
7586 
 
483 rajveer 7587 
  def process_getOrder(self, seqid, iprot, oprot):
7588 
    args = getOrder_args()
94 ashish 7589 
    args.read(iprot)
7590 
    iprot.readMessageEnd()
483 rajveer 7591 
    result = getOrder_result()
94 ashish 7592 
    try:
483 rajveer 7593 
      result.success = self._handler.getOrder(args.id)
94 ashish 7594 
    except TransactionServiceException, ex:
7595 
      result.ex = ex
483 rajveer 7596 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7597 
    result.write(oprot)
7598 
    oprot.writeMessageEnd()
7599 
    oprot.trans.flush()
7600 
 
483 rajveer 7601 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7602 
    args = getLineItemsForOrder_args()
94 ashish 7603 
    args.read(iprot)
7604 
    iprot.readMessageEnd()
483 rajveer 7605 
    result = getLineItemsForOrder_result()
94 ashish 7606 
    try:
483 rajveer 7607 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7608 
    except TransactionServiceException, ex:
7609 
      result.ex = ex
483 rajveer 7610 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7611 
    result.write(oprot)
7612 
    oprot.writeMessageEnd()
7613 
    oprot.trans.flush()
7614 
 
4999 phani.kuma 7615 
  def process_getOrderList(self, seqid, iprot, oprot):
7616 
    args = getOrderList_args()
7617 
    args.read(iprot)
7618 
    iprot.readMessageEnd()
7619 
    result = getOrderList_result()
7620 
    result.success = self._handler.getOrderList(args.order_ids)
7621 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7622 
    result.write(oprot)
7623 
    oprot.writeMessageEnd()
7624 
    oprot.trans.flush()
7625 
 
5386 phani.kuma 7626 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7627 
    args = getOrderListForVendor_args()
7628 
    args.read(iprot)
7629 
    iprot.readMessageEnd()
7630 
    result = getOrderListForVendor_result()
7631 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7632 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7633 
    result.write(oprot)
7634 
    oprot.writeMessageEnd()
7635 
    oprot.trans.flush()
7636 
 
1528 ankur.sing 7637 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7638 
    args = getOrderForCustomer_args()
7639 
    args.read(iprot)
7640 
    iprot.readMessageEnd()
7641 
    result = getOrderForCustomer_result()
7642 
    try:
7643 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7644 
    except TransactionServiceException, ex:
7645 
      result.ex = ex
7646 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7647 
    result.write(oprot)
7648 
    oprot.writeMessageEnd()
7649 
    oprot.trans.flush()
7650 
 
3064 chandransh 7651 
  def process_getAlerts(self, seqid, iprot, oprot):
7652 
    args = getAlerts_args()
7653 
    args.read(iprot)
7654 
    iprot.readMessageEnd()
7655 
    result = getAlerts_result()
4444 rajveer 7656 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7657 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7658 
    result.write(oprot)
7659 
    oprot.writeMessageEnd()
7660 
    oprot.trans.flush()
7661 
 
4394 rajveer 7662 
  def process_addAlert(self, seqid, iprot, oprot):
7663 
    args = addAlert_args()
3064 chandransh 7664 
    args.read(iprot)
7665 
    iprot.readMessageEnd()
4394 rajveer 7666 
    result = addAlert_result()
4444 rajveer 7667 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7668 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7669 
    result.write(oprot)
7670 
    oprot.writeMessageEnd()
7671 
    oprot.trans.flush()
7672 
 
4444 rajveer 7673 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7674 
    args = markAlertsAsSeen_args()
7675 
    args.read(iprot)
7676 
    iprot.readMessageEnd()
7677 
    result = markAlertsAsSeen_result()
7678 
    self._handler.markAlertsAsSeen(args.warehouseId)
7679 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7680 
    result.write(oprot)
7681 
    oprot.writeMessageEnd()
7682 
    oprot.trans.flush()
7683 
 
3064 chandransh 7684 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7685 
    args = getValidOrderCount_args()
7686 
    args.read(iprot)
7687 
    iprot.readMessageEnd()
7688 
    result = getValidOrderCount_result()
7689 
    result.success = self._handler.getValidOrderCount()
7690 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
7694 
 
7695 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7696 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
7699 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7700 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7701 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7702 
    result.write(oprot)
7703 
    oprot.writeMessageEnd()
7704 
    oprot.trans.flush()
7705 
 
7706 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7707 
    args = getValidOrdersAmountRange_args()
7708 
    args.read(iprot)
7709 
    iprot.readMessageEnd()
7710 
    result = getValidOrdersAmountRange_result()
7711 
    result.success = self._handler.getValidOrdersAmountRange()
7712 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7713 
    result.write(oprot)
7714 
    oprot.writeMessageEnd()
7715 
    oprot.trans.flush()
7716 
 
7717 
  def process_getValidOrders(self, seqid, iprot, oprot):
7718 
    args = getValidOrders_args()
7719 
    args.read(iprot)
7720 
    iprot.readMessageEnd()
7721 
    result = getValidOrders_result()
5874 rajveer 7722 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7723 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7724 
    result.write(oprot)
7725 
    oprot.writeMessageEnd()
7726 
    oprot.trans.flush()
7727 
 
1220 chandransh 7728 
  def process_batchOrders(self, seqid, iprot, oprot):
7729 
    args = batchOrders_args()
7730 
    args.read(iprot)
7731 
    iprot.readMessageEnd()
7732 
    result = batchOrders_result()
7733 
    try:
7734 
      result.success = self._handler.batchOrders(args.warehouseId)
7735 
    except TransactionServiceException, ex:
7736 
      result.ex = ex
7737 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7738 
    result.write(oprot)
7739 
    oprot.writeMessageEnd()
7740 
    oprot.trans.flush()
7741 
 
1208 chandransh 7742 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7743 
    args = markOrderAsOutOfStock_args()
7744 
    args.read(iprot)
7745 
    iprot.readMessageEnd()
7746 
    result = markOrderAsOutOfStock_result()
7747 
    try:
7748 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7749 
    except TransactionServiceException, ex:
7750 
      result.ex = ex
7751 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7752 
    result.write(oprot)
7753 
    oprot.writeMessageEnd()
7754 
    oprot.trans.flush()
7755 
 
3064 chandransh 7756 
  def process_verifyOrder(self, seqid, iprot, oprot):
7757 
    args = verifyOrder_args()
759 chandransh 7758 
    args.read(iprot)
7759 
    iprot.readMessageEnd()
3064 chandransh 7760 
    result = verifyOrder_result()
759 chandransh 7761 
    try:
3064 chandransh 7762 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7763 
    except TransactionServiceException, ex:
7764 
      result.ex = ex
3064 chandransh 7765 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7766 
    result.write(oprot)
7767 
    oprot.writeMessageEnd()
7768 
    oprot.trans.flush()
7769 
 
3064 chandransh 7770 
  def process_acceptOrder(self, seqid, iprot, oprot):
7771 
    args = acceptOrder_args()
1113 chandransh 7772 
    args.read(iprot)
7773 
    iprot.readMessageEnd()
3064 chandransh 7774 
    result = acceptOrder_result()
1113 chandransh 7775 
    try:
3064 chandransh 7776 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7777 
    except TransactionServiceException, ex:
7778 
      result.ex = ex
3064 chandransh 7779 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7780 
    result.write(oprot)
7781 
    oprot.writeMessageEnd()
7782 
    oprot.trans.flush()
7783 
 
3064 chandransh 7784 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7785 
    args = addBillingDetails_args()
1135 chandransh 7786 
    args.read(iprot)
7787 
    iprot.readMessageEnd()
3064 chandransh 7788 
    result = addBillingDetails_result()
1135 chandransh 7789 
    try:
5110 mandeep.dh 7790 
      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 7791 
    except TransactionServiceException, ex:
7792 
      result.ex = ex
3064 chandransh 7793 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7794 
    result.write(oprot)
7795 
    oprot.writeMessageEnd()
7796 
    oprot.trans.flush()
7797 
 
4579 rajveer 7798 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7799 
    args = addInvoiceNumber_args()
7800 
    args.read(iprot)
7801 
    iprot.readMessageEnd()
7802 
    result = addInvoiceNumber_result()
7803 
    try:
6756 amar.kumar 7804 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7805 
    except TransactionServiceException, ex:
7806 
      result.ex = ex
7807 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7808 
    result.write(oprot)
7809 
    oprot.writeMessageEnd()
7810 
    oprot.trans.flush()
7811 
 
4410 rajveer 7812 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7813 
    args = markOrdersAsShippedFromWarehouse_args()
7814 
    args.read(iprot)
7815 
    iprot.readMessageEnd()
7816 
    result = markOrdersAsShippedFromWarehouse_result()
7817 
    try:
4789 rajveer 7818 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7819 
    except TransactionServiceException, ex:
7820 
      result.ex = ex
7821 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7822 
    result.write(oprot)
7823 
    oprot.writeMessageEnd()
7824 
    oprot.trans.flush()
7825 
 
5676 rajveer 7826 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7827 
    args = markOrdersAsReturnedFromStore_args()
7828 
    args.read(iprot)
7829 
    iprot.readMessageEnd()
7830 
    result = markOrdersAsReturnedFromStore_result()
7831 
    try:
5713 rajveer 7832 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7833 
    except TransactionServiceException, ex:
7834 
      result.ex = ex
7835 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7836 
    result.write(oprot)
7837 
    oprot.writeMessageEnd()
7838 
    oprot.trans.flush()
7839 
 
3064 chandransh 7840 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7841 
    args = markOrdersAsPickedUp_args()
304 ashish 7842 
    args.read(iprot)
7843 
    iprot.readMessageEnd()
3064 chandransh 7844 
    result = markOrdersAsPickedUp_result()
7845 
    try:
4910 phani.kuma 7846 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7847 
    except TransactionServiceException, ex:
7848 
      result.ex = ex
7849 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7850 
    result.write(oprot)
7851 
    oprot.writeMessageEnd()
7852 
    oprot.trans.flush()
94 ashish 7853 
 
4910 phani.kuma 7854 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7855 
    args = getOrdersNotPickedUp_args()
7856 
    args.read(iprot)
7857 
    iprot.readMessageEnd()
7858 
    result = getOrdersNotPickedUp_result()
7859 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7860 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7861 
    result.write(oprot)
7862 
    oprot.writeMessageEnd()
7863 
    oprot.trans.flush()
7864 
 
3064 chandransh 7865 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7866 
    args = markOrdersAsDelivered_args()
304 ashish 7867 
    args.read(iprot)
7868 
    iprot.readMessageEnd()
3064 chandransh 7869 
    result = markOrdersAsDelivered_result()
7870 
    try:
7871 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7872 
    except TransactionServiceException, ex:
7873 
      result.ex = ex
7874 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7875 
    result.write(oprot)
7876 
    oprot.writeMessageEnd()
7877 
    oprot.trans.flush()
7878 
 
4910 phani.kuma 7879 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7880 
    args = markAsRTOrders_args()
1596 ankur.sing 7881 
    args.read(iprot)
7882 
    iprot.readMessageEnd()
4910 phani.kuma 7883 
    result = markAsRTOrders_result()
3064 chandransh 7884 
    try:
4910 phani.kuma 7885 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7886 
    except TransactionServiceException, ex:
7887 
      result.ex = ex
4910 phani.kuma 7888 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7889 
    result.write(oprot)
7890 
    oprot.writeMessageEnd()
7891 
    oprot.trans.flush()
304 ashish 7892 
 
4910 phani.kuma 7893 
  def process_getRTOrders(self, seqid, iprot, oprot):
7894 
    args = getRTOrders_args()
7895 
    args.read(iprot)
7896 
    iprot.readMessageEnd()
7897 
    result = getRTOrders_result()
7898 
    result.success = self._handler.getRTOrders(args.providerId)
7899 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7900 
    result.write(oprot)
7901 
    oprot.writeMessageEnd()
7902 
    oprot.trans.flush()
7903 
 
3064 chandransh 7904 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7905 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7906 
    args.read(iprot)
7907 
    iprot.readMessageEnd()
3064 chandransh 7908 
    result = updateNonDeliveryReason_result()
7909 
    try:
4910 phani.kuma 7910 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7911 
    except TransactionServiceException, ex:
7912 
      result.ex = ex
7913 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7914 
    result.write(oprot)
7915 
    oprot.writeMessageEnd()
7916 
    oprot.trans.flush()
1596 ankur.sing 7917 
 
4910 phani.kuma 7918 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7919 
    args = getNonDeliveredOrdersbyCourier_args()
7920 
    args.read(iprot)
7921 
    iprot.readMessageEnd()
7922 
    result = getNonDeliveredOrdersbyCourier_result()
7923 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7924 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
7929 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7930 
    args = markOrdersAsLocalConnected_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = markOrdersAsLocalConnected_result()
7934 
    try:
7935 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
7942 
 
7943 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7944 
    args = getOrdersNotLocalConnected_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = getOrdersNotLocalConnected_result()
7948 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7949 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7950 
    result.write(oprot)
7951 
    oprot.writeMessageEnd()
7952 
    oprot.trans.flush()
7953 
 
7954 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7955 
    args = markOrdersAsDestinationCityReached_args()
7956 
    args.read(iprot)
7957 
    iprot.readMessageEnd()
7958 
    result = markOrdersAsDestinationCityReached_result()
7959 
    try:
7960 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7961 
    except TransactionServiceException, ex:
7962 
      result.ex = ex
7963 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
7967 
 
7968 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7969 
    args = markOrdersAsFirstDeliveryAttempted_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = markOrdersAsFirstDeliveryAttempted_result()
7973 
    try:
7974 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7975 
    except TransactionServiceException, ex:
7976 
      result.ex = ex
7977 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7978 
    result.write(oprot)
7979 
    oprot.writeMessageEnd()
7980 
    oprot.trans.flush()
7981 
 
3064 chandransh 7982 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7983 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7984 
    args.read(iprot)
7985 
    iprot.readMessageEnd()
3064 chandransh 7986 
    result = getUndeliveredOrders_result()
7987 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7988 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
7992 
 
4783 phani.kuma 7993 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7994 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7998 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7999 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8000 
    result.write(oprot)
8001 
    oprot.writeMessageEnd()
8002 
    oprot.trans.flush()
8003 
 
2536 chandransh 8004 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8005 
    args = toggleDOAFlag_args()
8006 
    args.read(iprot)
8007 
    iprot.readMessageEnd()
8008 
    result = toggleDOAFlag_result()
8009 
    try:
8010 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8011 
    except TransactionServiceException, ex:
8012 
      result.ex = ex
8013 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8014 
    result.write(oprot)
8015 
    oprot.writeMessageEnd()
8016 
    oprot.trans.flush()
1886 ankur.sing 8017 
 
4712 rajveer 8018 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8019 
    args = markOrderAsDelivered_args()
8020 
    args.read(iprot)
8021 
    iprot.readMessageEnd()
8022 
    result = markOrderAsDelivered_result()
8023 
    try:
8024 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8025 
    except TransactionServiceException, ex:
8026 
      result.ex = ex
8027 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8028 
    result.write(oprot)
8029 
    oprot.writeMessageEnd()
8030 
    oprot.trans.flush()
8031 
 
5553 rajveer 8032 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8033 
    args = markOrderAsReceivedAtStore_args()
8034 
    args.read(iprot)
8035 
    iprot.readMessageEnd()
8036 
    result = markOrderAsReceivedAtStore_result()
8037 
    try:
8038 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8039 
    except TransactionServiceException, ex:
8040 
      result.ex = ex
8041 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8042 
    result.write(oprot)
8043 
    oprot.writeMessageEnd()
8044 
    oprot.trans.flush()
8045 
 
4454 rajveer 8046 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8047 
    args = markOrderDoaRequestReceived_args()
8048 
    args.read(iprot)
8049 
    iprot.readMessageEnd()
8050 
    result = markOrderDoaRequestReceived_result()
8051 
    try:
8052 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8053 
    except TransactionServiceException, ex:
8054 
      result.ex = ex
8055 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8056 
    result.write(oprot)
8057 
    oprot.writeMessageEnd()
8058 
    oprot.trans.flush()
8059 
 
8060 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8061 
    args = markOrderDoaRequestAuthorized_args()
8062 
    args.read(iprot)
8063 
    iprot.readMessageEnd()
8064 
    result = markOrderDoaRequestAuthorized_result()
8065 
    try:
8066 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8067 
    except TransactionServiceException, ex:
8068 
      result.ex = ex
8069 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8070 
    result.write(oprot)
8071 
    oprot.writeMessageEnd()
8072 
    oprot.trans.flush()
8073 
 
4488 rajveer 8074 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8075 
    args = markOrderReturnRequestReceived_args()
8076 
    args.read(iprot)
8077 
    iprot.readMessageEnd()
8078 
    result = markOrderReturnRequestReceived_result()
8079 
    try:
8080 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8081 
    except TransactionServiceException, ex:
8082 
      result.ex = ex
8083 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8084 
    result.write(oprot)
8085 
    oprot.writeMessageEnd()
8086 
    oprot.trans.flush()
8087 
 
8088 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8089 
    args = markOrderReturnRequestAuthorized_args()
8090 
    args.read(iprot)
8091 
    iprot.readMessageEnd()
8092 
    result = markOrderReturnRequestAuthorized_result()
8093 
    try:
8094 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8095 
    except TransactionServiceException, ex:
8096 
      result.ex = ex
8097 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8098 
    result.write(oprot)
8099 
    oprot.writeMessageEnd()
8100 
    oprot.trans.flush()
8101 
 
2536 chandransh 8102 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8103 
    args = requestPickupNumber_args()
8104 
    args.read(iprot)
8105 
    iprot.readMessageEnd()
8106 
    result = requestPickupNumber_result()
8107 
    try:
4579 rajveer 8108 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8109 
    except TransactionServiceException, ex:
8110 
      result.ex = ex
8111 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8112 
    result.write(oprot)
8113 
    oprot.writeMessageEnd()
8114 
    oprot.trans.flush()
8115 
 
8116 
  def process_authorizePickup(self, seqid, iprot, oprot):
8117 
    args = authorizePickup_args()
8118 
    args.read(iprot)
8119 
    iprot.readMessageEnd()
8120 
    result = authorizePickup_result()
8121 
    try:
4602 rajveer 8122 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8123 
    except TransactionServiceException, ex:
8124 
      result.ex = ex
8125 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8126 
    result.write(oprot)
8127 
    oprot.writeMessageEnd()
8128 
    oprot.trans.flush()
8129 
 
2764 chandransh 8130 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8131 
    args = markDoasAsPickedUp_args()
8132 
    args.read(iprot)
8133 
    iprot.readMessageEnd()
8134 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8135 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8136 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8137 
    result.write(oprot)
8138 
    oprot.writeMessageEnd()
8139 
    oprot.trans.flush()
8140 
 
4910 phani.kuma 8141 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8142 
    args = getDoasNotPickedUp_args()
8143 
    args.read(iprot)
8144 
    iprot.readMessageEnd()
8145 
    result = getDoasNotPickedUp_result()
8146 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8147 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
8151 
 
4741 phani.kuma 8152 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8153 
    args = markReturnOrdersAsPickedUp_args()
8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
8156 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8157 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8158 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
4910 phani.kuma 8163 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8164 
    args = getReturnOrdersNotPickedUp_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = getReturnOrdersNotPickedUp_result()
8168 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8169 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8170 
    result.write(oprot)
8171 
    oprot.writeMessageEnd()
8172 
    oprot.trans.flush()
8173 
 
2616 chandransh 8174 
  def process_receiveReturn(self, seqid, iprot, oprot):
8175 
    args = receiveReturn_args()
2591 chandransh 8176 
    args.read(iprot)
8177 
    iprot.readMessageEnd()
2616 chandransh 8178 
    result = receiveReturn_result()
2591 chandransh 8179 
    try:
4479 rajveer 8180 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8181 
    except TransactionServiceException, ex:
8182 
      result.ex = ex
2616 chandransh 8183 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8184 
    result.write(oprot)
8185 
    oprot.writeMessageEnd()
8186 
    oprot.trans.flush()
2536 chandransh 8187 
 
2591 chandransh 8188 
  def process_validateDoa(self, seqid, iprot, oprot):
8189 
    args = validateDoa_args()
8190 
    args.read(iprot)
8191 
    iprot.readMessageEnd()
8192 
    result = validateDoa_result()
8193 
    try:
8194 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8195 
    except TransactionServiceException, ex:
8196 
      result.ex = ex
8197 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8198 
    result.write(oprot)
8199 
    oprot.writeMessageEnd()
8200 
    oprot.trans.flush()
8201 
 
4495 rajveer 8202 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8203 
    args = validateReturnProduct_args()
8204 
    args.read(iprot)
8205 
    iprot.readMessageEnd()
8206 
    result = validateReturnProduct_result()
8207 
    try:
8208 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8209 
    except TransactionServiceException, ex:
8210 
      result.ex = ex
8211 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8212 
    result.write(oprot)
8213 
    oprot.writeMessageEnd()
8214 
    oprot.trans.flush()
8215 
 
2616 chandransh 8216 
  def process_reshipOrder(self, seqid, iprot, oprot):
8217 
    args = reshipOrder_args()
8218 
    args.read(iprot)
8219 
    iprot.readMessageEnd()
8220 
    result = reshipOrder_result()
8221 
    try:
8222 
      result.success = self._handler.reshipOrder(args.orderId)
8223 
    except TransactionServiceException, ex:
8224 
      result.ex = ex
8225 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8226 
    result.write(oprot)
8227 
    oprot.writeMessageEnd()
8228 
    oprot.trans.flush()
2591 chandransh 8229 
 
2616 chandransh 8230 
  def process_refundOrder(self, seqid, iprot, oprot):
8231 
    args = refundOrder_args()
8232 
    args.read(iprot)
8233 
    iprot.readMessageEnd()
8234 
    result = refundOrder_result()
8235 
    try:
3226 chandransh 8236 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8237 
    except TransactionServiceException, ex:
8238 
      result.ex = ex
8239 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8240 
    result.write(oprot)
8241 
    oprot.writeMessageEnd()
8242 
    oprot.trans.flush()
8243 
 
2690 chandransh 8244 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8245 
    args = getReturnOrders_args()
8246 
    args.read(iprot)
8247 
    iprot.readMessageEnd()
8248 
    result = getReturnOrders_result()
8249 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8250 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8251 
    result.write(oprot)
8252 
    oprot.writeMessageEnd()
8253 
    oprot.trans.flush()
2616 chandransh 8254 
 
5481 phani.kuma 8255 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8256 
    args = getAllReturnOrders_args()
8257 
    args.read(iprot)
8258 
    iprot.readMessageEnd()
8259 
    result = getAllReturnOrders_result()
8260 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8261 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
8265 
 
2700 chandransh 8266 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8267 
    args = getReturnOrder_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = getReturnOrder_result()
8271 
    try:
8272 
      result.success = self._handler.getReturnOrder(args.id)
8273 
    except TransactionServiceException, ex:
8274 
      result.ex = ex
8275 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8276 
    result.write(oprot)
8277 
    oprot.writeMessageEnd()
8278 
    oprot.trans.flush()
8279 
 
2690 chandransh 8280 
  def process_processReturn(self, seqid, iprot, oprot):
8281 
    args = processReturn_args()
8282 
    args.read(iprot)
8283 
    iprot.readMessageEnd()
8284 
    result = processReturn_result()
8285 
    try:
8286 
      self._handler.processReturn(args.returnOrderId)
8287 
    except TransactionServiceException, ex:
8288 
      result.ex = ex
8289 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8290 
    result.write(oprot)
8291 
    oprot.writeMessageEnd()
8292 
    oprot.trans.flush()
8293 
 
3451 chandransh 8294 
  def process_updateWeight(self, seqid, iprot, oprot):
8295 
    args = updateWeight_args()
8296 
    args.read(iprot)
8297 
    iprot.readMessageEnd()
8298 
    result = updateWeight_result()
8299 
    try:
8300 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8301 
    except TransactionServiceException, ex:
8302 
      result.ex = ex
8303 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8304 
    result.write(oprot)
8305 
    oprot.writeMessageEnd()
8306 
    oprot.trans.flush()
2819 chandransh 8307 
 
3469 chandransh 8308 
  def process_changeItem(self, seqid, iprot, oprot):
8309 
    args = changeItem_args()
8310 
    args.read(iprot)
8311 
    iprot.readMessageEnd()
8312 
    result = changeItem_result()
8313 
    try:
8314 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8315 
    except TransactionServiceException, ex:
8316 
      result.ex = ex
8317 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8318 
    result.write(oprot)
8319 
    oprot.writeMessageEnd()
8320 
    oprot.trans.flush()
3451 chandransh 8321 
 
3469 chandransh 8322 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8323 
    args = shiftToWarehouse_args()
8324 
    args.read(iprot)
8325 
    iprot.readMessageEnd()
8326 
    result = shiftToWarehouse_result()
8327 
    try:
8328 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8329 
    except TransactionServiceException, ex:
8330 
      result.ex = ex
8331 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8332 
    result.write(oprot)
8333 
    oprot.writeMessageEnd()
8334 
    oprot.trans.flush()
8335 
 
3553 chandransh 8336 
  def process_addDelayReason(self, seqid, iprot, oprot):
8337 
    args = addDelayReason_args()
8338 
    args.read(iprot)
8339 
    iprot.readMessageEnd()
8340 
    result = addDelayReason_result()
8341 
    try:
4647 rajveer 8342 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8343 
    except TransactionServiceException, ex:
8344 
      result.ex = ex
8345 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8346 
    result.write(oprot)
8347 
    oprot.writeMessageEnd()
8348 
    oprot.trans.flush()
3469 chandransh 8349 
 
3956 chandransh 8350 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8351 
    args = reconcileCodCollection_args()
8352 
    args.read(iprot)
8353 
    iprot.readMessageEnd()
8354 
    result = reconcileCodCollection_result()
8355 
    try:
8356 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8357 
    except TransactionServiceException, ex:
8358 
      result.ex = ex
8359 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8360 
    result.write(oprot)
8361 
    oprot.writeMessageEnd()
8362 
    oprot.trans.flush()
3553 chandransh 8363 
 
4008 mandeep.dh 8364 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8365 
    args = getTransactionsRequiringExtraProcessing_args()
8366 
    args.read(iprot)
8367 
    iprot.readMessageEnd()
8368 
    result = getTransactionsRequiringExtraProcessing_result()
8369 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8370 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8371 
    result.write(oprot)
8372 
    oprot.writeMessageEnd()
8373 
    oprot.trans.flush()
3956 chandransh 8374 
 
4008 mandeep.dh 8375 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8376 
    args = markTransactionAsProcessed_args()
8377 
    args.read(iprot)
8378 
    iprot.readMessageEnd()
8379 
    result = markTransactionAsProcessed_result()
8380 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8381 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8382 
    result.write(oprot)
8383 
    oprot.writeMessageEnd()
8384 
    oprot.trans.flush()
8385 
 
4018 chandransh 8386 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8387 
    args = getItemWiseRiskyOrdersCount_args()
8388 
    args.read(iprot)
8389 
    iprot.readMessageEnd()
8390 
    result = getItemWiseRiskyOrdersCount_result()
8391 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8392 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
4008 mandeep.dh 8396 
 
4295 varun.gupt 8397 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8398 
    args = getOrdersForItemIds_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = getOrdersForItemIds_result()
8402 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8403 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8404 
    result.write(oprot)
8405 
    oprot.writeMessageEnd()
8406 
    oprot.trans.flush()
8407 
 
4247 rajveer 8408 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8409 
    args = markOrderCancellationRequestReceived_args()
8410 
    args.read(iprot)
8411 
    iprot.readMessageEnd()
8412 
    result = markOrderCancellationRequestReceived_result()
8413 
    try:
8414 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8415 
    except TransactionServiceException, ex:
8416 
      result.ex = ex
8417 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8418 
    result.write(oprot)
8419 
    oprot.writeMessageEnd()
8420 
    oprot.trans.flush()
4018 chandransh 8421 
 
4247 rajveer 8422 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8423 
    args = markOrderCancellationRequestConfirmed_args()
8424 
    args.read(iprot)
8425 
    iprot.readMessageEnd()
8426 
    result = markOrderCancellationRequestConfirmed_result()
8427 
    try:
8428 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8429 
    except TransactionServiceException, ex:
8430 
      result.ex = ex
8431 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8432 
    result.write(oprot)
8433 
    oprot.writeMessageEnd()
8434 
    oprot.trans.flush()
8435 
 
8436 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8437 
    args = markOrderCancellationRequestDenied_args()
8438 
    args.read(iprot)
8439 
    iprot.readMessageEnd()
8440 
    result = markOrderCancellationRequestDenied_result()
8441 
    try:
8442 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8443 
    except TransactionServiceException, ex:
8444 
      result.ex = ex
8445 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8446 
    result.write(oprot)
8447 
    oprot.writeMessageEnd()
8448 
    oprot.trans.flush()
8449 
 
4258 rajveer 8450 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8451 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8452 
    args.read(iprot)
8453 
    iprot.readMessageEnd()
4258 rajveer 8454 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8455 
    try:
4258 rajveer 8456 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8457 
    except TransactionServiceException, ex:
8458 
      result.ex = ex
4258 rajveer 8459 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8460 
    result.write(oprot)
8461 
    oprot.writeMessageEnd()
8462 
    oprot.trans.flush()
8463 
 
4259 anupam.sin 8464 
  def process_refundTransaction(self, seqid, iprot, oprot):
8465 
    args = refundTransaction_args()
8466 
    args.read(iprot)
8467 
    iprot.readMessageEnd()
8468 
    result = refundTransaction_result()
8469 
    try:
8470 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8471 
    except TransactionServiceException, ex:
8472 
      result.ex = ex
8473 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8474 
    result.write(oprot)
8475 
    oprot.writeMessageEnd()
8476 
    oprot.trans.flush()
4247 rajveer 8477 
 
4324 mandeep.dh 8478 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8479 
    args = updateShipmentAddress_args()
8480 
    args.read(iprot)
8481 
    iprot.readMessageEnd()
8482 
    result = updateShipmentAddress_result()
8483 
    try:
8484 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8485 
    except TransactionServiceException, ex:
8486 
      result.ex = ex
8487 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8488 
    result.write(oprot)
8489 
    oprot.writeMessageEnd()
8490 
    oprot.trans.flush()
8491 
 
4285 rajveer 8492 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8493 
    args = acceptOrdersForItemId_args()
8494 
    args.read(iprot)
8495 
    iprot.readMessageEnd()
8496 
    result = acceptOrdersForItemId_result()
8497 
    try:
8498 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8499 
    except TransactionServiceException, ex:
8500 
      result.ex = ex
8501 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8502 
    result.write(oprot)
8503 
    oprot.writeMessageEnd()
8504 
    oprot.trans.flush()
4259 anupam.sin 8505 
 
4303 rajveer 8506 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8507 
    args = markOrdersAsPORaised_args()
8508 
    args.read(iprot)
8509 
    iprot.readMessageEnd()
8510 
    result = markOrdersAsPORaised_result()
8511 
    try:
4369 rajveer 8512 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8513 
    except TransactionServiceException, ex:
8514 
      result.ex = ex
8515 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8516 
    result.write(oprot)
8517 
    oprot.writeMessageEnd()
8518 
    oprot.trans.flush()
4285 rajveer 8519 
 
4303 rajveer 8520 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8521 
    args = markOrdersAsReversalInitiated_args()
8522 
    args.read(iprot)
8523 
    iprot.readMessageEnd()
8524 
    result = markOrdersAsReversalInitiated_result()
8525 
    try:
4369 rajveer 8526 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8527 
    except TransactionServiceException, ex:
8528 
      result.ex = ex
8529 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8530 
    result.write(oprot)
8531 
    oprot.writeMessageEnd()
8532 
    oprot.trans.flush()
8533 
 
8534 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8535 
    args = markOrdersAsNotAvailabke_args()
8536 
    args.read(iprot)
8537 
    iprot.readMessageEnd()
8538 
    result = markOrdersAsNotAvailabke_result()
8539 
    try:
4369 rajveer 8540 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8541 
    except TransactionServiceException, ex:
8542 
      result.ex = ex
8543 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8544 
    result.write(oprot)
8545 
    oprot.writeMessageEnd()
8546 
    oprot.trans.flush()
8547 
 
4369 rajveer 8548 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8549 
    args = markOrdersAsTimeout_args()
8550 
    args.read(iprot)
8551 
    iprot.readMessageEnd()
8552 
    result = markOrdersAsTimeout_result()
8553 
    try:
8554 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8555 
    except TransactionServiceException, ex:
8556 
      result.ex = ex
8557 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8558 
    result.write(oprot)
8559 
    oprot.writeMessageEnd()
8560 
    oprot.trans.flush()
4303 rajveer 8561 
 
4662 rajveer 8562 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8563 
    args = markOrderAsLostInTransit_args()
8564 
    args.read(iprot)
8565 
    iprot.readMessageEnd()
8566 
    result = markOrderAsLostInTransit_result()
8567 
    try:
8568 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8569 
    except TransactionServiceException, ex:
8570 
      result.ex = ex
8571 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8572 
    result.write(oprot)
8573 
    oprot.writeMessageEnd()
8574 
    oprot.trans.flush()
8575 
 
4386 anupam.sin 8576 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8577 
    args = getOrderForAwb_args()
8578 
    args.read(iprot)
8579 
    iprot.readMessageEnd()
8580 
    result = getOrderForAwb_result()
8581 
    try:
8582 
      result.success = self._handler.getOrderForAwb(args.awb)
8583 
    except TransactionServiceException, ex:
8584 
      result.ex = ex
8585 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8586 
    result.write(oprot)
8587 
    oprot.writeMessageEnd()
8588 
    oprot.trans.flush()
4369 rajveer 8589 
 
4506 phani.kuma 8590 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8591 
    args = getOrdersForProviderForStatus_args()
8592 
    args.read(iprot)
8593 
    iprot.readMessageEnd()
8594 
    result = getOrdersForProviderForStatus_result()
8595 
    try:
4910 phani.kuma 8596 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8597 
    except TransactionServiceException, ex:
8598 
      result.ex = ex
8599 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8600 
    result.write(oprot)
8601 
    oprot.writeMessageEnd()
8602 
    oprot.trans.flush()
4386 anupam.sin 8603 
 
4600 varun.gupt 8604 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8605 
    args = getBilledOrdersForVendor_args()
8606 
    args.read(iprot)
8607 
    iprot.readMessageEnd()
8608 
    result = getBilledOrdersForVendor_result()
8609 
    try:
8610 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8611 
    except TransactionServiceException, ex:
8612 
      result.ex = ex
8613 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8614 
    result.write(oprot)
8615 
    oprot.writeMessageEnd()
8616 
    oprot.trans.flush()
4506 phani.kuma 8617 
 
4607 rajveer 8618 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8619 
    args = getSlippedSippingDateOrders_args()
8620 
    args.read(iprot)
8621 
    iprot.readMessageEnd()
8622 
    result = getSlippedSippingDateOrders_result()
8623 
    try:
8624 
      result.success = self._handler.getSlippedSippingDateOrders()
8625 
    except TransactionServiceException, ex:
8626 
      result.ex = ex
8627 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8628 
    result.write(oprot)
8629 
    oprot.writeMessageEnd()
8630 
    oprot.trans.flush()
8631 
 
4709 rajveer 8632 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8633 
    args = getCancelledOrders_args()
8634 
    args.read(iprot)
8635 
    iprot.readMessageEnd()
8636 
    result = getCancelledOrders_result()
8637 
    try:
8638 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8639 
    except TransactionServiceException, ex:
8640 
      result.ex = ex
8641 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8642 
    result.write(oprot)
8643 
    oprot.writeMessageEnd()
8644 
    oprot.trans.flush()
8645 
 
4600 varun.gupt 8646 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8647 
    args = saveBluedartSettlements_args()
8648 
    args.read(iprot)
8649 
    iprot.readMessageEnd()
8650 
    result = saveBluedartSettlements_result()
8651 
    try:
8652 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8653 
    except TransactionServiceException, ex:
8654 
      result.ex = ex
8655 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8656 
    result.write(oprot)
8657 
    oprot.writeMessageEnd()
8658 
    oprot.trans.flush()
8659 
 
8660 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8661 
    args = savePaymentSettlements_args()
8662 
    args.read(iprot)
8663 
    iprot.readMessageEnd()
8664 
    result = savePaymentSettlements_result()
8665 
    try:
4905 varun.gupt 8666 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8667 
    except TransactionServiceException, ex:
8668 
      result.ex = ex
8669 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8670 
    result.write(oprot)
8671 
    oprot.writeMessageEnd()
8672 
    oprot.trans.flush()
8673 
 
8674 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8675 
    args = saveEBSSettlementSummary_args()
8676 
    args.read(iprot)
8677 
    iprot.readMessageEnd()
8678 
    result = saveEBSSettlementSummary_result()
8679 
    try:
8680 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8681 
    except TransactionServiceException, ex:
8682 
      result.ex = ex
8683 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8684 
    result.write(oprot)
8685 
    oprot.writeMessageEnd()
8686 
    oprot.trans.flush()
8687 
 
5386 phani.kuma 8688 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8689 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8690 
    args.read(iprot)
8691 
    iprot.readMessageEnd()
5386 phani.kuma 8692 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8693 
    try:
5386 phani.kuma 8694 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8695 
    except TransactionServiceException, ex:
8696 
      result.ex = ex
5386 phani.kuma 8697 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8698 
    result.write(oprot)
8699 
    oprot.writeMessageEnd()
8700 
    oprot.trans.flush()
8701 
 
5386 phani.kuma 8702 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8703 
    args = getSettlementForCod_args()
8704 
    args.read(iprot)
8705 
    iprot.readMessageEnd()
8706 
    result = getSettlementForCod_result()
8707 
    try:
8708 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8709 
    except TransactionServiceException, ex:
8710 
      result.ex = ex
8711 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8712 
    result.write(oprot)
8713 
    oprot.writeMessageEnd()
8714 
    oprot.trans.flush()
8715 
 
4600 varun.gupt 8716 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8717 
    args = getEBSSettlementSummaries_args()
8718 
    args.read(iprot)
8719 
    iprot.readMessageEnd()
8720 
    result = getEBSSettlementSummaries_result()
8721 
    try:
8722 
      result.success = self._handler.getEBSSettlementSummaries()
8723 
    except TransactionServiceException, ex:
8724 
      result.ex = ex
8725 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8726 
    result.write(oprot)
8727 
    oprot.writeMessageEnd()
8728 
    oprot.trans.flush()
8729 
 
8730 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8731 
    args = markEBSSettlementUploaded_args()
8732 
    args.read(iprot)
8733 
    iprot.readMessageEnd()
8734 
    result = markEBSSettlementUploaded_result()
8735 
    try:
8736 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8737 
    except TransactionServiceException, ex:
8738 
      result.ex = ex
8739 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8740 
    result.write(oprot)
8741 
    oprot.writeMessageEnd()
8742 
    oprot.trans.flush()
8743 
 
8744 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8745 
    args = getEBSSettlementDate_args()
8746 
    args.read(iprot)
8747 
    iprot.readMessageEnd()
8748 
    result = getEBSSettlementDate_result()
8749 
    try:
8750 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8751 
    except TransactionServiceException, ex:
8752 
      result.ex = ex
8753 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8754 
    result.write(oprot)
8755 
    oprot.writeMessageEnd()
8756 
    oprot.trans.flush()
8757 
 
4715 varun.gupt 8758 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8759 
    args = getSettlementsByDate_args()
8760 
    args.read(iprot)
8761 
    iprot.readMessageEnd()
8762 
    result = getSettlementsByDate_result()
8763 
    try:
8764 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8765 
    except TransactionServiceException, ex:
8766 
      result.ex = ex
8767 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8768 
    result.write(oprot)
8769 
    oprot.writeMessageEnd()
8770 
    oprot.trans.flush()
4600 varun.gupt 8771 
 
4715 varun.gupt 8772 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8773 
    args = getReshippedOrderIds_args()
8774 
    args.read(iprot)
8775 
    iprot.readMessageEnd()
8776 
    result = getReshippedOrderIds_result()
8777 
    try:
8778 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8779 
    except TransactionServiceException, ex:
8780 
      result.ex = ex
8781 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8782 
    result.write(oprot)
8783 
    oprot.writeMessageEnd()
8784 
    oprot.trans.flush()
8785 
 
5481 phani.kuma 8786 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8787 
    args = getBilledOrders_args()
4875 varun.gupt 8788 
    args.read(iprot)
8789 
    iprot.readMessageEnd()
5481 phani.kuma 8790 
    result = getBilledOrders_result()
4875 varun.gupt 8791 
    try:
5481 phani.kuma 8792 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8793 
    except TransactionServiceException, ex:
8794 
      result.ex = ex
5481 phani.kuma 8795 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8796 
    result.write(oprot)
8797 
    oprot.writeMessageEnd()
8798 
    oprot.trans.flush()
4757 mandeep.dh 8799 
 
5031 varun.gupt 8800 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8801 
    args = getStatusDistributionOfOrders_args()
8802 
    args.read(iprot)
8803 
    iprot.readMessageEnd()
8804 
    result = getStatusDistributionOfOrders_result()
8805 
    try:
8806 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8807 
    except TransactionServiceException, ex:
8808 
      result.ex = ex
8809 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8810 
    result.write(oprot)
8811 
    oprot.writeMessageEnd()
8812 
    oprot.trans.flush()
4875 varun.gupt 8813 
 
5067 varun.gupt 8814 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8815 
    args = getOrderIdsForStatus_args()
8816 
    args.read(iprot)
8817 
    iprot.readMessageEnd()
8818 
    result = getOrderIdsForStatus_result()
8819 
    try:
8820 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8821 
    except TransactionServiceException, ex:
8822 
      result.ex = ex
8823 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8824 
    result.write(oprot)
8825 
    oprot.writeMessageEnd()
8826 
    oprot.trans.flush()
5031 varun.gupt 8827 
 
5348 anupam.sin 8828 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8829 
    args = updateCODAgent_args()
8830 
    args.read(iprot)
8831 
    iprot.readMessageEnd()
8832 
    result = updateCODAgent_result()
8833 
    try:
8834 
      self._handler.updateCODAgent(args.agent, args.orderId)
8835 
    except TransactionServiceException, ex:
8836 
      result.ex = ex
8837 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8838 
    result.write(oprot)
8839 
    oprot.writeMessageEnd()
8840 
    oprot.trans.flush()
8841 
 
5099 varun.gupt 8842 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8843 
    args = updateOrderAsPaidToVendor_args()
8844 
    args.read(iprot)
8845 
    iprot.readMessageEnd()
8846 
    result = updateOrderAsPaidToVendor_result()
8847 
    try:
8848 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8849 
    except TransactionServiceException, ex:
8850 
      result.ex = ex
8851 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8852 
    result.write(oprot)
8853 
    oprot.writeMessageEnd()
8854 
    oprot.trans.flush()
5067 varun.gupt 8855 
 
5386 phani.kuma 8856 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8857 
    args = updateOrderOnlyAsPaidToVendor_args()
8858 
    args.read(iprot)
8859 
    iprot.readMessageEnd()
8860 
    result = updateOrderOnlyAsPaidToVendor_result()
8861 
    try:
8862 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8863 
    except TransactionServiceException, ex:
8864 
      result.ex = ex
8865 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8866 
    result.write(oprot)
8867 
    oprot.writeMessageEnd()
8868 
    oprot.trans.flush()
8869 
 
5208 varun.gupt 8870 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8871 
    args = getRefundedOrdersMarkedPaid_args()
8872 
    args.read(iprot)
8873 
    iprot.readMessageEnd()
8874 
    result = getRefundedOrdersMarkedPaid_result()
8875 
    try:
8876 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8877 
    except TransactionServiceException, ex:
8878 
      result.ex = ex
8879 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8880 
    result.write(oprot)
8881 
    oprot.writeMessageEnd()
8882 
    oprot.trans.flush()
5099 varun.gupt 8883 
 
5447 anupam.sin 8884 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8885 
    args = getAllVerificationAgents_args()
8886 
    args.read(iprot)
8887 
    iprot.readMessageEnd()
8888 
    result = getAllVerificationAgents_result()
8889 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8890 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8891 
    result.write(oprot)
8892 
    oprot.writeMessageEnd()
8893 
    oprot.trans.flush()
5208 varun.gupt 8894 
 
5527 anupam.sin 8895 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8896 
    args = getAllAttributesForOrderId_args()
8897 
    args.read(iprot)
8898 
    iprot.readMessageEnd()
8899 
    result = getAllAttributesForOrderId_result()
8900 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8901 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8902 
    result.write(oprot)
8903 
    oprot.writeMessageEnd()
8904 
    oprot.trans.flush()
5447 anupam.sin 8905 
 
5676 rajveer 8906 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8907 
    args = setOrderAttributes_args()
8908 
    args.read(iprot)
8909 
    iprot.readMessageEnd()
8910 
    result = setOrderAttributes_result()
8911 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8912 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8913 
    result.write(oprot)
8914 
    oprot.writeMessageEnd()
8915 
    oprot.trans.flush()
8916 
 
5527 anupam.sin 8917 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8918 
    args = setOrderAttributeForTransaction_args()
8919 
    args.read(iprot)
8920 
    iprot.readMessageEnd()
8921 
    result = setOrderAttributeForTransaction_result()
8922 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8923 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8924 
    result.write(oprot)
8925 
    oprot.writeMessageEnd()
8926 
    oprot.trans.flush()
8927 
 
5553 rajveer 8928 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8929 
    args = getReceivePendingOrders_args()
8930 
    args.read(iprot)
8931 
    iprot.readMessageEnd()
8932 
    result = getReceivePendingOrders_result()
8933 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8934 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8935 
    result.write(oprot)
8936 
    oprot.writeMessageEnd()
8937 
    oprot.trans.flush()
5527 anupam.sin 8938 
 
5553 rajveer 8939 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8940 
    args = getReceivedAtStoreOrders_args()
8941 
    args.read(iprot)
8942 
    iprot.readMessageEnd()
8943 
    result = getReceivedAtStoreOrders_result()
8944 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8945 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8946 
    result.write(oprot)
8947 
    oprot.writeMessageEnd()
8948 
    oprot.trans.flush()
8949 
 
5713 rajveer 8950 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8951 
    args = getOrdersCollectionAtStore_args()
8952 
    args.read(iprot)
8953 
    iprot.readMessageEnd()
8954 
    result = getOrdersCollectionAtStore_result()
8955 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8956 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8957 
    result.write(oprot)
8958 
    oprot.writeMessageEnd()
8959 
    oprot.trans.flush()
8960 
 
5833 rajveer 8961 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8962 
    args = getOrderAttributeValue_args()
8963 
    args.read(iprot)
8964 
    iprot.readMessageEnd()
8965 
    result = getOrderAttributeValue_result()
8966 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8967 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8968 
    result.write(oprot)
8969 
    oprot.writeMessageEnd()
8970 
    oprot.trans.flush()
8971 
 
6019 rajveer 8972 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8973 
    args = changeJacketNumber_args()
8974 
    args.read(iprot)
8975 
    iprot.readMessageEnd()
8976 
    result = changeJacketNumber_result()
8977 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8978 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8979 
    result.write(oprot)
8980 
    oprot.writeMessageEnd()
8981 
    oprot.trans.flush()
8982 
 
8983 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8984 
    args = markOrderAsRtoInTransit_args()
8985 
    args.read(iprot)
8986 
    iprot.readMessageEnd()
8987 
    result = markOrderAsRtoInTransit_result()
8988 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8989 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8990 
    result.write(oprot)
8991 
    oprot.writeMessageEnd()
8992 
    oprot.trans.flush()
8993 
 
5593 mandeep.dh 8994 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8995 
    args = acceptOrderForItem_args()
8996 
    args.read(iprot)
8997 
    iprot.readMessageEnd()
8998 
    result = acceptOrderForItem_result()
8999 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9000 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9001 
    result.write(oprot)
9002 
    oprot.writeMessageEnd()
9003 
    oprot.trans.flush()
5553 rajveer 9004 
 
6000 mandeep.dh 9005 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9006 
    args = createRechargeOrder_args()
9007 
    args.read(iprot)
9008 
    iprot.readMessageEnd()
9009 
    result = createRechargeOrder_result()
9010 
    try:
9011 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9012 
    except TransactionServiceException, ex:
9013 
      result.ex = ex
9014 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9015 
    result.write(oprot)
9016 
    oprot.writeMessageEnd()
9017 
    oprot.trans.flush()
5593 mandeep.dh 9018 
 
6031 rajveer 9019 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9020 
    args = getRechargeOrder_args()
9021 
    args.read(iprot)
9022 
    iprot.readMessageEnd()
9023 
    result = getRechargeOrder_result()
9024 
    try:
9025 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9026 
    except TransactionServiceException, ex:
9027 
      result.ex = ex
9028 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9029 
    result.write(oprot)
9030 
    oprot.writeMessageEnd()
9031 
    oprot.trans.flush()
9032 
 
9033 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9034 
    args = getRechargeOrders_args()
9035 
    args.read(iprot)
9036 
    iprot.readMessageEnd()
9037 
    result = getRechargeOrders_result()
9038 
    result.success = self._handler.getRechargeOrders(args.userId)
9039 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9040 
    result.write(oprot)
9041 
    oprot.writeMessageEnd()
9042 
    oprot.trans.flush()
9043 
 
6000 mandeep.dh 9044 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9045 
    args = updateRechargeOrderStatus_args()
9046 
    args.read(iprot)
9047 
    iprot.readMessageEnd()
9048 
    result = updateRechargeOrderStatus_result()
9049 
    try:
6031 rajveer 9050 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9051 
    except TransactionServiceException, ex:
9052 
      result.ex = ex
9053 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9054 
    result.write(oprot)
9055 
    oprot.writeMessageEnd()
9056 
    oprot.trans.flush()
9057 
 
9058 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9059 
    args = activateRechargeTxn_args()
9060 
    args.read(iprot)
9061 
    iprot.readMessageEnd()
9062 
    result = activateRechargeTxn_result()
9063 
    try:
6031 rajveer 9064 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9065 
    except TransactionServiceException, ex:
9066 
      result.ex = ex
9067 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9068 
    result.write(oprot)
9069 
    oprot.writeMessageEnd()
9070 
    oprot.trans.flush()
9071 
 
6031 rajveer 9072 
  def process_getUserWallet(self, seqid, iprot, oprot):
9073 
    args = getUserWallet_args()
6000 mandeep.dh 9074 
    args.read(iprot)
9075 
    iprot.readMessageEnd()
6031 rajveer 9076 
    result = getUserWallet_result()
9077 
    result.success = self._handler.getUserWallet(args.userId)
9078 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9079 
    result.write(oprot)
9080 
    oprot.writeMessageEnd()
9081 
    oprot.trans.flush()
9082 
 
6031 rajveer 9083 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9084 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9085 
    args.read(iprot)
9086 
    iprot.readMessageEnd()
6031 rajveer 9087 
    result = getUserWalletHistory_result()
9088 
    result.success = self._handler.getUserWalletHistory(args.userId)
9089 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9090 
    result.write(oprot)
9091 
    oprot.writeMessageEnd()
9092 
    oprot.trans.flush()
9093 
 
6050 anupam.sin 9094 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9095 
    args = getRechargeOrdersForTransaction_args()
9096 
    args.read(iprot)
9097 
    iprot.readMessageEnd()
9098 
    result = getRechargeOrdersForTransaction_result()
9099 
    try:
9100 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9101 
    except TransactionServiceException, ex:
9102 
      result.ex = ex
9103 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9104 
    result.write(oprot)
9105 
    oprot.writeMessageEnd()
9106 
    oprot.trans.flush()
9107 
 
6048 rajveer 9108 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9109 
    args = getServiceProviders_args()
9110 
    args.read(iprot)
9111 
    iprot.readMessageEnd()
9112 
    result = getServiceProviders_result()
6206 rajveer 9113 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9114 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9115 
    result.write(oprot)
9116 
    oprot.writeMessageEnd()
9117 
    oprot.trans.flush()
6000 mandeep.dh 9118 
 
6048 rajveer 9119 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9120 
    args = getServiceProviderForDevice_args()
9121 
    args.read(iprot)
9122 
    iprot.readMessageEnd()
9123 
    result = getServiceProviderForDevice_result()
6049 rajveer 9124 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9125 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9126 
    result.write(oprot)
9127 
    oprot.writeMessageEnd()
9128 
    oprot.trans.flush()
9129 
 
6269 rajveer 9130 
  def process_validateRecharge(self, seqid, iprot, oprot):
9131 
    args = validateRecharge_args()
9132 
    args.read(iprot)
9133 
    iprot.readMessageEnd()
9134 
    result = validateRecharge_result()
6591 anupam.sin 9135 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9136 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9137 
    result.write(oprot)
9138 
    oprot.writeMessageEnd()
9139 
    oprot.trans.flush()
9140 
 
6094 rajveer 9141 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9142 
    args = getRechargeOrdersForDevice_args()
9143 
    args.read(iprot)
9144 
    iprot.readMessageEnd()
9145 
    result = getRechargeOrdersForDevice_result()
9146 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9147 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9148 
    result.write(oprot)
9149 
    oprot.writeMessageEnd()
9150 
    oprot.trans.flush()
6048 rajveer 9151 
 
6094 rajveer 9152 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9153 
    args = addAmountToWallet_args()
9154 
    args.read(iprot)
9155 
    iprot.readMessageEnd()
9156 
    result = addAmountToWallet_result()
9157 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9158 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9159 
    result.write(oprot)
9160 
    oprot.writeMessageEnd()
9161 
    oprot.trans.flush()
9162 
 
6188 rajveer 9163 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9164 
    args = getRechargeStatistics_args()
9165 
    args.read(iprot)
9166 
    iprot.readMessageEnd()
9167 
    result = getRechargeStatistics_result()
9168 
    result.success = self._handler.getRechargeStatistics()
9169 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9170 
    result.write(oprot)
9171 
    oprot.writeMessageEnd()
9172 
    oprot.trans.flush()
9173 
 
6154 rajveer 9174 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9175 
    args = getRechargeOrdersForStatus_args()
9176 
    args.read(iprot)
9177 
    iprot.readMessageEnd()
9178 
    result = getRechargeOrdersForStatus_result()
9179 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9180 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9181 
    result.write(oprot)
9182 
    oprot.writeMessageEnd()
9183 
    oprot.trans.flush()
6094 rajveer 9184 
 
6159 rajveer 9185 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9186 
    args = getPlansForOperator_args()
9187 
    args.read(iprot)
9188 
    iprot.readMessageEnd()
9189 
    result = getPlansForOperator_result()
9190 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9191 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9192 
    result.write(oprot)
9193 
    oprot.writeMessageEnd()
9194 
    oprot.trans.flush()
6154 rajveer 9195 
 
6289 anupam.sin 9196 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9197 
    args = getRechargeDenominations_args()
9198 
    args.read(iprot)
9199 
    iprot.readMessageEnd()
9200 
    result = getRechargeDenominations_result()
9201 
    try:
6307 anupam.sin 9202 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9203 
    except TransactionServiceException, ex:
9204 
      result.ex = ex
9205 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9206 
    result.write(oprot)
9207 
    oprot.writeMessageEnd()
9208 
    oprot.trans.flush()
6159 rajveer 9209 
 
6371 rajveer 9210 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9211 
    args = updateAvailabilityStatus_args()
9212 
    args.read(iprot)
9213 
    iprot.readMessageEnd()
9214 
    result = updateAvailabilityStatus_result()
9215 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9216 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9217 
    result.write(oprot)
9218 
    oprot.writeMessageEnd()
9219 
    oprot.trans.flush()
6289 anupam.sin 9220 
 
6389 rajveer 9221 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9222 
    args = getAvailableEmiSchemes_args()
9223 
    args.read(iprot)
9224 
    iprot.readMessageEnd()
9225 
    result = getAvailableEmiSchemes_result()
9226 
    result.success = self._handler.getAvailableEmiSchemes()
9227 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9228 
    result.write(oprot)
9229 
    oprot.writeMessageEnd()
9230 
    oprot.trans.flush()
6371 rajveer 9231 
 
6389 rajveer 9232 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9233 
    args = getMiscCharges_args()
9234 
    args.read(iprot)
9235 
    iprot.readMessageEnd()
9236 
    result = getMiscCharges_result()
9237 
    result.success = self._handler.getMiscCharges(args.transactionId)
9238 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9239 
    result.write(oprot)
9240 
    oprot.writeMessageEnd()
9241 
    oprot.trans.flush()
9242 
 
6507 anupam.sin 9243 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9244 
    args = refundRechargeOrder_args()
9245 
    args.read(iprot)
9246 
    iprot.readMessageEnd()
9247 
    result = refundRechargeOrder_result()
9248 
    try:
9249 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9250 
    except TransactionServiceException, ex:
9251 
      result.ex = ex
9252 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9253 
    result.write(oprot)
9254 
    oprot.writeMessageEnd()
9255 
    oprot.trans.flush()
6389 rajveer 9256 
 
6821 amar.kumar 9257 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9258 
    args = getPhysicalOrders_args()
9259 
    args.read(iprot)
9260 
    iprot.readMessageEnd()
9261 
    result = getPhysicalOrders_result()
9262 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9263 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9264 
    result.write(oprot)
9265 
    oprot.writeMessageEnd()
9266 
    oprot.trans.flush()
6507 anupam.sin 9267 
 
6906 rajveer 9268 
  def process_getDocument(self, seqid, iprot, oprot):
9269 
    args = getDocument_args()
9270 
    args.read(iprot)
9271 
    iprot.readMessageEnd()
9272 
    result = getDocument_result()
9273 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9274 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9275 
    result.write(oprot)
9276 
    oprot.writeMessageEnd()
9277 
    oprot.trans.flush()
6821 amar.kumar 9278 
 
6985 anupam.sin 9279 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9280 
    args = changeShippingAddress_args()
9281 
    args.read(iprot)
9282 
    iprot.readMessageEnd()
9283 
    result = changeShippingAddress_result()
9284 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9285 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9286 
    result.write(oprot)
9287 
    oprot.writeMessageEnd()
9288 
    oprot.trans.flush()
6906 rajveer 9289 
 
6988 rajveer 9290 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9291 
    args = retrieveInvoice_args()
9292 
    args.read(iprot)
9293 
    iprot.readMessageEnd()
9294 
    result = retrieveInvoice_result()
7075 rajveer 9295 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9296 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9297 
    result.write(oprot)
9298 
    oprot.writeMessageEnd()
9299 
    oprot.trans.flush()
6985 anupam.sin 9300 
 
7026 rajveer 9301 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9302 
    args = receiveUpdatesForRedExpress_args()
9303 
    args.read(iprot)
9304 
    iprot.readMessageEnd()
9305 
    result = receiveUpdatesForRedExpress_result()
9306 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9307 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9308 
    result.write(oprot)
9309 
    oprot.writeMessageEnd()
9310 
    oprot.trans.flush()
6988 rajveer 9311 
 
7073 anupam.sin 9312 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9313 
    args = createRechargeTransaction_args()
9314 
    args.read(iprot)
9315 
    iprot.readMessageEnd()
9316 
    result = createRechargeTransaction_result()
9317 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9318 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9319 
    result.write(oprot)
9320 
    oprot.writeMessageEnd()
9321 
    oprot.trans.flush()
7026 rajveer 9322 
 
7085 rajveer 9323 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9324 
    args = getRechargeTransactions_args()
9325 
    args.read(iprot)
9326 
    iprot.readMessageEnd()
9327 
    result = getRechargeTransactions_result()
9328 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9329 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9330 
    result.write(oprot)
9331 
    oprot.writeMessageEnd()
9332 
    oprot.trans.flush()
9333 
 
7151 amit.gupta 9334 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9335 
    args = getRechargeTrans_args()
9336 
    args.read(iprot)
9337 
    iprot.readMessageEnd()
9338 
    result = getRechargeTrans_result()
9339 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9340 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9341 
    result.write(oprot)
9342 
    oprot.writeMessageEnd()
9343 
    oprot.trans.flush()
9344 
 
7080 anupam.sin 9345 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9346 
    args = getRechargeTransaction_args()
9347 
    args.read(iprot)
9348 
    iprot.readMessageEnd()
9349 
    result = getRechargeTransaction_result()
9350 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9351 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9352 
    result.write(oprot)
9353 
    oprot.writeMessageEnd()
9354 
    oprot.trans.flush()
7073 anupam.sin 9355 
 
7080 anupam.sin 9356 
  def process_getFRCs(self, seqid, iprot, oprot):
9357 
    args = getFRCs_args()
9358 
    args.read(iprot)
9359 
    iprot.readMessageEnd()
9360 
    result = getFRCs_result()
9361 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9362 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9363 
    result.write(oprot)
9364 
    oprot.writeMessageEnd()
9365 
    oprot.trans.flush()
9366 
 
7096 anupam.sin 9367 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9368 
    args = getHotspotStore_args()
9369 
    args.read(iprot)
9370 
    iprot.readMessageEnd()
9371 
    result = getHotspotStore_result()
9372 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9373 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9374 
    result.write(oprot)
9375 
    oprot.writeMessageEnd()
9376 
    oprot.trans.flush()
7080 anupam.sin 9377 
 
7096 anupam.sin 9378 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9379 
    args = getTelecomCircle_args()
9380 
    args.read(iprot)
9381 
    iprot.readMessageEnd()
9382 
    result = getTelecomCircle_result()
9383 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9384 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9385 
    result.write(oprot)
9386 
    oprot.writeMessageEnd()
9387 
    oprot.trans.flush()
9388 
 
7109 anupam.sin 9389 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9390 
    args = retrieveHotspotRechargeInvoice_args()
9391 
    args.read(iprot)
9392 
    iprot.readMessageEnd()
9393 
    result = retrieveHotspotRechargeInvoice_result()
9394 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9395 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9396 
    result.write(oprot)
9397 
    oprot.writeMessageEnd()
9398 
    oprot.trans.flush()
7096 anupam.sin 9399 
 
7169 anupam.sin 9400 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9401 
    args = getRechargeTransactionsByNumber_args()
9402 
    args.read(iprot)
9403 
    iprot.readMessageEnd()
9404 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9405 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9406 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9407 
    result.write(oprot)
9408 
    oprot.writeMessageEnd()
9409 
    oprot.trans.flush()
7109 anupam.sin 9410 
 
7169 anupam.sin 9411 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9412 
    args = updateHotspotStorePassword_args()
9413 
    args.read(iprot)
9414 
    iprot.readMessageEnd()
9415 
    result = updateHotspotStorePassword_result()
9416 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9417 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9418 
    result.write(oprot)
9419 
    oprot.writeMessageEnd()
9420 
    oprot.trans.flush()
9421 
 
9422 
 
94 ashish 9423 
# HELPER FUNCTIONS AND STRUCTURES
9424 
 
9425 
class createTransaction_args:
9426 
  """
9427 
  Attributes:
9428 
   - transaction
9429 
  """
9430 
 
9431 
  thrift_spec = (
9432 
    None, # 0
9433 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9434 
  )
9435 
 
9436 
  def __init__(self, transaction=None,):
9437 
    self.transaction = transaction
9438 
 
9439 
  def read(self, iprot):
9440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9442 
      return
9443 
    iprot.readStructBegin()
9444 
    while True:
9445 
      (fname, ftype, fid) = iprot.readFieldBegin()
9446 
      if ftype == TType.STOP:
9447 
        break
9448 
      if fid == 1:
9449 
        if ftype == TType.STRUCT:
9450 
          self.transaction = Transaction()
9451 
          self.transaction.read(iprot)
9452 
        else:
9453 
          iprot.skip(ftype)
9454 
      else:
9455 
        iprot.skip(ftype)
9456 
      iprot.readFieldEnd()
9457 
    iprot.readStructEnd()
9458 
 
9459 
  def write(self, oprot):
9460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9462 
      return
9463 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9464 
    if self.transaction is not None:
94 ashish 9465 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9466 
      self.transaction.write(oprot)
9467 
      oprot.writeFieldEnd()
9468 
    oprot.writeFieldStop()
9469 
    oprot.writeStructEnd()
9470 
 
3431 rajveer 9471 
  def validate(self):
9472 
    return
9473 
 
9474 
 
94 ashish 9475 
  def __repr__(self):
9476 
    L = ['%s=%r' % (key, value)
9477 
      for key, value in self.__dict__.iteritems()]
9478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9479 
 
9480 
  def __eq__(self, other):
9481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9482 
 
9483 
  def __ne__(self, other):
9484 
    return not (self == other)
9485 
 
9486 
class createTransaction_result:
9487 
  """
9488 
  Attributes:
132 ashish 9489 
   - success
94 ashish 9490 
   - ex
9491 
  """
9492 
 
9493 
  thrift_spec = (
132 ashish 9494 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9496 
  )
9497 
 
132 ashish 9498 
  def __init__(self, success=None, ex=None,):
9499 
    self.success = success
94 ashish 9500 
    self.ex = ex
9501 
 
9502 
  def read(self, iprot):
9503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9505 
      return
9506 
    iprot.readStructBegin()
9507 
    while True:
9508 
      (fname, ftype, fid) = iprot.readFieldBegin()
9509 
      if ftype == TType.STOP:
9510 
        break
132 ashish 9511 
      if fid == 0:
9512 
        if ftype == TType.I64:
9513 
          self.success = iprot.readI64();
9514 
        else:
9515 
          iprot.skip(ftype)
9516 
      elif fid == 1:
94 ashish 9517 
        if ftype == TType.STRUCT:
9518 
          self.ex = TransactionServiceException()
9519 
          self.ex.read(iprot)
9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      else:
9523 
        iprot.skip(ftype)
9524 
      iprot.readFieldEnd()
9525 
    iprot.readStructEnd()
9526 
 
9527 
  def write(self, oprot):
9528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9530 
      return
9531 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9532 
    if self.success is not None:
132 ashish 9533 
      oprot.writeFieldBegin('success', TType.I64, 0)
9534 
      oprot.writeI64(self.success)
9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.ex is not None:
94 ashish 9537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9538 
      self.ex.write(oprot)
9539 
      oprot.writeFieldEnd()
9540 
    oprot.writeFieldStop()
9541 
    oprot.writeStructEnd()
9542 
 
3431 rajveer 9543 
  def validate(self):
9544 
    return
9545 
 
9546 
 
94 ashish 9547 
  def __repr__(self):
9548 
    L = ['%s=%r' % (key, value)
9549 
      for key, value in self.__dict__.iteritems()]
9550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9551 
 
9552 
  def __eq__(self, other):
9553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9554 
 
9555 
  def __ne__(self, other):
9556 
    return not (self == other)
9557 
 
9558 
class getTransaction_args:
9559 
  """
9560 
  Attributes:
9561 
   - id
9562 
  """
9563 
 
9564 
  thrift_spec = (
9565 
    None, # 0
9566 
    (1, TType.I64, 'id', None, None, ), # 1
9567 
  )
9568 
 
9569 
  def __init__(self, id=None,):
9570 
    self.id = id
9571 
 
9572 
  def read(self, iprot):
9573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9575 
      return
9576 
    iprot.readStructBegin()
9577 
    while True:
9578 
      (fname, ftype, fid) = iprot.readFieldBegin()
9579 
      if ftype == TType.STOP:
9580 
        break
9581 
      if fid == 1:
9582 
        if ftype == TType.I64:
9583 
          self.id = iprot.readI64();
9584 
        else:
9585 
          iprot.skip(ftype)
9586 
      else:
9587 
        iprot.skip(ftype)
9588 
      iprot.readFieldEnd()
9589 
    iprot.readStructEnd()
9590 
 
9591 
  def write(self, oprot):
9592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9594 
      return
9595 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9596 
    if self.id is not None:
94 ashish 9597 
      oprot.writeFieldBegin('id', TType.I64, 1)
9598 
      oprot.writeI64(self.id)
9599 
      oprot.writeFieldEnd()
9600 
    oprot.writeFieldStop()
9601 
    oprot.writeStructEnd()
9602 
 
3431 rajveer 9603 
  def validate(self):
9604 
    return
9605 
 
9606 
 
94 ashish 9607 
  def __repr__(self):
9608 
    L = ['%s=%r' % (key, value)
9609 
      for key, value in self.__dict__.iteritems()]
9610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9611 
 
9612 
  def __eq__(self, other):
9613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9614 
 
9615 
  def __ne__(self, other):
9616 
    return not (self == other)
9617 
 
9618 
class getTransaction_result:
9619 
  """
9620 
  Attributes:
9621 
   - success
9622 
   - ex
9623 
  """
9624 
 
9625 
  thrift_spec = (
9626 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9628 
  )
9629 
 
9630 
  def __init__(self, success=None, ex=None,):
9631 
    self.success = success
9632 
    self.ex = ex
9633 
 
9634 
  def read(self, iprot):
9635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9637 
      return
9638 
    iprot.readStructBegin()
9639 
    while True:
9640 
      (fname, ftype, fid) = iprot.readFieldBegin()
9641 
      if ftype == TType.STOP:
9642 
        break
9643 
      if fid == 0:
9644 
        if ftype == TType.STRUCT:
9645 
          self.success = Transaction()
9646 
          self.success.read(iprot)
9647 
        else:
9648 
          iprot.skip(ftype)
9649 
      elif fid == 1:
9650 
        if ftype == TType.STRUCT:
9651 
          self.ex = TransactionServiceException()
9652 
          self.ex.read(iprot)
9653 
        else:
9654 
          iprot.skip(ftype)
9655 
      else:
9656 
        iprot.skip(ftype)
9657 
      iprot.readFieldEnd()
9658 
    iprot.readStructEnd()
9659 
 
9660 
  def write(self, oprot):
9661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9663 
      return
9664 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9665 
    if self.success is not None:
94 ashish 9666 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9667 
      self.success.write(oprot)
9668 
      oprot.writeFieldEnd()
3431 rajveer 9669 
    if self.ex is not None:
94 ashish 9670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9671 
      self.ex.write(oprot)
9672 
      oprot.writeFieldEnd()
9673 
    oprot.writeFieldStop()
9674 
    oprot.writeStructEnd()
9675 
 
3431 rajveer 9676 
  def validate(self):
9677 
    return
9678 
 
9679 
 
94 ashish 9680 
  def __repr__(self):
9681 
    L = ['%s=%r' % (key, value)
9682 
      for key, value in self.__dict__.iteritems()]
9683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9684 
 
9685 
  def __eq__(self, other):
9686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9687 
 
9688 
  def __ne__(self, other):
9689 
    return not (self == other)
9690 
 
9691 
class getTransactionsForCustomer_args:
9692 
  """
9693 
  Attributes:
9694 
   - customerId
9695 
   - from_date
9696 
   - to_date
9697 
   - status
9698 
  """
9699 
 
9700 
  thrift_spec = (
9701 
    None, # 0
9702 
    (1, TType.I64, 'customerId', None, None, ), # 1
9703 
    (2, TType.I64, 'from_date', None, None, ), # 2
9704 
    (3, TType.I64, 'to_date', None, None, ), # 3
9705 
    (4, TType.I32, 'status', None, None, ), # 4
9706 
  )
9707 
 
9708 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9709 
    self.customerId = customerId
9710 
    self.from_date = from_date
9711 
    self.to_date = to_date
9712 
    self.status = status
9713 
 
9714 
  def read(self, iprot):
9715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9717 
      return
9718 
    iprot.readStructBegin()
9719 
    while True:
9720 
      (fname, ftype, fid) = iprot.readFieldBegin()
9721 
      if ftype == TType.STOP:
9722 
        break
9723 
      if fid == 1:
9724 
        if ftype == TType.I64:
9725 
          self.customerId = iprot.readI64();
9726 
        else:
9727 
          iprot.skip(ftype)
9728 
      elif fid == 2:
9729 
        if ftype == TType.I64:
9730 
          self.from_date = iprot.readI64();
9731 
        else:
9732 
          iprot.skip(ftype)
9733 
      elif fid == 3:
9734 
        if ftype == TType.I64:
9735 
          self.to_date = iprot.readI64();
9736 
        else:
9737 
          iprot.skip(ftype)
9738 
      elif fid == 4:
9739 
        if ftype == TType.I32:
9740 
          self.status = iprot.readI32();
9741 
        else:
9742 
          iprot.skip(ftype)
9743 
      else:
9744 
        iprot.skip(ftype)
9745 
      iprot.readFieldEnd()
9746 
    iprot.readStructEnd()
9747 
 
9748 
  def write(self, oprot):
9749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9751 
      return
9752 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9753 
    if self.customerId is not None:
94 ashish 9754 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9755 
      oprot.writeI64(self.customerId)
9756 
      oprot.writeFieldEnd()
3431 rajveer 9757 
    if self.from_date is not None:
94 ashish 9758 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9759 
      oprot.writeI64(self.from_date)
9760 
      oprot.writeFieldEnd()
3431 rajveer 9761 
    if self.to_date is not None:
94 ashish 9762 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9763 
      oprot.writeI64(self.to_date)
9764 
      oprot.writeFieldEnd()
3431 rajveer 9765 
    if self.status is not None:
94 ashish 9766 
      oprot.writeFieldBegin('status', TType.I32, 4)
9767 
      oprot.writeI32(self.status)
9768 
      oprot.writeFieldEnd()
9769 
    oprot.writeFieldStop()
9770 
    oprot.writeStructEnd()
9771 
 
3431 rajveer 9772 
  def validate(self):
9773 
    return
9774 
 
9775 
 
94 ashish 9776 
  def __repr__(self):
9777 
    L = ['%s=%r' % (key, value)
9778 
      for key, value in self.__dict__.iteritems()]
9779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9780 
 
9781 
  def __eq__(self, other):
9782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9783 
 
9784 
  def __ne__(self, other):
9785 
    return not (self == other)
9786 
 
9787 
class getTransactionsForCustomer_result:
9788 
  """
9789 
  Attributes:
9790 
   - success
9791 
   - ex
9792 
  """
9793 
 
9794 
  thrift_spec = (
9795 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9797 
  )
9798 
 
9799 
  def __init__(self, success=None, ex=None,):
9800 
    self.success = success
9801 
    self.ex = ex
9802 
 
9803 
  def read(self, iprot):
9804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9806 
      return
9807 
    iprot.readStructBegin()
9808 
    while True:
9809 
      (fname, ftype, fid) = iprot.readFieldBegin()
9810 
      if ftype == TType.STOP:
9811 
        break
9812 
      if fid == 0:
9813 
        if ftype == TType.LIST:
9814 
          self.success = []
6188 rajveer 9815 
          (_etype109, _size106) = iprot.readListBegin()
9816 
          for _i110 in xrange(_size106):
9817 
            _elem111 = Transaction()
9818 
            _elem111.read(iprot)
9819 
            self.success.append(_elem111)
94 ashish 9820 
          iprot.readListEnd()
9821 
        else:
9822 
          iprot.skip(ftype)
9823 
      elif fid == 1:
9824 
        if ftype == TType.STRUCT:
9825 
          self.ex = TransactionServiceException()
9826 
          self.ex.read(iprot)
9827 
        else:
9828 
          iprot.skip(ftype)
9829 
      else:
9830 
        iprot.skip(ftype)
9831 
      iprot.readFieldEnd()
9832 
    iprot.readStructEnd()
9833 
 
9834 
  def write(self, oprot):
9835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9837 
      return
9838 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9839 
    if self.success is not None:
94 ashish 9840 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9841 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9842 
      for iter112 in self.success:
9843 
        iter112.write(oprot)
94 ashish 9844 
      oprot.writeListEnd()
9845 
      oprot.writeFieldEnd()
3431 rajveer 9846 
    if self.ex is not None:
94 ashish 9847 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9848 
      self.ex.write(oprot)
9849 
      oprot.writeFieldEnd()
9850 
    oprot.writeFieldStop()
9851 
    oprot.writeStructEnd()
9852 
 
3431 rajveer 9853 
  def validate(self):
9854 
    return
9855 
 
9856 
 
94 ashish 9857 
  def __repr__(self):
9858 
    L = ['%s=%r' % (key, value)
9859 
      for key, value in self.__dict__.iteritems()]
9860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9861 
 
9862 
  def __eq__(self, other):
9863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9864 
 
9865 
  def __ne__(self, other):
9866 
    return not (self == other)
9867 
 
132 ashish 9868 
class getTransactionsForShoppingCartId_args:
9869 
  """
9870 
  Attributes:
9871 
   - shoppingCartId
9872 
  """
9873 
 
9874 
  thrift_spec = (
9875 
    None, # 0
9876 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9877 
  )
9878 
 
9879 
  def __init__(self, shoppingCartId=None,):
9880 
    self.shoppingCartId = shoppingCartId
9881 
 
9882 
  def read(self, iprot):
9883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9885 
      return
9886 
    iprot.readStructBegin()
9887 
    while True:
9888 
      (fname, ftype, fid) = iprot.readFieldBegin()
9889 
      if ftype == TType.STOP:
9890 
        break
9891 
      if fid == 1:
9892 
        if ftype == TType.I64:
9893 
          self.shoppingCartId = iprot.readI64();
9894 
        else:
9895 
          iprot.skip(ftype)
9896 
      else:
9897 
        iprot.skip(ftype)
9898 
      iprot.readFieldEnd()
9899 
    iprot.readStructEnd()
9900 
 
9901 
  def write(self, oprot):
9902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9904 
      return
9905 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9906 
    if self.shoppingCartId is not None:
132 ashish 9907 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9908 
      oprot.writeI64(self.shoppingCartId)
9909 
      oprot.writeFieldEnd()
9910 
    oprot.writeFieldStop()
9911 
    oprot.writeStructEnd()
9912 
 
3431 rajveer 9913 
  def validate(self):
9914 
    return
9915 
 
9916 
 
132 ashish 9917 
  def __repr__(self):
9918 
    L = ['%s=%r' % (key, value)
9919 
      for key, value in self.__dict__.iteritems()]
9920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9921 
 
9922 
  def __eq__(self, other):
9923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9924 
 
9925 
  def __ne__(self, other):
9926 
    return not (self == other)
9927 
 
9928 
class getTransactionsForShoppingCartId_result:
9929 
  """
9930 
  Attributes:
9931 
   - success
9932 
   - ex
9933 
  """
9934 
 
9935 
  thrift_spec = (
9936 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9938 
  )
9939 
 
9940 
  def __init__(self, success=None, ex=None,):
9941 
    self.success = success
9942 
    self.ex = ex
9943 
 
9944 
  def read(self, iprot):
9945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9947 
      return
9948 
    iprot.readStructBegin()
9949 
    while True:
9950 
      (fname, ftype, fid) = iprot.readFieldBegin()
9951 
      if ftype == TType.STOP:
9952 
        break
9953 
      if fid == 0:
9954 
        if ftype == TType.LIST:
9955 
          self.success = []
6188 rajveer 9956 
          (_etype116, _size113) = iprot.readListBegin()
9957 
          for _i117 in xrange(_size113):
9958 
            _elem118 = Transaction()
9959 
            _elem118.read(iprot)
9960 
            self.success.append(_elem118)
132 ashish 9961 
          iprot.readListEnd()
9962 
        else:
9963 
          iprot.skip(ftype)
9964 
      elif fid == 1:
9965 
        if ftype == TType.STRUCT:
9966 
          self.ex = TransactionServiceException()
9967 
          self.ex.read(iprot)
9968 
        else:
9969 
          iprot.skip(ftype)
9970 
      else:
9971 
        iprot.skip(ftype)
9972 
      iprot.readFieldEnd()
9973 
    iprot.readStructEnd()
9974 
 
9975 
  def write(self, oprot):
9976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9978 
      return
9979 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9980 
    if self.success is not None:
132 ashish 9981 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9982 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9983 
      for iter119 in self.success:
9984 
        iter119.write(oprot)
132 ashish 9985 
      oprot.writeListEnd()
9986 
      oprot.writeFieldEnd()
3431 rajveer 9987 
    if self.ex is not None:
132 ashish 9988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9989 
      self.ex.write(oprot)
9990 
      oprot.writeFieldEnd()
9991 
    oprot.writeFieldStop()
9992 
    oprot.writeStructEnd()
9993 
 
3431 rajveer 9994 
  def validate(self):
9995 
    return
9996 
 
9997 
 
132 ashish 9998 
  def __repr__(self):
9999 
    L = ['%s=%r' % (key, value)
10000 
      for key, value in self.__dict__.iteritems()]
10001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10002 
 
10003 
  def __eq__(self, other):
10004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10005 
 
10006 
  def __ne__(self, other):
10007 
    return not (self == other)
10008 
 
94 ashish 10009 
class getTransactionStatus_args:
10010 
  """
10011 
  Attributes:
10012 
   - transactionId
10013 
  """
10014 
 
10015 
  thrift_spec = (
10016 
    None, # 0
10017 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10018 
  )
10019 
 
10020 
  def __init__(self, transactionId=None,):
10021 
    self.transactionId = transactionId
10022 
 
10023 
  def read(self, iprot):
10024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10026 
      return
10027 
    iprot.readStructBegin()
10028 
    while True:
10029 
      (fname, ftype, fid) = iprot.readFieldBegin()
10030 
      if ftype == TType.STOP:
10031 
        break
10032 
      if fid == 1:
10033 
        if ftype == TType.I64:
10034 
          self.transactionId = iprot.readI64();
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      else:
10038 
        iprot.skip(ftype)
10039 
      iprot.readFieldEnd()
10040 
    iprot.readStructEnd()
10041 
 
10042 
  def write(self, oprot):
10043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10045 
      return
10046 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10047 
    if self.transactionId is not None:
94 ashish 10048 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10049 
      oprot.writeI64(self.transactionId)
10050 
      oprot.writeFieldEnd()
10051 
    oprot.writeFieldStop()
10052 
    oprot.writeStructEnd()
10053 
 
3431 rajveer 10054 
  def validate(self):
10055 
    return
10056 
 
10057 
 
94 ashish 10058 
  def __repr__(self):
10059 
    L = ['%s=%r' % (key, value)
10060 
      for key, value in self.__dict__.iteritems()]
10061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10062 
 
10063 
  def __eq__(self, other):
10064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10065 
 
10066 
  def __ne__(self, other):
10067 
    return not (self == other)
10068 
 
10069 
class getTransactionStatus_result:
10070 
  """
10071 
  Attributes:
10072 
   - success
10073 
   - ex
10074 
  """
10075 
 
10076 
  thrift_spec = (
10077 
    (0, TType.I32, 'success', None, None, ), # 0
10078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10079 
  )
10080 
 
10081 
  def __init__(self, success=None, ex=None,):
10082 
    self.success = success
10083 
    self.ex = ex
10084 
 
10085 
  def read(self, iprot):
10086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10088 
      return
10089 
    iprot.readStructBegin()
10090 
    while True:
10091 
      (fname, ftype, fid) = iprot.readFieldBegin()
10092 
      if ftype == TType.STOP:
10093 
        break
10094 
      if fid == 0:
10095 
        if ftype == TType.I32:
10096 
          self.success = iprot.readI32();
10097 
        else:
10098 
          iprot.skip(ftype)
10099 
      elif fid == 1:
10100 
        if ftype == TType.STRUCT:
10101 
          self.ex = TransactionServiceException()
10102 
          self.ex.read(iprot)
10103 
        else:
10104 
          iprot.skip(ftype)
10105 
      else:
10106 
        iprot.skip(ftype)
10107 
      iprot.readFieldEnd()
10108 
    iprot.readStructEnd()
10109 
 
10110 
  def write(self, oprot):
10111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10113 
      return
10114 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10115 
    if self.success is not None:
94 ashish 10116 
      oprot.writeFieldBegin('success', TType.I32, 0)
10117 
      oprot.writeI32(self.success)
10118 
      oprot.writeFieldEnd()
3431 rajveer 10119 
    if self.ex is not None:
94 ashish 10120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10121 
      self.ex.write(oprot)
10122 
      oprot.writeFieldEnd()
10123 
    oprot.writeFieldStop()
10124 
    oprot.writeStructEnd()
10125 
 
3431 rajveer 10126 
  def validate(self):
10127 
    return
10128 
 
10129 
 
94 ashish 10130 
  def __repr__(self):
10131 
    L = ['%s=%r' % (key, value)
10132 
      for key, value in self.__dict__.iteritems()]
10133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10134 
 
10135 
  def __eq__(self, other):
10136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10137 
 
10138 
  def __ne__(self, other):
10139 
    return not (self == other)
10140 
 
10141 
class changeTransactionStatus_args:
10142 
  """
10143 
  Attributes:
10144 
   - transactionId
10145 
   - status
10146 
   - description
5527 anupam.sin 10147 
   - pickUp
10148 
   - orderType
94 ashish 10149 
  """
10150 
 
10151 
  thrift_spec = (
10152 
    None, # 0
10153 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10154 
    (2, TType.I32, 'status', None, None, ), # 2
10155 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10156 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10157 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 10158 
  )
10159 
 
5527 anupam.sin 10160 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 10161 
    self.transactionId = transactionId
10162 
    self.status = status
10163 
    self.description = description
5527 anupam.sin 10164 
    self.pickUp = pickUp
10165 
    self.orderType = orderType
94 ashish 10166 
 
10167 
  def read(self, iprot):
10168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10170 
      return
10171 
    iprot.readStructBegin()
10172 
    while True:
10173 
      (fname, ftype, fid) = iprot.readFieldBegin()
10174 
      if ftype == TType.STOP:
10175 
        break
10176 
      if fid == 1:
10177 
        if ftype == TType.I64:
10178 
          self.transactionId = iprot.readI64();
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      elif fid == 2:
10182 
        if ftype == TType.I32:
10183 
          self.status = iprot.readI32();
10184 
        else:
10185 
          iprot.skip(ftype)
10186 
      elif fid == 3:
10187 
        if ftype == TType.STRING:
10188 
          self.description = iprot.readString();
10189 
        else:
10190 
          iprot.skip(ftype)
5387 rajveer 10191 
      elif fid == 4:
5527 anupam.sin 10192 
        if ftype == TType.I64:
10193 
          self.pickUp = iprot.readI64();
5387 rajveer 10194 
        else:
10195 
          iprot.skip(ftype)
5527 anupam.sin 10196 
      elif fid == 5:
10197 
        if ftype == TType.I32:
10198 
          self.orderType = iprot.readI32();
10199 
        else:
10200 
          iprot.skip(ftype)
94 ashish 10201 
      else:
10202 
        iprot.skip(ftype)
10203 
      iprot.readFieldEnd()
10204 
    iprot.readStructEnd()
10205 
 
10206 
  def write(self, oprot):
10207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10209 
      return
10210 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10211 
    if self.transactionId is not None:
94 ashish 10212 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10213 
      oprot.writeI64(self.transactionId)
10214 
      oprot.writeFieldEnd()
3431 rajveer 10215 
    if self.status is not None:
94 ashish 10216 
      oprot.writeFieldBegin('status', TType.I32, 2)
10217 
      oprot.writeI32(self.status)
10218 
      oprot.writeFieldEnd()
3431 rajveer 10219 
    if self.description is not None:
94 ashish 10220 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10221 
      oprot.writeString(self.description)
10222 
      oprot.writeFieldEnd()
5527 anupam.sin 10223 
    if self.pickUp is not None:
10224 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10225 
      oprot.writeI64(self.pickUp)
5387 rajveer 10226 
      oprot.writeFieldEnd()
5527 anupam.sin 10227 
    if self.orderType is not None:
10228 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10229 
      oprot.writeI32(self.orderType)
10230 
      oprot.writeFieldEnd()
94 ashish 10231 
    oprot.writeFieldStop()
10232 
    oprot.writeStructEnd()
10233 
 
3431 rajveer 10234 
  def validate(self):
10235 
    return
10236 
 
10237 
 
94 ashish 10238 
  def __repr__(self):
10239 
    L = ['%s=%r' % (key, value)
10240 
      for key, value in self.__dict__.iteritems()]
10241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10242 
 
10243 
  def __eq__(self, other):
10244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10245 
 
10246 
  def __ne__(self, other):
10247 
    return not (self == other)
10248 
 
10249 
class changeTransactionStatus_result:
10250 
  """
10251 
  Attributes:
10252 
   - success
10253 
   - ex
10254 
  """
10255 
 
10256 
  thrift_spec = (
10257 
    (0, TType.BOOL, 'success', None, None, ), # 0
10258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10259 
  )
10260 
 
10261 
  def __init__(self, success=None, ex=None,):
10262 
    self.success = success
10263 
    self.ex = ex
10264 
 
10265 
  def read(self, iprot):
10266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10268 
      return
10269 
    iprot.readStructBegin()
10270 
    while True:
10271 
      (fname, ftype, fid) = iprot.readFieldBegin()
10272 
      if ftype == TType.STOP:
10273 
        break
10274 
      if fid == 0:
10275 
        if ftype == TType.BOOL:
10276 
          self.success = iprot.readBool();
10277 
        else:
10278 
          iprot.skip(ftype)
10279 
      elif fid == 1:
10280 
        if ftype == TType.STRUCT:
10281 
          self.ex = TransactionServiceException()
10282 
          self.ex.read(iprot)
10283 
        else:
10284 
          iprot.skip(ftype)
10285 
      else:
10286 
        iprot.skip(ftype)
10287 
      iprot.readFieldEnd()
10288 
    iprot.readStructEnd()
10289 
 
10290 
  def write(self, oprot):
10291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10293 
      return
10294 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10295 
    if self.success is not None:
94 ashish 10296 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10297 
      oprot.writeBool(self.success)
10298 
      oprot.writeFieldEnd()
3431 rajveer 10299 
    if self.ex is not None:
94 ashish 10300 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10301 
      self.ex.write(oprot)
10302 
      oprot.writeFieldEnd()
10303 
    oprot.writeFieldStop()
10304 
    oprot.writeStructEnd()
10305 
 
3431 rajveer 10306 
  def validate(self):
10307 
    return
10308 
 
10309 
 
94 ashish 10310 
  def __repr__(self):
10311 
    L = ['%s=%r' % (key, value)
10312 
      for key, value in self.__dict__.iteritems()]
10313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10314 
 
10315 
  def __eq__(self, other):
10316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10317 
 
10318 
  def __ne__(self, other):
10319 
    return not (self == other)
10320 
 
1398 varun.gupt 10321 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10322 
  """
10323 
  Attributes:
10324 
   - transactionId
10325 
  """
10326 
 
10327 
  thrift_spec = (
10328 
    None, # 0
10329 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10330 
  )
10331 
 
10332 
  def __init__(self, transactionId=None,):
10333 
    self.transactionId = transactionId
10334 
 
10335 
  def read(self, iprot):
10336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10338 
      return
10339 
    iprot.readStructBegin()
10340 
    while True:
10341 
      (fname, ftype, fid) = iprot.readFieldBegin()
10342 
      if ftype == TType.STOP:
10343 
        break
10344 
      if fid == 1:
10345 
        if ftype == TType.I64:
10346 
          self.transactionId = iprot.readI64();
10347 
        else:
10348 
          iprot.skip(ftype)
10349 
      else:
10350 
        iprot.skip(ftype)
10351 
      iprot.readFieldEnd()
10352 
    iprot.readStructEnd()
10353 
 
10354 
  def write(self, oprot):
10355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10357 
      return
1398 varun.gupt 10358 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10359 
    if self.transactionId is not None:
1382 varun.gupt 10360 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10361 
      oprot.writeI64(self.transactionId)
10362 
      oprot.writeFieldEnd()
10363 
    oprot.writeFieldStop()
10364 
    oprot.writeStructEnd()
10365 
 
3431 rajveer 10366 
  def validate(self):
10367 
    return
10368 
 
10369 
 
1382 varun.gupt 10370 
  def __repr__(self):
10371 
    L = ['%s=%r' % (key, value)
10372 
      for key, value in self.__dict__.iteritems()]
10373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10374 
 
10375 
  def __eq__(self, other):
10376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10377 
 
10378 
  def __ne__(self, other):
10379 
    return not (self == other)
10380 
 
1398 varun.gupt 10381 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10382 
  """
10383 
  Attributes:
10384 
   - success
10385 
   - ex
10386 
  """
10387 
 
10388 
  thrift_spec = (
10389 
    (0, TType.BOOL, 'success', None, None, ), # 0
10390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10391 
  )
10392 
 
10393 
  def __init__(self, success=None, ex=None,):
10394 
    self.success = success
10395 
    self.ex = ex
10396 
 
10397 
  def read(self, iprot):
10398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10400 
      return
10401 
    iprot.readStructBegin()
10402 
    while True:
10403 
      (fname, ftype, fid) = iprot.readFieldBegin()
10404 
      if ftype == TType.STOP:
10405 
        break
10406 
      if fid == 0:
10407 
        if ftype == TType.BOOL:
10408 
          self.success = iprot.readBool();
10409 
        else:
10410 
          iprot.skip(ftype)
10411 
      elif fid == 1:
10412 
        if ftype == TType.STRUCT:
10413 
          self.ex = TransactionServiceException()
10414 
          self.ex.read(iprot)
10415 
        else:
10416 
          iprot.skip(ftype)
10417 
      else:
10418 
        iprot.skip(ftype)
10419 
      iprot.readFieldEnd()
10420 
    iprot.readStructEnd()
10421 
 
10422 
  def write(self, oprot):
10423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10425 
      return
1398 varun.gupt 10426 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10427 
    if self.success is not None:
1382 varun.gupt 10428 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10429 
      oprot.writeBool(self.success)
10430 
      oprot.writeFieldEnd()
3431 rajveer 10431 
    if self.ex is not None:
1382 varun.gupt 10432 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10433 
      self.ex.write(oprot)
10434 
      oprot.writeFieldEnd()
10435 
    oprot.writeFieldStop()
10436 
    oprot.writeStructEnd()
10437 
 
3431 rajveer 10438 
  def validate(self):
10439 
    return
10440 
 
10441 
 
1382 varun.gupt 10442 
  def __repr__(self):
10443 
    L = ['%s=%r' % (key, value)
10444 
      for key, value in self.__dict__.iteritems()]
10445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10446 
 
10447 
  def __eq__(self, other):
10448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10449 
 
10450 
  def __ne__(self, other):
10451 
    return not (self == other)
10452 
 
483 rajveer 10453 
class getAllOrders_args:
94 ashish 10454 
  """
10455 
  Attributes:
4801 anupam.sin 10456 
   - statuses
483 rajveer 10457 
   - from_date
10458 
   - to_date
10459 
   - warehouse_id
94 ashish 10460 
  """
10461 
 
10462 
  thrift_spec = (
10463 
    None, # 0
4801 anupam.sin 10464 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10465 
    (2, TType.I64, 'from_date', None, None, ), # 2
10466 
    (3, TType.I64, 'to_date', None, None, ), # 3
10467 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10468 
  )
10469 
 
4801 anupam.sin 10470 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10471 
    self.statuses = statuses
483 rajveer 10472 
    self.from_date = from_date
10473 
    self.to_date = to_date
10474 
    self.warehouse_id = warehouse_id
94 ashish 10475 
 
10476 
  def read(self, iprot):
10477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10479 
      return
10480 
    iprot.readStructBegin()
10481 
    while True:
10482 
      (fname, ftype, fid) = iprot.readFieldBegin()
10483 
      if ftype == TType.STOP:
10484 
        break
10485 
      if fid == 1:
4801 anupam.sin 10486 
        if ftype == TType.LIST:
10487 
          self.statuses = []
6188 rajveer 10488 
          (_etype123, _size120) = iprot.readListBegin()
10489 
          for _i124 in xrange(_size120):
10490 
            _elem125 = iprot.readI32();
10491 
            self.statuses.append(_elem125)
4801 anupam.sin 10492 
          iprot.readListEnd()
94 ashish 10493 
        else:
10494 
          iprot.skip(ftype)
483 rajveer 10495 
      elif fid == 2:
10496 
        if ftype == TType.I64:
10497 
          self.from_date = iprot.readI64();
94 ashish 10498 
        else:
10499 
          iprot.skip(ftype)
483 rajveer 10500 
      elif fid == 3:
10501 
        if ftype == TType.I64:
10502 
          self.to_date = iprot.readI64();
94 ashish 10503 
        else:
10504 
          iprot.skip(ftype)
483 rajveer 10505 
      elif fid == 4:
94 ashish 10506 
        if ftype == TType.I64:
483 rajveer 10507 
          self.warehouse_id = iprot.readI64();
94 ashish 10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
483 rajveer 10519 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10520 
    if self.statuses is not None:
10521 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10522 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10523 
      for iter126 in self.statuses:
10524 
        oprot.writeI32(iter126)
4801 anupam.sin 10525 
      oprot.writeListEnd()
94 ashish 10526 
      oprot.writeFieldEnd()
3431 rajveer 10527 
    if self.from_date is not None:
483 rajveer 10528 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10529 
      oprot.writeI64(self.from_date)
94 ashish 10530 
      oprot.writeFieldEnd()
3431 rajveer 10531 
    if self.to_date is not None:
483 rajveer 10532 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10533 
      oprot.writeI64(self.to_date)
94 ashish 10534 
      oprot.writeFieldEnd()
3431 rajveer 10535 
    if self.warehouse_id is not None:
483 rajveer 10536 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10537 
      oprot.writeI64(self.warehouse_id)
94 ashish 10538 
      oprot.writeFieldEnd()
10539 
    oprot.writeFieldStop()
10540 
    oprot.writeStructEnd()
10541 
 
3431 rajveer 10542 
  def validate(self):
10543 
    return
10544 
 
10545 
 
94 ashish 10546 
  def __repr__(self):
10547 
    L = ['%s=%r' % (key, value)
10548 
      for key, value in self.__dict__.iteritems()]
10549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10550 
 
10551 
  def __eq__(self, other):
10552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10553 
 
10554 
  def __ne__(self, other):
10555 
    return not (self == other)
10556 
 
483 rajveer 10557 
class getAllOrders_result:
94 ashish 10558 
  """
10559 
  Attributes:
10560 
   - success
10561 
   - ex
10562 
  """
10563 
 
10564 
  thrift_spec = (
483 rajveer 10565 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10567 
  )
10568 
 
10569 
  def __init__(self, success=None, ex=None,):
10570 
    self.success = success
10571 
    self.ex = ex
10572 
 
10573 
  def read(self, iprot):
10574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10576 
      return
10577 
    iprot.readStructBegin()
10578 
    while True:
10579 
      (fname, ftype, fid) = iprot.readFieldBegin()
10580 
      if ftype == TType.STOP:
10581 
        break
10582 
      if fid == 0:
483 rajveer 10583 
        if ftype == TType.LIST:
10584 
          self.success = []
6188 rajveer 10585 
          (_etype130, _size127) = iprot.readListBegin()
10586 
          for _i131 in xrange(_size127):
10587 
            _elem132 = Order()
10588 
            _elem132.read(iprot)
10589 
            self.success.append(_elem132)
483 rajveer 10590 
          iprot.readListEnd()
94 ashish 10591 
        else:
10592 
          iprot.skip(ftype)
10593 
      elif fid == 1:
10594 
        if ftype == TType.STRUCT:
10595 
          self.ex = TransactionServiceException()
10596 
          self.ex.read(iprot)
10597 
        else:
10598 
          iprot.skip(ftype)
10599 
      else:
10600 
        iprot.skip(ftype)
10601 
      iprot.readFieldEnd()
10602 
    iprot.readStructEnd()
10603 
 
10604 
  def write(self, oprot):
10605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10607 
      return
483 rajveer 10608 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10609 
    if self.success is not None:
483 rajveer 10610 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10611 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10612 
      for iter133 in self.success:
10613 
        iter133.write(oprot)
483 rajveer 10614 
      oprot.writeListEnd()
94 ashish 10615 
      oprot.writeFieldEnd()
3431 rajveer 10616 
    if self.ex is not None:
94 ashish 10617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10618 
      self.ex.write(oprot)
10619 
      oprot.writeFieldEnd()
10620 
    oprot.writeFieldStop()
10621 
    oprot.writeStructEnd()
10622 
 
3431 rajveer 10623 
  def validate(self):
10624 
    return
10625 
 
10626 
 
94 ashish 10627 
  def __repr__(self):
10628 
    L = ['%s=%r' % (key, value)
10629 
      for key, value in self.__dict__.iteritems()]
10630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10631 
 
10632 
  def __eq__(self, other):
10633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10634 
 
10635 
  def __ne__(self, other):
10636 
    return not (self == other)
10637 
 
4133 chandransh 10638 
class getOrdersInBatch_args:
10639 
  """
10640 
  Attributes:
10641 
   - statuses
10642 
   - offset
10643 
   - limit
10644 
   - warehouse_id
10645 
  """
10646 
 
10647 
  thrift_spec = (
10648 
    None, # 0
10649 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10650 
    (2, TType.I64, 'offset', None, None, ), # 2
10651 
    (3, TType.I64, 'limit', None, None, ), # 3
10652 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10653 
  )
10654 
 
10655 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10656 
    self.statuses = statuses
10657 
    self.offset = offset
10658 
    self.limit = limit
10659 
    self.warehouse_id = warehouse_id
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 1:
10671 
        if ftype == TType.LIST:
10672 
          self.statuses = []
6188 rajveer 10673 
          (_etype137, _size134) = iprot.readListBegin()
10674 
          for _i138 in xrange(_size134):
10675 
            _elem139 = iprot.readI32();
10676 
            self.statuses.append(_elem139)
4133 chandransh 10677 
          iprot.readListEnd()
10678 
        else:
10679 
          iprot.skip(ftype)
10680 
      elif fid == 2:
10681 
        if ftype == TType.I64:
10682 
          self.offset = iprot.readI64();
10683 
        else:
10684 
          iprot.skip(ftype)
10685 
      elif fid == 3:
10686 
        if ftype == TType.I64:
10687 
          self.limit = iprot.readI64();
10688 
        else:
10689 
          iprot.skip(ftype)
10690 
      elif fid == 4:
10691 
        if ftype == TType.I64:
10692 
          self.warehouse_id = iprot.readI64();
10693 
        else:
10694 
          iprot.skip(ftype)
10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('getOrdersInBatch_args')
10705 
    if self.statuses is not None:
10706 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10707 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10708 
      for iter140 in self.statuses:
10709 
        oprot.writeI32(iter140)
4133 chandransh 10710 
      oprot.writeListEnd()
10711 
      oprot.writeFieldEnd()
10712 
    if self.offset is not None:
10713 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10714 
      oprot.writeI64(self.offset)
10715 
      oprot.writeFieldEnd()
10716 
    if self.limit is not None:
10717 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10718 
      oprot.writeI64(self.limit)
10719 
      oprot.writeFieldEnd()
10720 
    if self.warehouse_id is not None:
10721 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10722 
      oprot.writeI64(self.warehouse_id)
10723 
      oprot.writeFieldEnd()
10724 
    oprot.writeFieldStop()
10725 
    oprot.writeStructEnd()
10726 
 
10727 
  def validate(self):
10728 
    return
10729 
 
10730 
 
10731 
  def __repr__(self):
10732 
    L = ['%s=%r' % (key, value)
10733 
      for key, value in self.__dict__.iteritems()]
10734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10735 
 
10736 
  def __eq__(self, other):
10737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10738 
 
10739 
  def __ne__(self, other):
10740 
    return not (self == other)
10741 
 
10742 
class getOrdersInBatch_result:
10743 
  """
10744 
  Attributes:
10745 
   - success
10746 
   - ex
10747 
  """
10748 
 
10749 
  thrift_spec = (
10750 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10751 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10752 
  )
10753 
 
10754 
  def __init__(self, success=None, ex=None,):
10755 
    self.success = success
10756 
    self.ex = ex
10757 
 
10758 
  def read(self, iprot):
10759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10761 
      return
10762 
    iprot.readStructBegin()
10763 
    while True:
10764 
      (fname, ftype, fid) = iprot.readFieldBegin()
10765 
      if ftype == TType.STOP:
10766 
        break
10767 
      if fid == 0:
10768 
        if ftype == TType.LIST:
10769 
          self.success = []
6188 rajveer 10770 
          (_etype144, _size141) = iprot.readListBegin()
10771 
          for _i145 in xrange(_size141):
10772 
            _elem146 = Order()
10773 
            _elem146.read(iprot)
10774 
            self.success.append(_elem146)
4133 chandransh 10775 
          iprot.readListEnd()
10776 
        else:
10777 
          iprot.skip(ftype)
10778 
      elif fid == 1:
10779 
        if ftype == TType.STRUCT:
10780 
          self.ex = TransactionServiceException()
10781 
          self.ex.read(iprot)
10782 
        else:
10783 
          iprot.skip(ftype)
10784 
      else:
10785 
        iprot.skip(ftype)
10786 
      iprot.readFieldEnd()
10787 
    iprot.readStructEnd()
10788 
 
10789 
  def write(self, oprot):
10790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10792 
      return
10793 
    oprot.writeStructBegin('getOrdersInBatch_result')
10794 
    if self.success is not None:
10795 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10796 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10797 
      for iter147 in self.success:
10798 
        iter147.write(oprot)
4133 chandransh 10799 
      oprot.writeListEnd()
10800 
      oprot.writeFieldEnd()
10801 
    if self.ex is not None:
10802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10803 
      self.ex.write(oprot)
10804 
      oprot.writeFieldEnd()
10805 
    oprot.writeFieldStop()
10806 
    oprot.writeStructEnd()
10807 
 
10808 
  def validate(self):
10809 
    return
10810 
 
10811 
 
10812 
  def __repr__(self):
10813 
    L = ['%s=%r' % (key, value)
10814 
      for key, value in self.__dict__.iteritems()]
10815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10816 
 
10817 
  def __eq__(self, other):
10818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10819 
 
10820 
  def __ne__(self, other):
10821 
    return not (self == other)
10822 
 
10823 
class getOrderCount_args:
10824 
  """
10825 
  Attributes:
10826 
   - statuses
10827 
   - warehouseId
10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    None, # 0
10832 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10833 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10834 
  )
10835 
 
10836 
  def __init__(self, statuses=None, warehouseId=None,):
10837 
    self.statuses = statuses
10838 
    self.warehouseId = warehouseId
10839 
 
10840 
  def read(self, iprot):
10841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10843 
      return
10844 
    iprot.readStructBegin()
10845 
    while True:
10846 
      (fname, ftype, fid) = iprot.readFieldBegin()
10847 
      if ftype == TType.STOP:
10848 
        break
10849 
      if fid == 1:
10850 
        if ftype == TType.LIST:
10851 
          self.statuses = []
6188 rajveer 10852 
          (_etype151, _size148) = iprot.readListBegin()
10853 
          for _i152 in xrange(_size148):
10854 
            _elem153 = iprot.readI32();
10855 
            self.statuses.append(_elem153)
4133 chandransh 10856 
          iprot.readListEnd()
10857 
        else:
10858 
          iprot.skip(ftype)
10859 
      elif fid == 2:
10860 
        if ftype == TType.I64:
10861 
          self.warehouseId = iprot.readI64();
10862 
        else:
10863 
          iprot.skip(ftype)
10864 
      else:
10865 
        iprot.skip(ftype)
10866 
      iprot.readFieldEnd()
10867 
    iprot.readStructEnd()
10868 
 
10869 
  def write(self, oprot):
10870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10872 
      return
10873 
    oprot.writeStructBegin('getOrderCount_args')
10874 
    if self.statuses is not None:
10875 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10876 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10877 
      for iter154 in self.statuses:
10878 
        oprot.writeI32(iter154)
4133 chandransh 10879 
      oprot.writeListEnd()
10880 
      oprot.writeFieldEnd()
10881 
    if self.warehouseId is not None:
10882 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10883 
      oprot.writeI64(self.warehouseId)
10884 
      oprot.writeFieldEnd()
10885 
    oprot.writeFieldStop()
10886 
    oprot.writeStructEnd()
10887 
 
10888 
  def validate(self):
10889 
    return
10890 
 
10891 
 
10892 
  def __repr__(self):
10893 
    L = ['%s=%r' % (key, value)
10894 
      for key, value in self.__dict__.iteritems()]
10895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10896 
 
10897 
  def __eq__(self, other):
10898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10899 
 
10900 
  def __ne__(self, other):
10901 
    return not (self == other)
10902 
 
10903 
class getOrderCount_result:
10904 
  """
10905 
  Attributes:
10906 
   - success
10907 
   - ex
10908 
  """
10909 
 
10910 
  thrift_spec = (
10911 
    (0, TType.I32, 'success', None, None, ), # 0
10912 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10913 
  )
10914 
 
10915 
  def __init__(self, success=None, ex=None,):
10916 
    self.success = success
10917 
    self.ex = ex
10918 
 
10919 
  def read(self, iprot):
10920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10922 
      return
10923 
    iprot.readStructBegin()
10924 
    while True:
10925 
      (fname, ftype, fid) = iprot.readFieldBegin()
10926 
      if ftype == TType.STOP:
10927 
        break
10928 
      if fid == 0:
10929 
        if ftype == TType.I32:
10930 
          self.success = iprot.readI32();
10931 
        else:
10932 
          iprot.skip(ftype)
10933 
      elif fid == 1:
10934 
        if ftype == TType.STRUCT:
10935 
          self.ex = TransactionServiceException()
10936 
          self.ex.read(iprot)
10937 
        else:
10938 
          iprot.skip(ftype)
10939 
      else:
10940 
        iprot.skip(ftype)
10941 
      iprot.readFieldEnd()
10942 
    iprot.readStructEnd()
10943 
 
10944 
  def write(self, oprot):
10945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10947 
      return
10948 
    oprot.writeStructBegin('getOrderCount_result')
10949 
    if self.success is not None:
10950 
      oprot.writeFieldBegin('success', TType.I32, 0)
10951 
      oprot.writeI32(self.success)
10952 
      oprot.writeFieldEnd()
10953 
    if self.ex is not None:
10954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10955 
      self.ex.write(oprot)
10956 
      oprot.writeFieldEnd()
10957 
    oprot.writeFieldStop()
10958 
    oprot.writeStructEnd()
10959 
 
10960 
  def validate(self):
10961 
    return
10962 
 
10963 
 
10964 
  def __repr__(self):
10965 
    L = ['%s=%r' % (key, value)
10966 
      for key, value in self.__dict__.iteritems()]
10967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10968 
 
10969 
  def __eq__(self, other):
10970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10971 
 
10972 
  def __ne__(self, other):
10973 
    return not (self == other)
10974 
 
999 varun.gupt 10975 
class getOrdersByBillingDate_args:
10976 
  """
10977 
  Attributes:
10978 
   - status
10979 
   - start_billing_date
10980 
   - end_billing_date
10981 
   - warehouse_id
10982 
  """
10983 
 
10984 
  thrift_spec = (
10985 
    None, # 0
10986 
    (1, TType.I32, 'status', None, None, ), # 1
10987 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10988 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10989 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10990 
  )
10991 
 
10992 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10993 
    self.status = status
10994 
    self.start_billing_date = start_billing_date
10995 
    self.end_billing_date = end_billing_date
10996 
    self.warehouse_id = warehouse_id
10997 
 
10998 
  def read(self, iprot):
10999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11001 
      return
11002 
    iprot.readStructBegin()
11003 
    while True:
11004 
      (fname, ftype, fid) = iprot.readFieldBegin()
11005 
      if ftype == TType.STOP:
11006 
        break
11007 
      if fid == 1:
11008 
        if ftype == TType.I32:
11009 
          self.status = iprot.readI32();
11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      elif fid == 2:
11013 
        if ftype == TType.I64:
11014 
          self.start_billing_date = iprot.readI64();
11015 
        else:
11016 
          iprot.skip(ftype)
11017 
      elif fid == 3:
11018 
        if ftype == TType.I64:
11019 
          self.end_billing_date = iprot.readI64();
11020 
        else:
11021 
          iprot.skip(ftype)
11022 
      elif fid == 4:
11023 
        if ftype == TType.I64:
11024 
          self.warehouse_id = iprot.readI64();
11025 
        else:
11026 
          iprot.skip(ftype)
11027 
      else:
11028 
        iprot.skip(ftype)
11029 
      iprot.readFieldEnd()
11030 
    iprot.readStructEnd()
11031 
 
11032 
  def write(self, oprot):
11033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11035 
      return
11036 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11037 
    if self.status is not None:
999 varun.gupt 11038 
      oprot.writeFieldBegin('status', TType.I32, 1)
11039 
      oprot.writeI32(self.status)
11040 
      oprot.writeFieldEnd()
3431 rajveer 11041 
    if self.start_billing_date is not None:
999 varun.gupt 11042 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11043 
      oprot.writeI64(self.start_billing_date)
11044 
      oprot.writeFieldEnd()
3431 rajveer 11045 
    if self.end_billing_date is not None:
999 varun.gupt 11046 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11047 
      oprot.writeI64(self.end_billing_date)
11048 
      oprot.writeFieldEnd()
3431 rajveer 11049 
    if self.warehouse_id is not None:
999 varun.gupt 11050 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11051 
      oprot.writeI64(self.warehouse_id)
11052 
      oprot.writeFieldEnd()
11053 
    oprot.writeFieldStop()
11054 
    oprot.writeStructEnd()
11055 
 
3431 rajveer 11056 
  def validate(self):
11057 
    return
11058 
 
11059 
 
999 varun.gupt 11060 
  def __repr__(self):
11061 
    L = ['%s=%r' % (key, value)
11062 
      for key, value in self.__dict__.iteritems()]
11063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11064 
 
11065 
  def __eq__(self, other):
11066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11067 
 
11068 
  def __ne__(self, other):
11069 
    return not (self == other)
11070 
 
11071 
class getOrdersByBillingDate_result:
11072 
  """
11073 
  Attributes:
11074 
   - success
11075 
   - ex
11076 
  """
11077 
 
11078 
  thrift_spec = (
11079 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11081 
  )
11082 
 
11083 
  def __init__(self, success=None, ex=None,):
11084 
    self.success = success
11085 
    self.ex = ex
11086 
 
11087 
  def read(self, iprot):
11088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11090 
      return
11091 
    iprot.readStructBegin()
11092 
    while True:
11093 
      (fname, ftype, fid) = iprot.readFieldBegin()
11094 
      if ftype == TType.STOP:
11095 
        break
11096 
      if fid == 0:
11097 
        if ftype == TType.LIST:
11098 
          self.success = []
6188 rajveer 11099 
          (_etype158, _size155) = iprot.readListBegin()
11100 
          for _i159 in xrange(_size155):
11101 
            _elem160 = Order()
11102 
            _elem160.read(iprot)
11103 
            self.success.append(_elem160)
999 varun.gupt 11104 
          iprot.readListEnd()
11105 
        else:
11106 
          iprot.skip(ftype)
11107 
      elif fid == 1:
11108 
        if ftype == TType.STRUCT:
11109 
          self.ex = TransactionServiceException()
11110 
          self.ex.read(iprot)
11111 
        else:
11112 
          iprot.skip(ftype)
11113 
      else:
11114 
        iprot.skip(ftype)
11115 
      iprot.readFieldEnd()
11116 
    iprot.readStructEnd()
11117 
 
11118 
  def write(self, oprot):
11119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11121 
      return
11122 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11123 
    if self.success is not None:
999 varun.gupt 11124 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11125 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11126 
      for iter161 in self.success:
11127 
        iter161.write(oprot)
999 varun.gupt 11128 
      oprot.writeListEnd()
11129 
      oprot.writeFieldEnd()
3431 rajveer 11130 
    if self.ex is not None:
999 varun.gupt 11131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11132 
      self.ex.write(oprot)
11133 
      oprot.writeFieldEnd()
11134 
    oprot.writeFieldStop()
11135 
    oprot.writeStructEnd()
11136 
 
3431 rajveer 11137 
  def validate(self):
11138 
    return
11139 
 
11140 
 
999 varun.gupt 11141 
  def __repr__(self):
11142 
    L = ['%s=%r' % (key, value)
11143 
      for key, value in self.__dict__.iteritems()]
11144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11145 
 
11146 
  def __eq__(self, other):
11147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11148 
 
11149 
  def __ne__(self, other):
11150 
    return not (self == other)
11151 
 
3427 chandransh 11152 
class getOrdersByShippingDate_args:
11153 
  """
11154 
  Attributes:
11155 
   - fromShippingDate
11156 
   - toShippingDate
11157 
   - providerId
11158 
   - warehouseId
3451 chandransh 11159 
   - cod
3427 chandransh 11160 
  """
11161 
 
11162 
  thrift_spec = (
11163 
    None, # 0
11164 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11165 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11166 
    (3, TType.I64, 'providerId', None, None, ), # 3
11167 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11168 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11169 
  )
11170 
 
3451 chandransh 11171 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11172 
    self.fromShippingDate = fromShippingDate
11173 
    self.toShippingDate = toShippingDate
11174 
    self.providerId = providerId
11175 
    self.warehouseId = warehouseId
3451 chandransh 11176 
    self.cod = cod
3427 chandransh 11177 
 
11178 
  def read(self, iprot):
11179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11181 
      return
11182 
    iprot.readStructBegin()
11183 
    while True:
11184 
      (fname, ftype, fid) = iprot.readFieldBegin()
11185 
      if ftype == TType.STOP:
11186 
        break
11187 
      if fid == 1:
11188 
        if ftype == TType.I64:
11189 
          self.fromShippingDate = iprot.readI64();
11190 
        else:
11191 
          iprot.skip(ftype)
11192 
      elif fid == 2:
11193 
        if ftype == TType.I64:
11194 
          self.toShippingDate = iprot.readI64();
11195 
        else:
11196 
          iprot.skip(ftype)
11197 
      elif fid == 3:
11198 
        if ftype == TType.I64:
11199 
          self.providerId = iprot.readI64();
11200 
        else:
11201 
          iprot.skip(ftype)
11202 
      elif fid == 4:
11203 
        if ftype == TType.I64:
11204 
          self.warehouseId = iprot.readI64();
11205 
        else:
11206 
          iprot.skip(ftype)
3451 chandransh 11207 
      elif fid == 5:
11208 
        if ftype == TType.BOOL:
11209 
          self.cod = iprot.readBool();
11210 
        else:
11211 
          iprot.skip(ftype)
3427 chandransh 11212 
      else:
11213 
        iprot.skip(ftype)
11214 
      iprot.readFieldEnd()
11215 
    iprot.readStructEnd()
11216 
 
11217 
  def write(self, oprot):
11218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11220 
      return
11221 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11222 
    if self.fromShippingDate is not None:
3427 chandransh 11223 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11224 
      oprot.writeI64(self.fromShippingDate)
11225 
      oprot.writeFieldEnd()
3431 rajveer 11226 
    if self.toShippingDate is not None:
3427 chandransh 11227 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11228 
      oprot.writeI64(self.toShippingDate)
11229 
      oprot.writeFieldEnd()
3431 rajveer 11230 
    if self.providerId is not None:
3427 chandransh 11231 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11232 
      oprot.writeI64(self.providerId)
11233 
      oprot.writeFieldEnd()
3431 rajveer 11234 
    if self.warehouseId is not None:
3427 chandransh 11235 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11236 
      oprot.writeI64(self.warehouseId)
11237 
      oprot.writeFieldEnd()
3451 chandransh 11238 
    if self.cod is not None:
11239 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11240 
      oprot.writeBool(self.cod)
11241 
      oprot.writeFieldEnd()
3427 chandransh 11242 
    oprot.writeFieldStop()
11243 
    oprot.writeStructEnd()
11244 
 
3431 rajveer 11245 
  def validate(self):
11246 
    return
11247 
 
11248 
 
3427 chandransh 11249 
  def __repr__(self):
11250 
    L = ['%s=%r' % (key, value)
11251 
      for key, value in self.__dict__.iteritems()]
11252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11253 
 
11254 
  def __eq__(self, other):
11255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11256 
 
11257 
  def __ne__(self, other):
11258 
    return not (self == other)
11259 
 
11260 
class getOrdersByShippingDate_result:
11261 
  """
11262 
  Attributes:
11263 
   - success
11264 
   - ex
11265 
  """
11266 
 
11267 
  thrift_spec = (
11268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11270 
  )
11271 
 
11272 
  def __init__(self, success=None, ex=None,):
11273 
    self.success = success
11274 
    self.ex = ex
11275 
 
11276 
  def read(self, iprot):
11277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11279 
      return
11280 
    iprot.readStructBegin()
11281 
    while True:
11282 
      (fname, ftype, fid) = iprot.readFieldBegin()
11283 
      if ftype == TType.STOP:
11284 
        break
11285 
      if fid == 0:
11286 
        if ftype == TType.LIST:
11287 
          self.success = []
6188 rajveer 11288 
          (_etype165, _size162) = iprot.readListBegin()
11289 
          for _i166 in xrange(_size162):
11290 
            _elem167 = Order()
11291 
            _elem167.read(iprot)
11292 
            self.success.append(_elem167)
3427 chandransh 11293 
          iprot.readListEnd()
11294 
        else:
11295 
          iprot.skip(ftype)
11296 
      elif fid == 1:
11297 
        if ftype == TType.STRUCT:
11298 
          self.ex = TransactionServiceException()
11299 
          self.ex.read(iprot)
11300 
        else:
11301 
          iprot.skip(ftype)
11302 
      else:
11303 
        iprot.skip(ftype)
11304 
      iprot.readFieldEnd()
11305 
    iprot.readStructEnd()
11306 
 
11307 
  def write(self, oprot):
11308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11310 
      return
11311 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11312 
    if self.success is not None:
3427 chandransh 11313 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11314 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11315 
      for iter168 in self.success:
11316 
        iter168.write(oprot)
3427 chandransh 11317 
      oprot.writeListEnd()
11318 
      oprot.writeFieldEnd()
3431 rajveer 11319 
    if self.ex is not None:
3427 chandransh 11320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11321 
      self.ex.write(oprot)
11322 
      oprot.writeFieldEnd()
11323 
    oprot.writeFieldStop()
11324 
    oprot.writeStructEnd()
11325 
 
3431 rajveer 11326 
  def validate(self):
11327 
    return
11328 
 
11329 
 
3427 chandransh 11330 
  def __repr__(self):
11331 
    L = ['%s=%r' % (key, value)
11332 
      for key, value in self.__dict__.iteritems()]
11333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11334 
 
11335 
  def __eq__(self, other):
11336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11337 
 
11338 
  def __ne__(self, other):
11339 
    return not (self == other)
11340 
 
1382 varun.gupt 11341 
class getReturnableOrdersForCustomer_args:
11342 
  """
11343 
  Attributes:
11344 
   - customer_id
11345 
   - limit
11346 
  """
11347 
 
11348 
  thrift_spec = (
11349 
    None, # 0
11350 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11351 
    (2, TType.I64, 'limit', None, None, ), # 2
11352 
  )
11353 
 
11354 
  def __init__(self, customer_id=None, limit=None,):
11355 
    self.customer_id = customer_id
11356 
    self.limit = limit
11357 
 
11358 
  def read(self, iprot):
11359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11361 
      return
11362 
    iprot.readStructBegin()
11363 
    while True:
11364 
      (fname, ftype, fid) = iprot.readFieldBegin()
11365 
      if ftype == TType.STOP:
11366 
        break
11367 
      if fid == 1:
11368 
        if ftype == TType.I64:
11369 
          self.customer_id = iprot.readI64();
11370 
        else:
11371 
          iprot.skip(ftype)
11372 
      elif fid == 2:
11373 
        if ftype == TType.I64:
11374 
          self.limit = iprot.readI64();
11375 
        else:
11376 
          iprot.skip(ftype)
11377 
      else:
11378 
        iprot.skip(ftype)
11379 
      iprot.readFieldEnd()
11380 
    iprot.readStructEnd()
11381 
 
11382 
  def write(self, oprot):
11383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11385 
      return
11386 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11387 
    if self.customer_id is not None:
1382 varun.gupt 11388 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11389 
      oprot.writeI64(self.customer_id)
11390 
      oprot.writeFieldEnd()
3431 rajveer 11391 
    if self.limit is not None:
1382 varun.gupt 11392 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11393 
      oprot.writeI64(self.limit)
11394 
      oprot.writeFieldEnd()
11395 
    oprot.writeFieldStop()
11396 
    oprot.writeStructEnd()
11397 
 
3431 rajveer 11398 
  def validate(self):
11399 
    return
11400 
 
11401 
 
1382 varun.gupt 11402 
  def __repr__(self):
11403 
    L = ['%s=%r' % (key, value)
11404 
      for key, value in self.__dict__.iteritems()]
11405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11406 
 
11407 
  def __eq__(self, other):
11408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11409 
 
11410 
  def __ne__(self, other):
11411 
    return not (self == other)
11412 
 
11413 
class getReturnableOrdersForCustomer_result:
11414 
  """
11415 
  Attributes:
11416 
   - success
11417 
   - ex
11418 
  """
11419 
 
11420 
  thrift_spec = (
11421 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11423 
  )
11424 
 
11425 
  def __init__(self, success=None, ex=None,):
11426 
    self.success = success
11427 
    self.ex = ex
11428 
 
11429 
  def read(self, iprot):
11430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11432 
      return
11433 
    iprot.readStructBegin()
11434 
    while True:
11435 
      (fname, ftype, fid) = iprot.readFieldBegin()
11436 
      if ftype == TType.STOP:
11437 
        break
11438 
      if fid == 0:
11439 
        if ftype == TType.LIST:
11440 
          self.success = []
6188 rajveer 11441 
          (_etype172, _size169) = iprot.readListBegin()
11442 
          for _i173 in xrange(_size169):
11443 
            _elem174 = iprot.readI64();
11444 
            self.success.append(_elem174)
1382 varun.gupt 11445 
          iprot.readListEnd()
11446 
        else:
11447 
          iprot.skip(ftype)
11448 
      elif fid == 1:
11449 
        if ftype == TType.STRUCT:
11450 
          self.ex = TransactionServiceException()
11451 
          self.ex.read(iprot)
11452 
        else:
11453 
          iprot.skip(ftype)
11454 
      else:
11455 
        iprot.skip(ftype)
11456 
      iprot.readFieldEnd()
11457 
    iprot.readStructEnd()
11458 
 
11459 
  def write(self, oprot):
11460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11462 
      return
11463 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11464 
    if self.success is not None:
1382 varun.gupt 11465 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11466 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11467 
      for iter175 in self.success:
11468 
        oprot.writeI64(iter175)
1382 varun.gupt 11469 
      oprot.writeListEnd()
11470 
      oprot.writeFieldEnd()
3431 rajveer 11471 
    if self.ex is not None:
1382 varun.gupt 11472 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11473 
      self.ex.write(oprot)
11474 
      oprot.writeFieldEnd()
11475 
    oprot.writeFieldStop()
11476 
    oprot.writeStructEnd()
11477 
 
3431 rajveer 11478 
  def validate(self):
11479 
    return
11480 
 
11481 
 
1382 varun.gupt 11482 
  def __repr__(self):
11483 
    L = ['%s=%r' % (key, value)
11484 
      for key, value in self.__dict__.iteritems()]
11485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11486 
 
11487 
  def __eq__(self, other):
11488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11489 
 
11490 
  def __ne__(self, other):
11491 
    return not (self == other)
11492 
 
11493 
class getCancellableOrdersForCustomer_args:
11494 
  """
11495 
  Attributes:
11496 
   - customer_id
11497 
   - limit
11498 
  """
11499 
 
11500 
  thrift_spec = (
11501 
    None, # 0
11502 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11503 
    (2, TType.I64, 'limit', None, None, ), # 2
11504 
  )
11505 
 
11506 
  def __init__(self, customer_id=None, limit=None,):
11507 
    self.customer_id = customer_id
11508 
    self.limit = limit
11509 
 
11510 
  def read(self, iprot):
11511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11513 
      return
11514 
    iprot.readStructBegin()
11515 
    while True:
11516 
      (fname, ftype, fid) = iprot.readFieldBegin()
11517 
      if ftype == TType.STOP:
11518 
        break
11519 
      if fid == 1:
11520 
        if ftype == TType.I64:
11521 
          self.customer_id = iprot.readI64();
11522 
        else:
11523 
          iprot.skip(ftype)
11524 
      elif fid == 2:
11525 
        if ftype == TType.I64:
11526 
          self.limit = iprot.readI64();
11527 
        else:
11528 
          iprot.skip(ftype)
11529 
      else:
11530 
        iprot.skip(ftype)
11531 
      iprot.readFieldEnd()
11532 
    iprot.readStructEnd()
11533 
 
11534 
  def write(self, oprot):
11535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11537 
      return
11538 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11539 
    if self.customer_id is not None:
1382 varun.gupt 11540 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11541 
      oprot.writeI64(self.customer_id)
11542 
      oprot.writeFieldEnd()
3431 rajveer 11543 
    if self.limit is not None:
1382 varun.gupt 11544 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11545 
      oprot.writeI64(self.limit)
11546 
      oprot.writeFieldEnd()
11547 
    oprot.writeFieldStop()
11548 
    oprot.writeStructEnd()
11549 
 
3431 rajveer 11550 
  def validate(self):
11551 
    return
11552 
 
11553 
 
1382 varun.gupt 11554 
  def __repr__(self):
11555 
    L = ['%s=%r' % (key, value)
11556 
      for key, value in self.__dict__.iteritems()]
11557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11558 
 
11559 
  def __eq__(self, other):
11560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11561 
 
11562 
  def __ne__(self, other):
11563 
    return not (self == other)
11564 
 
11565 
class getCancellableOrdersForCustomer_result:
11566 
  """
11567 
  Attributes:
11568 
   - success
11569 
   - ex
11570 
  """
11571 
 
11572 
  thrift_spec = (
11573 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11575 
  )
11576 
 
11577 
  def __init__(self, success=None, ex=None,):
11578 
    self.success = success
11579 
    self.ex = ex
11580 
 
11581 
  def read(self, iprot):
11582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11584 
      return
11585 
    iprot.readStructBegin()
11586 
    while True:
11587 
      (fname, ftype, fid) = iprot.readFieldBegin()
11588 
      if ftype == TType.STOP:
11589 
        break
11590 
      if fid == 0:
11591 
        if ftype == TType.LIST:
11592 
          self.success = []
6188 rajveer 11593 
          (_etype179, _size176) = iprot.readListBegin()
11594 
          for _i180 in xrange(_size176):
11595 
            _elem181 = iprot.readI64();
11596 
            self.success.append(_elem181)
1382 varun.gupt 11597 
          iprot.readListEnd()
11598 
        else:
11599 
          iprot.skip(ftype)
11600 
      elif fid == 1:
11601 
        if ftype == TType.STRUCT:
11602 
          self.ex = TransactionServiceException()
11603 
          self.ex.read(iprot)
11604 
        else:
11605 
          iprot.skip(ftype)
11606 
      else:
11607 
        iprot.skip(ftype)
11608 
      iprot.readFieldEnd()
11609 
    iprot.readStructEnd()
11610 
 
11611 
  def write(self, oprot):
11612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11614 
      return
11615 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11616 
    if self.success is not None:
1382 varun.gupt 11617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11618 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11619 
      for iter182 in self.success:
11620 
        oprot.writeI64(iter182)
1382 varun.gupt 11621 
      oprot.writeListEnd()
11622 
      oprot.writeFieldEnd()
3431 rajveer 11623 
    if self.ex is not None:
1382 varun.gupt 11624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11625 
      self.ex.write(oprot)
11626 
      oprot.writeFieldEnd()
11627 
    oprot.writeFieldStop()
11628 
    oprot.writeStructEnd()
11629 
 
3431 rajveer 11630 
  def validate(self):
11631 
    return
11632 
 
11633 
 
1382 varun.gupt 11634 
  def __repr__(self):
11635 
    L = ['%s=%r' % (key, value)
11636 
      for key, value in self.__dict__.iteritems()]
11637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11638 
 
11639 
  def __eq__(self, other):
11640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11641 
 
11642 
  def __ne__(self, other):
11643 
    return not (self == other)
11644 
 
483 rajveer 11645 
class changeOrderStatus_args:
94 ashish 11646 
  """
11647 
  Attributes:
483 rajveer 11648 
   - orderId
11649 
   - status
11650 
   - description
94 ashish 11651 
  """
11652 
 
11653 
  thrift_spec = (
11654 
    None, # 0
483 rajveer 11655 
    (1, TType.I64, 'orderId', None, None, ), # 1
11656 
    (2, TType.I32, 'status', None, None, ), # 2
11657 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11658 
  )
11659 
 
483 rajveer 11660 
  def __init__(self, orderId=None, status=None, description=None,):
11661 
    self.orderId = orderId
11662 
    self.status = status
11663 
    self.description = description
94 ashish 11664 
 
11665 
  def read(self, iprot):
11666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11668 
      return
11669 
    iprot.readStructBegin()
11670 
    while True:
11671 
      (fname, ftype, fid) = iprot.readFieldBegin()
11672 
      if ftype == TType.STOP:
11673 
        break
11674 
      if fid == 1:
11675 
        if ftype == TType.I64:
483 rajveer 11676 
          self.orderId = iprot.readI64();
94 ashish 11677 
        else:
11678 
          iprot.skip(ftype)
11679 
      elif fid == 2:
483 rajveer 11680 
        if ftype == TType.I32:
11681 
          self.status = iprot.readI32();
94 ashish 11682 
        else:
11683 
          iprot.skip(ftype)
483 rajveer 11684 
      elif fid == 3:
11685 
        if ftype == TType.STRING:
11686 
          self.description = iprot.readString();
11687 
        else:
11688 
          iprot.skip(ftype)
94 ashish 11689 
      else:
11690 
        iprot.skip(ftype)
11691 
      iprot.readFieldEnd()
11692 
    iprot.readStructEnd()
11693 
 
11694 
  def write(self, oprot):
11695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11697 
      return
483 rajveer 11698 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11699 
    if self.orderId is not None:
483 rajveer 11700 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11701 
      oprot.writeI64(self.orderId)
94 ashish 11702 
      oprot.writeFieldEnd()
3431 rajveer 11703 
    if self.status is not None:
483 rajveer 11704 
      oprot.writeFieldBegin('status', TType.I32, 2)
11705 
      oprot.writeI32(self.status)
94 ashish 11706 
      oprot.writeFieldEnd()
3431 rajveer 11707 
    if self.description is not None:
483 rajveer 11708 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11709 
      oprot.writeString(self.description)
11710 
      oprot.writeFieldEnd()
94 ashish 11711 
    oprot.writeFieldStop()
11712 
    oprot.writeStructEnd()
11713 
 
3431 rajveer 11714 
  def validate(self):
11715 
    return
11716 
 
11717 
 
94 ashish 11718 
  def __repr__(self):
11719 
    L = ['%s=%r' % (key, value)
11720 
      for key, value in self.__dict__.iteritems()]
11721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11722 
 
11723 
  def __eq__(self, other):
11724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11725 
 
11726 
  def __ne__(self, other):
11727 
    return not (self == other)
11728 
 
483 rajveer 11729 
class changeOrderStatus_result:
94 ashish 11730 
  """
11731 
  Attributes:
11732 
   - success
11733 
   - ex
11734 
  """
11735 
 
11736 
  thrift_spec = (
11737 
    (0, TType.BOOL, 'success', None, None, ), # 0
11738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11739 
  )
11740 
 
11741 
  def __init__(self, success=None, ex=None,):
11742 
    self.success = success
11743 
    self.ex = ex
11744 
 
11745 
  def read(self, iprot):
11746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11748 
      return
11749 
    iprot.readStructBegin()
11750 
    while True:
11751 
      (fname, ftype, fid) = iprot.readFieldBegin()
11752 
      if ftype == TType.STOP:
11753 
        break
11754 
      if fid == 0:
11755 
        if ftype == TType.BOOL:
11756 
          self.success = iprot.readBool();
11757 
        else:
11758 
          iprot.skip(ftype)
11759 
      elif fid == 1:
11760 
        if ftype == TType.STRUCT:
11761 
          self.ex = TransactionServiceException()
11762 
          self.ex.read(iprot)
11763 
        else:
11764 
          iprot.skip(ftype)
11765 
      else:
11766 
        iprot.skip(ftype)
11767 
      iprot.readFieldEnd()
11768 
    iprot.readStructEnd()
11769 
 
11770 
  def write(self, oprot):
11771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11773 
      return
483 rajveer 11774 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11775 
    if self.success is not None:
94 ashish 11776 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11777 
      oprot.writeBool(self.success)
11778 
      oprot.writeFieldEnd()
3431 rajveer 11779 
    if self.ex is not None:
94 ashish 11780 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11781 
      self.ex.write(oprot)
11782 
      oprot.writeFieldEnd()
11783 
    oprot.writeFieldStop()
11784 
    oprot.writeStructEnd()
11785 
 
3431 rajveer 11786 
  def validate(self):
11787 
    return
11788 
 
11789 
 
94 ashish 11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
3064 chandransh 11801 
class getOrdersForTransaction_args:
494 rajveer 11802 
  """
11803 
  Attributes:
3064 chandransh 11804 
   - transactionId
11805 
   - customerId
494 rajveer 11806 
  """
11807 
 
11808 
  thrift_spec = (
11809 
    None, # 0
3064 chandransh 11810 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11811 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11812 
  )
11813 
 
3064 chandransh 11814 
  def __init__(self, transactionId=None, customerId=None,):
11815 
    self.transactionId = transactionId
11816 
    self.customerId = customerId
494 rajveer 11817 
 
11818 
  def read(self, iprot):
11819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11821 
      return
11822 
    iprot.readStructBegin()
11823 
    while True:
11824 
      (fname, ftype, fid) = iprot.readFieldBegin()
11825 
      if ftype == TType.STOP:
11826 
        break
11827 
      if fid == 1:
11828 
        if ftype == TType.I64:
3064 chandransh 11829 
          self.transactionId = iprot.readI64();
494 rajveer 11830 
        else:
11831 
          iprot.skip(ftype)
11832 
      elif fid == 2:
3064 chandransh 11833 
        if ftype == TType.I64:
11834 
          self.customerId = iprot.readI64();
494 rajveer 11835 
        else:
11836 
          iprot.skip(ftype)
11837 
      else:
11838 
        iprot.skip(ftype)
11839 
      iprot.readFieldEnd()
11840 
    iprot.readStructEnd()
11841 
 
11842 
  def write(self, oprot):
11843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11845 
      return
3064 chandransh 11846 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11847 
    if self.transactionId is not None:
3064 chandransh 11848 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11849 
      oprot.writeI64(self.transactionId)
494 rajveer 11850 
      oprot.writeFieldEnd()
3431 rajveer 11851 
    if self.customerId is not None:
3064 chandransh 11852 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11853 
      oprot.writeI64(self.customerId)
494 rajveer 11854 
      oprot.writeFieldEnd()
11855 
    oprot.writeFieldStop()
11856 
    oprot.writeStructEnd()
11857 
 
3431 rajveer 11858 
  def validate(self):
11859 
    return
11860 
 
11861 
 
494 rajveer 11862 
  def __repr__(self):
11863 
    L = ['%s=%r' % (key, value)
11864 
      for key, value in self.__dict__.iteritems()]
11865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11866 
 
11867 
  def __eq__(self, other):
11868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11869 
 
11870 
  def __ne__(self, other):
11871 
    return not (self == other)
11872 
 
3064 chandransh 11873 
class getOrdersForTransaction_result:
494 rajveer 11874 
  """
11875 
  Attributes:
11876 
   - success
11877 
   - ex
11878 
  """
11879 
 
11880 
  thrift_spec = (
3064 chandransh 11881 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11883 
  )
11884 
 
11885 
  def __init__(self, success=None, ex=None,):
11886 
    self.success = success
11887 
    self.ex = ex
11888 
 
11889 
  def read(self, iprot):
11890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11892 
      return
11893 
    iprot.readStructBegin()
11894 
    while True:
11895 
      (fname, ftype, fid) = iprot.readFieldBegin()
11896 
      if ftype == TType.STOP:
11897 
        break
11898 
      if fid == 0:
3064 chandransh 11899 
        if ftype == TType.LIST:
11900 
          self.success = []
6188 rajveer 11901 
          (_etype186, _size183) = iprot.readListBegin()
11902 
          for _i187 in xrange(_size183):
11903 
            _elem188 = Order()
11904 
            _elem188.read(iprot)
11905 
            self.success.append(_elem188)
3064 chandransh 11906 
          iprot.readListEnd()
494 rajveer 11907 
        else:
11908 
          iprot.skip(ftype)
11909 
      elif fid == 1:
11910 
        if ftype == TType.STRUCT:
11911 
          self.ex = TransactionServiceException()
11912 
          self.ex.read(iprot)
11913 
        else:
11914 
          iprot.skip(ftype)
11915 
      else:
11916 
        iprot.skip(ftype)
11917 
      iprot.readFieldEnd()
11918 
    iprot.readStructEnd()
11919 
 
11920 
  def write(self, oprot):
11921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11923 
      return
3064 chandransh 11924 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11925 
    if self.success is not None:
3064 chandransh 11926 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11927 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11928 
      for iter189 in self.success:
11929 
        iter189.write(oprot)
3064 chandransh 11930 
      oprot.writeListEnd()
494 rajveer 11931 
      oprot.writeFieldEnd()
3431 rajveer 11932 
    if self.ex is not None:
494 rajveer 11933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11934 
      self.ex.write(oprot)
11935 
      oprot.writeFieldEnd()
11936 
    oprot.writeFieldStop()
11937 
    oprot.writeStructEnd()
11938 
 
3431 rajveer 11939 
  def validate(self):
11940 
    return
11941 
 
11942 
 
494 rajveer 11943 
  def __repr__(self):
11944 
    L = ['%s=%r' % (key, value)
11945 
      for key, value in self.__dict__.iteritems()]
11946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11947 
 
11948 
  def __eq__(self, other):
11949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11950 
 
11951 
  def __ne__(self, other):
11952 
    return not (self == other)
11953 
 
3064 chandransh 11954 
class getOrdersForCustomer_args:
1149 chandransh 11955 
  """
11956 
  Attributes:
3064 chandransh 11957 
   - customerId
11958 
   - from_date
11959 
   - to_date
11960 
   - statuses
1149 chandransh 11961 
  """
11962 
 
11963 
  thrift_spec = (
11964 
    None, # 0
3064 chandransh 11965 
    (1, TType.I64, 'customerId', None, None, ), # 1
11966 
    (2, TType.I64, 'from_date', None, None, ), # 2
11967 
    (3, TType.I64, 'to_date', None, None, ), # 3
11968 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11969 
  )
11970 
 
3064 chandransh 11971 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11972 
    self.customerId = customerId
11973 
    self.from_date = from_date
11974 
    self.to_date = to_date
11975 
    self.statuses = statuses
1149 chandransh 11976 
 
11977 
  def read(self, iprot):
11978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11980 
      return
11981 
    iprot.readStructBegin()
11982 
    while True:
11983 
      (fname, ftype, fid) = iprot.readFieldBegin()
11984 
      if ftype == TType.STOP:
11985 
        break
11986 
      if fid == 1:
11987 
        if ftype == TType.I64:
3064 chandransh 11988 
          self.customerId = iprot.readI64();
1149 chandransh 11989 
        else:
11990 
          iprot.skip(ftype)
11991 
      elif fid == 2:
11992 
        if ftype == TType.I64:
3064 chandransh 11993 
          self.from_date = iprot.readI64();
1149 chandransh 11994 
        else:
11995 
          iprot.skip(ftype)
2783 chandransh 11996 
      elif fid == 3:
11997 
        if ftype == TType.I64:
3064 chandransh 11998 
          self.to_date = iprot.readI64();
2783 chandransh 11999 
        else:
12000 
          iprot.skip(ftype)
12001 
      elif fid == 4:
3064 chandransh 12002 
        if ftype == TType.LIST:
12003 
          self.statuses = []
6188 rajveer 12004 
          (_etype193, _size190) = iprot.readListBegin()
12005 
          for _i194 in xrange(_size190):
12006 
            _elem195 = iprot.readI32();
12007 
            self.statuses.append(_elem195)
3064 chandransh 12008 
          iprot.readListEnd()
2783 chandransh 12009 
        else:
12010 
          iprot.skip(ftype)
1149 chandransh 12011 
      else:
12012 
        iprot.skip(ftype)
12013 
      iprot.readFieldEnd()
12014 
    iprot.readStructEnd()
12015 
 
12016 
  def write(self, oprot):
12017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12019 
      return
3064 chandransh 12020 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12021 
    if self.customerId is not None:
3064 chandransh 12022 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12023 
      oprot.writeI64(self.customerId)
1149 chandransh 12024 
      oprot.writeFieldEnd()
3431 rajveer 12025 
    if self.from_date is not None:
3064 chandransh 12026 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12027 
      oprot.writeI64(self.from_date)
1149 chandransh 12028 
      oprot.writeFieldEnd()
3431 rajveer 12029 
    if self.to_date is not None:
3064 chandransh 12030 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12031 
      oprot.writeI64(self.to_date)
2783 chandransh 12032 
      oprot.writeFieldEnd()
3431 rajveer 12033 
    if self.statuses is not None:
3064 chandransh 12034 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12035 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12036 
      for iter196 in self.statuses:
12037 
        oprot.writeI32(iter196)
3064 chandransh 12038 
      oprot.writeListEnd()
2783 chandransh 12039 
      oprot.writeFieldEnd()
1149 chandransh 12040 
    oprot.writeFieldStop()
12041 
    oprot.writeStructEnd()
12042 
 
3431 rajveer 12043 
  def validate(self):
12044 
    return
12045 
 
12046 
 
1149 chandransh 12047 
  def __repr__(self):
12048 
    L = ['%s=%r' % (key, value)
12049 
      for key, value in self.__dict__.iteritems()]
12050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12051 
 
12052 
  def __eq__(self, other):
12053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12054 
 
12055 
  def __ne__(self, other):
12056 
    return not (self == other)
12057 
 
3064 chandransh 12058 
class getOrdersForCustomer_result:
1149 chandransh 12059 
  """
12060 
  Attributes:
12061 
   - success
12062 
   - ex
12063 
  """
12064 
 
12065 
  thrift_spec = (
3064 chandransh 12066 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12068 
  )
12069 
 
12070 
  def __init__(self, success=None, ex=None,):
12071 
    self.success = success
12072 
    self.ex = ex
12073 
 
12074 
  def read(self, iprot):
12075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12077 
      return
12078 
    iprot.readStructBegin()
12079 
    while True:
12080 
      (fname, ftype, fid) = iprot.readFieldBegin()
12081 
      if ftype == TType.STOP:
12082 
        break
12083 
      if fid == 0:
3064 chandransh 12084 
        if ftype == TType.LIST:
12085 
          self.success = []
6188 rajveer 12086 
          (_etype200, _size197) = iprot.readListBegin()
12087 
          for _i201 in xrange(_size197):
12088 
            _elem202 = Order()
12089 
            _elem202.read(iprot)
12090 
            self.success.append(_elem202)
3064 chandransh 12091 
          iprot.readListEnd()
1149 chandransh 12092 
        else:
12093 
          iprot.skip(ftype)
12094 
      elif fid == 1:
12095 
        if ftype == TType.STRUCT:
12096 
          self.ex = TransactionServiceException()
12097 
          self.ex.read(iprot)
12098 
        else:
12099 
          iprot.skip(ftype)
12100 
      else:
12101 
        iprot.skip(ftype)
12102 
      iprot.readFieldEnd()
12103 
    iprot.readStructEnd()
12104 
 
12105 
  def write(self, oprot):
12106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12108 
      return
3064 chandransh 12109 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12110 
    if self.success is not None:
3064 chandransh 12111 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12112 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12113 
      for iter203 in self.success:
12114 
        iter203.write(oprot)
3064 chandransh 12115 
      oprot.writeListEnd()
1149 chandransh 12116 
      oprot.writeFieldEnd()
3431 rajveer 12117 
    if self.ex is not None:
1149 chandransh 12118 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12119 
      self.ex.write(oprot)
12120 
      oprot.writeFieldEnd()
12121 
    oprot.writeFieldStop()
12122 
    oprot.writeStructEnd()
12123 
 
3431 rajveer 12124 
  def validate(self):
12125 
    return
12126 
 
12127 
 
1149 chandransh 12128 
  def __repr__(self):
12129 
    L = ['%s=%r' % (key, value)
12130 
      for key, value in self.__dict__.iteritems()]
12131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12132 
 
12133 
  def __eq__(self, other):
12134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12135 
 
12136 
  def __ne__(self, other):
12137 
    return not (self == other)
12138 
 
3064 chandransh 12139 
class createOrder_args:
921 rajveer 12140 
  """
12141 
  Attributes:
3064 chandransh 12142 
   - order
921 rajveer 12143 
  """
12144 
 
12145 
  thrift_spec = (
12146 
    None, # 0
3064 chandransh 12147 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12148 
  )
12149 
 
3064 chandransh 12150 
  def __init__(self, order=None,):
12151 
    self.order = order
921 rajveer 12152 
 
12153 
  def read(self, iprot):
12154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12156 
      return
12157 
    iprot.readStructBegin()
12158 
    while True:
12159 
      (fname, ftype, fid) = iprot.readFieldBegin()
12160 
      if ftype == TType.STOP:
12161 
        break
12162 
      if fid == 1:
3064 chandransh 12163 
        if ftype == TType.STRUCT:
12164 
          self.order = Order()
12165 
          self.order.read(iprot)
921 rajveer 12166 
        else:
12167 
          iprot.skip(ftype)
12168 
      else:
12169 
        iprot.skip(ftype)
12170 
      iprot.readFieldEnd()
12171 
    iprot.readStructEnd()
12172 
 
12173 
  def write(self, oprot):
12174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12176 
      return
3064 chandransh 12177 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12178 
    if self.order is not None:
3064 chandransh 12179 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12180 
      self.order.write(oprot)
921 rajveer 12181 
      oprot.writeFieldEnd()
12182 
    oprot.writeFieldStop()
12183 
    oprot.writeStructEnd()
12184 
 
3431 rajveer 12185 
  def validate(self):
12186 
    return
12187 
 
12188 
 
921 rajveer 12189 
  def __repr__(self):
12190 
    L = ['%s=%r' % (key, value)
12191 
      for key, value in self.__dict__.iteritems()]
12192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12193 
 
12194 
  def __eq__(self, other):
12195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12196 
 
12197 
  def __ne__(self, other):
12198 
    return not (self == other)
12199 
 
3064 chandransh 12200 
class createOrder_result:
921 rajveer 12201 
  """
12202 
  Attributes:
12203 
   - success
12204 
   - ex
12205 
  """
12206 
 
12207 
  thrift_spec = (
3064 chandransh 12208 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12210 
  )
12211 
 
12212 
  def __init__(self, success=None, ex=None,):
12213 
    self.success = success
12214 
    self.ex = ex
12215 
 
12216 
  def read(self, iprot):
12217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12219 
      return
12220 
    iprot.readStructBegin()
12221 
    while True:
12222 
      (fname, ftype, fid) = iprot.readFieldBegin()
12223 
      if ftype == TType.STOP:
12224 
        break
12225 
      if fid == 0:
3064 chandransh 12226 
        if ftype == TType.I64:
12227 
          self.success = iprot.readI64();
921 rajveer 12228 
        else:
12229 
          iprot.skip(ftype)
12230 
      elif fid == 1:
12231 
        if ftype == TType.STRUCT:
12232 
          self.ex = TransactionServiceException()
12233 
          self.ex.read(iprot)
12234 
        else:
12235 
          iprot.skip(ftype)
12236 
      else:
12237 
        iprot.skip(ftype)
12238 
      iprot.readFieldEnd()
12239 
    iprot.readStructEnd()
12240 
 
12241 
  def write(self, oprot):
12242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12244 
      return
3064 chandransh 12245 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12246 
    if self.success is not None:
3064 chandransh 12247 
      oprot.writeFieldBegin('success', TType.I64, 0)
12248 
      oprot.writeI64(self.success)
921 rajveer 12249 
      oprot.writeFieldEnd()
3431 rajveer 12250 
    if self.ex is not None:
921 rajveer 12251 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12252 
      self.ex.write(oprot)
12253 
      oprot.writeFieldEnd()
12254 
    oprot.writeFieldStop()
12255 
    oprot.writeStructEnd()
12256 
 
3431 rajveer 12257 
  def validate(self):
12258 
    return
12259 
 
12260 
 
921 rajveer 12261 
  def __repr__(self):
12262 
    L = ['%s=%r' % (key, value)
12263 
      for key, value in self.__dict__.iteritems()]
12264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12265 
 
12266 
  def __eq__(self, other):
12267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12268 
 
12269 
  def __ne__(self, other):
12270 
    return not (self == other)
12271 
 
3064 chandransh 12272 
class getOrder_args:
921 rajveer 12273 
  """
12274 
  Attributes:
3064 chandransh 12275 
   - id
921 rajveer 12276 
  """
12277 
 
12278 
  thrift_spec = (
12279 
    None, # 0
3064 chandransh 12280 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12281 
  )
12282 
 
3064 chandransh 12283 
  def __init__(self, id=None,):
12284 
    self.id = id
921 rajveer 12285 
 
12286 
  def read(self, iprot):
12287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12289 
      return
12290 
    iprot.readStructBegin()
12291 
    while True:
12292 
      (fname, ftype, fid) = iprot.readFieldBegin()
12293 
      if ftype == TType.STOP:
12294 
        break
12295 
      if fid == 1:
12296 
        if ftype == TType.I64:
3064 chandransh 12297 
          self.id = iprot.readI64();
921 rajveer 12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
3064 chandransh 12309 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12310 
    if self.id is not None:
3064 chandransh 12311 
      oprot.writeFieldBegin('id', TType.I64, 1)
12312 
      oprot.writeI64(self.id)
921 rajveer 12313 
      oprot.writeFieldEnd()
12314 
    oprot.writeFieldStop()
12315 
    oprot.writeStructEnd()
12316 
 
3431 rajveer 12317 
  def validate(self):
12318 
    return
12319 
 
12320 
 
921 rajveer 12321 
  def __repr__(self):
12322 
    L = ['%s=%r' % (key, value)
12323 
      for key, value in self.__dict__.iteritems()]
12324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12325 
 
12326 
  def __eq__(self, other):
12327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12328 
 
12329 
  def __ne__(self, other):
12330 
    return not (self == other)
12331 
 
3064 chandransh 12332 
class getOrder_result:
921 rajveer 12333 
  """
12334 
  Attributes:
12335 
   - success
12336 
   - ex
12337 
  """
12338 
 
12339 
  thrift_spec = (
3064 chandransh 12340 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12342 
  )
12343 
 
12344 
  def __init__(self, success=None, ex=None,):
12345 
    self.success = success
12346 
    self.ex = ex
12347 
 
12348 
  def read(self, iprot):
12349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12351 
      return
12352 
    iprot.readStructBegin()
12353 
    while True:
12354 
      (fname, ftype, fid) = iprot.readFieldBegin()
12355 
      if ftype == TType.STOP:
12356 
        break
12357 
      if fid == 0:
3064 chandransh 12358 
        if ftype == TType.STRUCT:
12359 
          self.success = Order()
12360 
          self.success.read(iprot)
921 rajveer 12361 
        else:
12362 
          iprot.skip(ftype)
12363 
      elif fid == 1:
12364 
        if ftype == TType.STRUCT:
12365 
          self.ex = TransactionServiceException()
12366 
          self.ex.read(iprot)
12367 
        else:
12368 
          iprot.skip(ftype)
12369 
      else:
12370 
        iprot.skip(ftype)
12371 
      iprot.readFieldEnd()
12372 
    iprot.readStructEnd()
12373 
 
12374 
  def write(self, oprot):
12375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12377 
      return
3064 chandransh 12378 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12379 
    if self.success is not None:
3064 chandransh 12380 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12381 
      self.success.write(oprot)
921 rajveer 12382 
      oprot.writeFieldEnd()
3431 rajveer 12383 
    if self.ex is not None:
921 rajveer 12384 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12385 
      self.ex.write(oprot)
12386 
      oprot.writeFieldEnd()
12387 
    oprot.writeFieldStop()
12388 
    oprot.writeStructEnd()
12389 
 
3431 rajveer 12390 
  def validate(self):
12391 
    return
12392 
 
12393 
 
921 rajveer 12394 
  def __repr__(self):
12395 
    L = ['%s=%r' % (key, value)
12396 
      for key, value in self.__dict__.iteritems()]
12397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12398 
 
12399 
  def __eq__(self, other):
12400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12401 
 
12402 
  def __ne__(self, other):
12403 
    return not (self == other)
12404 
 
3064 chandransh 12405 
class getLineItemsForOrder_args:
94 ashish 12406 
  """
12407 
  Attributes:
3064 chandransh 12408 
   - orderId
94 ashish 12409 
  """
12410 
 
12411 
  thrift_spec = (
12412 
    None, # 0
3064 chandransh 12413 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12414 
  )
12415 
 
3064 chandransh 12416 
  def __init__(self, orderId=None,):
12417 
    self.orderId = orderId
94 ashish 12418 
 
12419 
  def read(self, iprot):
12420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12422 
      return
12423 
    iprot.readStructBegin()
12424 
    while True:
12425 
      (fname, ftype, fid) = iprot.readFieldBegin()
12426 
      if ftype == TType.STOP:
12427 
        break
12428 
      if fid == 1:
12429 
        if ftype == TType.I64:
3064 chandransh 12430 
          self.orderId = iprot.readI64();
94 ashish 12431 
        else:
12432 
          iprot.skip(ftype)
12433 
      else:
12434 
        iprot.skip(ftype)
12435 
      iprot.readFieldEnd()
12436 
    iprot.readStructEnd()
12437 
 
12438 
  def write(self, oprot):
12439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12441 
      return
3064 chandransh 12442 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12443 
    if self.orderId is not None:
3064 chandransh 12444 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12445 
      oprot.writeI64(self.orderId)
94 ashish 12446 
      oprot.writeFieldEnd()
12447 
    oprot.writeFieldStop()
12448 
    oprot.writeStructEnd()
12449 
 
3431 rajveer 12450 
  def validate(self):
12451 
    return
12452 
 
12453 
 
94 ashish 12454 
  def __repr__(self):
12455 
    L = ['%s=%r' % (key, value)
12456 
      for key, value in self.__dict__.iteritems()]
12457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12458 
 
12459 
  def __eq__(self, other):
12460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12461 
 
12462 
  def __ne__(self, other):
12463 
    return not (self == other)
12464 
 
3064 chandransh 12465 
class getLineItemsForOrder_result:
94 ashish 12466 
  """
12467 
  Attributes:
12468 
   - success
12469 
   - ex
12470 
  """
12471 
 
12472 
  thrift_spec = (
3064 chandransh 12473 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12475 
  )
12476 
 
12477 
  def __init__(self, success=None, ex=None,):
12478 
    self.success = success
12479 
    self.ex = ex
12480 
 
12481 
  def read(self, iprot):
12482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12484 
      return
12485 
    iprot.readStructBegin()
12486 
    while True:
12487 
      (fname, ftype, fid) = iprot.readFieldBegin()
12488 
      if ftype == TType.STOP:
12489 
        break
12490 
      if fid == 0:
483 rajveer 12491 
        if ftype == TType.LIST:
12492 
          self.success = []
6188 rajveer 12493 
          (_etype207, _size204) = iprot.readListBegin()
12494 
          for _i208 in xrange(_size204):
12495 
            _elem209 = LineItem()
12496 
            _elem209.read(iprot)
12497 
            self.success.append(_elem209)
483 rajveer 12498 
          iprot.readListEnd()
94 ashish 12499 
        else:
12500 
          iprot.skip(ftype)
12501 
      elif fid == 1:
12502 
        if ftype == TType.STRUCT:
12503 
          self.ex = TransactionServiceException()
12504 
          self.ex.read(iprot)
12505 
        else:
12506 
          iprot.skip(ftype)
12507 
      else:
12508 
        iprot.skip(ftype)
12509 
      iprot.readFieldEnd()
12510 
    iprot.readStructEnd()
12511 
 
12512 
  def write(self, oprot):
12513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12515 
      return
3064 chandransh 12516 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12517 
    if self.success is not None:
483 rajveer 12518 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12519 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12520 
      for iter210 in self.success:
12521 
        iter210.write(oprot)
483 rajveer 12522 
      oprot.writeListEnd()
94 ashish 12523 
      oprot.writeFieldEnd()
3431 rajveer 12524 
    if self.ex is not None:
94 ashish 12525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12526 
      self.ex.write(oprot)
12527 
      oprot.writeFieldEnd()
12528 
    oprot.writeFieldStop()
12529 
    oprot.writeStructEnd()
12530 
 
3431 rajveer 12531 
  def validate(self):
12532 
    return
12533 
 
12534 
 
94 ashish 12535 
  def __repr__(self):
12536 
    L = ['%s=%r' % (key, value)
12537 
      for key, value in self.__dict__.iteritems()]
12538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12539 
 
12540 
  def __eq__(self, other):
12541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12542 
 
12543 
  def __ne__(self, other):
12544 
    return not (self == other)
12545 
 
4999 phani.kuma 12546 
class getOrderList_args:
12547 
  """
12548 
  Attributes:
12549 
   - order_ids
12550 
  """
12551 
 
12552 
  thrift_spec = (
12553 
    None, # 0
12554 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12555 
  )
12556 
 
12557 
  def __init__(self, order_ids=None,):
12558 
    self.order_ids = order_ids
12559 
 
12560 
  def read(self, iprot):
12561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12563 
      return
12564 
    iprot.readStructBegin()
12565 
    while True:
12566 
      (fname, ftype, fid) = iprot.readFieldBegin()
12567 
      if ftype == TType.STOP:
12568 
        break
12569 
      if fid == 1:
12570 
        if ftype == TType.LIST:
12571 
          self.order_ids = []
6188 rajveer 12572 
          (_etype214, _size211) = iprot.readListBegin()
12573 
          for _i215 in xrange(_size211):
12574 
            _elem216 = iprot.readI64();
12575 
            self.order_ids.append(_elem216)
4999 phani.kuma 12576 
          iprot.readListEnd()
12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      else:
12580 
        iprot.skip(ftype)
12581 
      iprot.readFieldEnd()
12582 
    iprot.readStructEnd()
12583 
 
12584 
  def write(self, oprot):
12585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12587 
      return
12588 
    oprot.writeStructBegin('getOrderList_args')
12589 
    if self.order_ids is not None:
12590 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12591 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12592 
      for iter217 in self.order_ids:
12593 
        oprot.writeI64(iter217)
4999 phani.kuma 12594 
      oprot.writeListEnd()
12595 
      oprot.writeFieldEnd()
12596 
    oprot.writeFieldStop()
12597 
    oprot.writeStructEnd()
12598 
 
12599 
  def validate(self):
12600 
    return
12601 
 
12602 
 
12603 
  def __repr__(self):
12604 
    L = ['%s=%r' % (key, value)
12605 
      for key, value in self.__dict__.iteritems()]
12606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12607 
 
12608 
  def __eq__(self, other):
12609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12610 
 
12611 
  def __ne__(self, other):
12612 
    return not (self == other)
12613 
 
12614 
class getOrderList_result:
12615 
  """
12616 
  Attributes:
12617 
   - success
12618 
  """
12619 
 
12620 
  thrift_spec = (
12621 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12622 
  )
12623 
 
12624 
  def __init__(self, success=None,):
12625 
    self.success = success
12626 
 
12627 
  def read(self, iprot):
12628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12630 
      return
12631 
    iprot.readStructBegin()
12632 
    while True:
12633 
      (fname, ftype, fid) = iprot.readFieldBegin()
12634 
      if ftype == TType.STOP:
12635 
        break
12636 
      if fid == 0:
12637 
        if ftype == TType.LIST:
12638 
          self.success = []
6188 rajveer 12639 
          (_etype221, _size218) = iprot.readListBegin()
12640 
          for _i222 in xrange(_size218):
12641 
            _elem223 = Order()
12642 
            _elem223.read(iprot)
12643 
            self.success.append(_elem223)
4999 phani.kuma 12644 
          iprot.readListEnd()
12645 
        else:
12646 
          iprot.skip(ftype)
12647 
      else:
12648 
        iprot.skip(ftype)
12649 
      iprot.readFieldEnd()
12650 
    iprot.readStructEnd()
12651 
 
12652 
  def write(self, oprot):
12653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12655 
      return
12656 
    oprot.writeStructBegin('getOrderList_result')
12657 
    if self.success is not None:
12658 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12659 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12660 
      for iter224 in self.success:
12661 
        iter224.write(oprot)
4999 phani.kuma 12662 
      oprot.writeListEnd()
12663 
      oprot.writeFieldEnd()
12664 
    oprot.writeFieldStop()
12665 
    oprot.writeStructEnd()
12666 
 
12667 
  def validate(self):
12668 
    return
12669 
 
12670 
 
12671 
  def __repr__(self):
12672 
    L = ['%s=%r' % (key, value)
12673 
      for key, value in self.__dict__.iteritems()]
12674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12675 
 
12676 
  def __eq__(self, other):
12677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12678 
 
12679 
  def __ne__(self, other):
12680 
    return not (self == other)
12681 
 
5386 phani.kuma 12682 
class getOrderListForVendor_args:
12683 
  """
12684 
  Attributes:
12685 
   - order_ids
12686 
   - vendorId
12687 
  """
12688 
 
12689 
  thrift_spec = (
12690 
    None, # 0
12691 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12692 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12693 
  )
12694 
 
12695 
  def __init__(self, order_ids=None, vendorId=None,):
12696 
    self.order_ids = order_ids
12697 
    self.vendorId = vendorId
12698 
 
12699 
  def read(self, iprot):
12700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12702 
      return
12703 
    iprot.readStructBegin()
12704 
    while True:
12705 
      (fname, ftype, fid) = iprot.readFieldBegin()
12706 
      if ftype == TType.STOP:
12707 
        break
12708 
      if fid == 1:
12709 
        if ftype == TType.LIST:
12710 
          self.order_ids = []
6188 rajveer 12711 
          (_etype228, _size225) = iprot.readListBegin()
12712 
          for _i229 in xrange(_size225):
12713 
            _elem230 = iprot.readI64();
12714 
            self.order_ids.append(_elem230)
5386 phani.kuma 12715 
          iprot.readListEnd()
12716 
        else:
12717 
          iprot.skip(ftype)
12718 
      elif fid == 2:
12719 
        if ftype == TType.I64:
12720 
          self.vendorId = iprot.readI64();
12721 
        else:
12722 
          iprot.skip(ftype)
12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
12732 
    oprot.writeStructBegin('getOrderListForVendor_args')
12733 
    if self.order_ids is not None:
12734 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12735 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12736 
      for iter231 in self.order_ids:
12737 
        oprot.writeI64(iter231)
5386 phani.kuma 12738 
      oprot.writeListEnd()
12739 
      oprot.writeFieldEnd()
12740 
    if self.vendorId is not None:
12741 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12742 
      oprot.writeI64(self.vendorId)
12743 
      oprot.writeFieldEnd()
12744 
    oprot.writeFieldStop()
12745 
    oprot.writeStructEnd()
12746 
 
12747 
  def validate(self):
12748 
    return
12749 
 
12750 
 
12751 
  def __repr__(self):
12752 
    L = ['%s=%r' % (key, value)
12753 
      for key, value in self.__dict__.iteritems()]
12754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12755 
 
12756 
  def __eq__(self, other):
12757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12758 
 
12759 
  def __ne__(self, other):
12760 
    return not (self == other)
12761 
 
12762 
class getOrderListForVendor_result:
12763 
  """
12764 
  Attributes:
12765 
   - success
12766 
  """
12767 
 
12768 
  thrift_spec = (
12769 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12770 
  )
12771 
 
12772 
  def __init__(self, success=None,):
12773 
    self.success = success
12774 
 
12775 
  def read(self, iprot):
12776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12778 
      return
12779 
    iprot.readStructBegin()
12780 
    while True:
12781 
      (fname, ftype, fid) = iprot.readFieldBegin()
12782 
      if ftype == TType.STOP:
12783 
        break
12784 
      if fid == 0:
12785 
        if ftype == TType.LIST:
12786 
          self.success = []
6188 rajveer 12787 
          (_etype235, _size232) = iprot.readListBegin()
12788 
          for _i236 in xrange(_size232):
12789 
            _elem237 = Order()
12790 
            _elem237.read(iprot)
12791 
            self.success.append(_elem237)
5386 phani.kuma 12792 
          iprot.readListEnd()
12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
12804 
    oprot.writeStructBegin('getOrderListForVendor_result')
12805 
    if self.success is not None:
12806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12808 
      for iter238 in self.success:
12809 
        iter238.write(oprot)
5386 phani.kuma 12810 
      oprot.writeListEnd()
12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
12829 
 
3064 chandransh 12830 
class getOrderForCustomer_args:
94 ashish 12831 
  """
12832 
  Attributes:
3064 chandransh 12833 
   - orderId
483 rajveer 12834 
   - customerId
94 ashish 12835 
  """
12836 
 
12837 
  thrift_spec = (
12838 
    None, # 0
3064 chandransh 12839 
    (1, TType.I64, 'orderId', None, None, ), # 1
12840 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12841 
  )
12842 
 
3064 chandransh 12843 
  def __init__(self, orderId=None, customerId=None,):
12844 
    self.orderId = orderId
483 rajveer 12845 
    self.customerId = customerId
94 ashish 12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      if fid == 1:
12857 
        if ftype == TType.I64:
3064 chandransh 12858 
          self.orderId = iprot.readI64();
94 ashish 12859 
        else:
12860 
          iprot.skip(ftype)
12861 
      elif fid == 2:
12862 
        if ftype == TType.I64:
3064 chandransh 12863 
          self.customerId = iprot.readI64();
94 ashish 12864 
        else:
12865 
          iprot.skip(ftype)
12866 
      else:
12867 
        iprot.skip(ftype)
12868 
      iprot.readFieldEnd()
12869 
    iprot.readStructEnd()
12870 
 
12871 
  def write(self, oprot):
12872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12874 
      return
3064 chandransh 12875 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12876 
    if self.orderId is not None:
3064 chandransh 12877 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12878 
      oprot.writeI64(self.orderId)
12879 
      oprot.writeFieldEnd()
3431 rajveer 12880 
    if self.customerId is not None:
3064 chandransh 12881 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12882 
      oprot.writeI64(self.customerId)
94 ashish 12883 
      oprot.writeFieldEnd()
12884 
    oprot.writeFieldStop()
12885 
    oprot.writeStructEnd()
12886 
 
3431 rajveer 12887 
  def validate(self):
12888 
    return
12889 
 
12890 
 
94 ashish 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 getOrderForCustomer_result:
94 ashish 12903 
  """
12904 
  Attributes:
12905 
   - success
12906 
   - ex
12907 
  """
12908 
 
12909 
  thrift_spec = (
3064 chandransh 12910 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12911 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12912 
  )
12913 
 
12914 
  def __init__(self, success=None, ex=None,):
12915 
    self.success = success
12916 
    self.ex = ex
12917 
 
12918 
  def read(self, iprot):
12919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12921 
      return
12922 
    iprot.readStructBegin()
12923 
    while True:
12924 
      (fname, ftype, fid) = iprot.readFieldBegin()
12925 
      if ftype == TType.STOP:
12926 
        break
12927 
      if fid == 0:
3064 chandransh 12928 
        if ftype == TType.STRUCT:
12929 
          self.success = Order()
12930 
          self.success.read(iprot)
94 ashish 12931 
        else:
12932 
          iprot.skip(ftype)
12933 
      elif fid == 1:
12934 
        if ftype == TType.STRUCT:
12935 
          self.ex = TransactionServiceException()
12936 
          self.ex.read(iprot)
12937 
        else:
12938 
          iprot.skip(ftype)
12939 
      else:
12940 
        iprot.skip(ftype)
12941 
      iprot.readFieldEnd()
12942 
    iprot.readStructEnd()
12943 
 
12944 
  def write(self, oprot):
12945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12947 
      return
3064 chandransh 12948 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12949 
    if self.success is not None:
3064 chandransh 12950 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12951 
      self.success.write(oprot)
94 ashish 12952 
      oprot.writeFieldEnd()
3431 rajveer 12953 
    if self.ex is not None:
94 ashish 12954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12955 
      self.ex.write(oprot)
12956 
      oprot.writeFieldEnd()
12957 
    oprot.writeFieldStop()
12958 
    oprot.writeStructEnd()
12959 
 
3431 rajveer 12960 
  def validate(self):
12961 
    return
12962 
 
12963 
 
94 ashish 12964 
  def __repr__(self):
12965 
    L = ['%s=%r' % (key, value)
12966 
      for key, value in self.__dict__.iteritems()]
12967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12968 
 
12969 
  def __eq__(self, other):
12970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12971 
 
12972 
  def __ne__(self, other):
12973 
    return not (self == other)
12974 
 
3064 chandransh 12975 
class getAlerts_args:
94 ashish 12976 
  """
12977 
  Attributes:
4394 rajveer 12978 
   - type
4444 rajveer 12979 
   - warehouseId
4394 rajveer 12980 
   - status
12981 
   - timestamp
94 ashish 12982 
  """
12983 
 
12984 
  thrift_spec = (
12985 
    None, # 0
4394 rajveer 12986 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12987 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12988 
    (3, TType.I64, 'status', None, None, ), # 3
12989 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12990 
  )
12991 
 
4444 rajveer 12992 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12993 
    self.type = type
4444 rajveer 12994 
    self.warehouseId = warehouseId
4394 rajveer 12995 
    self.status = status
12996 
    self.timestamp = timestamp
94 ashish 12997 
 
12998 
  def read(self, iprot):
12999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13001 
      return
13002 
    iprot.readStructBegin()
13003 
    while True:
13004 
      (fname, ftype, fid) = iprot.readFieldBegin()
13005 
      if ftype == TType.STOP:
13006 
        break
13007 
      if fid == 1:
3064 chandransh 13008 
        if ftype == TType.I64:
4394 rajveer 13009 
          self.type = iprot.readI64();
94 ashish 13010 
        else:
13011 
          iprot.skip(ftype)
3064 chandransh 13012 
      elif fid == 2:
4394 rajveer 13013 
        if ftype == TType.I64:
4444 rajveer 13014 
          self.warehouseId = iprot.readI64();
3064 chandransh 13015 
        else:
13016 
          iprot.skip(ftype)
4394 rajveer 13017 
      elif fid == 3:
13018 
        if ftype == TType.I64:
4444 rajveer 13019 
          self.status = iprot.readI64();
13020 
        else:
13021 
          iprot.skip(ftype)
13022 
      elif fid == 4:
13023 
        if ftype == TType.I64:
4394 rajveer 13024 
          self.timestamp = iprot.readI64();
13025 
        else:
13026 
          iprot.skip(ftype)
94 ashish 13027 
      else:
13028 
        iprot.skip(ftype)
13029 
      iprot.readFieldEnd()
13030 
    iprot.readStructEnd()
13031 
 
13032 
  def write(self, oprot):
13033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13035 
      return
3064 chandransh 13036 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13037 
    if self.type is not None:
13038 
      oprot.writeFieldBegin('type', TType.I64, 1)
13039 
      oprot.writeI64(self.type)
94 ashish 13040 
      oprot.writeFieldEnd()
4444 rajveer 13041 
    if self.warehouseId is not None:
13042 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13043 
      oprot.writeI64(self.warehouseId)
13044 
      oprot.writeFieldEnd()
4394 rajveer 13045 
    if self.status is not None:
4444 rajveer 13046 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13047 
      oprot.writeI64(self.status)
3064 chandransh 13048 
      oprot.writeFieldEnd()
4394 rajveer 13049 
    if self.timestamp is not None:
4444 rajveer 13050 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13051 
      oprot.writeI64(self.timestamp)
13052 
      oprot.writeFieldEnd()
94 ashish 13053 
    oprot.writeFieldStop()
13054 
    oprot.writeStructEnd()
13055 
 
3431 rajveer 13056 
  def validate(self):
13057 
    return
13058 
 
13059 
 
94 ashish 13060 
  def __repr__(self):
13061 
    L = ['%s=%r' % (key, value)
13062 
      for key, value in self.__dict__.iteritems()]
13063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13064 
 
13065 
  def __eq__(self, other):
13066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13067 
 
13068 
  def __ne__(self, other):
13069 
    return not (self == other)
13070 
 
3064 chandransh 13071 
class getAlerts_result:
94 ashish 13072 
  """
13073 
  Attributes:
13074 
   - success
13075 
  """
13076 
 
13077 
  thrift_spec = (
3064 chandransh 13078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13079 
  )
13080 
 
3064 chandransh 13081 
  def __init__(self, success=None,):
94 ashish 13082 
    self.success = success
13083 
 
13084 
  def read(self, iprot):
13085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13087 
      return
13088 
    iprot.readStructBegin()
13089 
    while True:
13090 
      (fname, ftype, fid) = iprot.readFieldBegin()
13091 
      if ftype == TType.STOP:
13092 
        break
13093 
      if fid == 0:
3064 chandransh 13094 
        if ftype == TType.LIST:
13095 
          self.success = []
6188 rajveer 13096 
          (_etype242, _size239) = iprot.readListBegin()
13097 
          for _i243 in xrange(_size239):
13098 
            _elem244 = Alert()
13099 
            _elem244.read(iprot)
13100 
            self.success.append(_elem244)
3064 chandransh 13101 
          iprot.readListEnd()
94 ashish 13102 
        else:
13103 
          iprot.skip(ftype)
13104 
      else:
13105 
        iprot.skip(ftype)
13106 
      iprot.readFieldEnd()
13107 
    iprot.readStructEnd()
13108 
 
13109 
  def write(self, oprot):
13110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13112 
      return
3064 chandransh 13113 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13114 
    if self.success is not None:
3064 chandransh 13115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13116 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13117 
      for iter245 in self.success:
13118 
        iter245.write(oprot)
3064 chandransh 13119 
      oprot.writeListEnd()
94 ashish 13120 
      oprot.writeFieldEnd()
13121 
    oprot.writeFieldStop()
13122 
    oprot.writeStructEnd()
13123 
 
3431 rajveer 13124 
  def validate(self):
13125 
    return
13126 
 
13127 
 
94 ashish 13128 
  def __repr__(self):
13129 
    L = ['%s=%r' % (key, value)
13130 
      for key, value in self.__dict__.iteritems()]
13131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13132 
 
13133 
  def __eq__(self, other):
13134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13135 
 
13136 
  def __ne__(self, other):
13137 
    return not (self == other)
13138 
 
4394 rajveer 13139 
class addAlert_args:
94 ashish 13140 
  """
13141 
  Attributes:
3064 chandransh 13142 
   - type
4444 rajveer 13143 
   - warehouseId
4394 rajveer 13144 
   - description
94 ashish 13145 
  """
13146 
 
13147 
  thrift_spec = (
13148 
    None, # 0
4394 rajveer 13149 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13150 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13151 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13152 
  )
13153 
 
4444 rajveer 13154 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13155 
    self.type = type
4444 rajveer 13156 
    self.warehouseId = warehouseId
4394 rajveer 13157 
    self.description = description
94 ashish 13158 
 
13159 
  def read(self, iprot):
13160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13162 
      return
13163 
    iprot.readStructBegin()
13164 
    while True:
13165 
      (fname, ftype, fid) = iprot.readFieldBegin()
13166 
      if ftype == TType.STOP:
13167 
        break
13168 
      if fid == 1:
13169 
        if ftype == TType.I64:
4394 rajveer 13170 
          self.type = iprot.readI64();
94 ashish 13171 
        else:
13172 
          iprot.skip(ftype)
3064 chandransh 13173 
      elif fid == 2:
4444 rajveer 13174 
        if ftype == TType.I64:
13175 
          self.warehouseId = iprot.readI64();
13176 
        else:
13177 
          iprot.skip(ftype)
13178 
      elif fid == 3:
3064 chandransh 13179 
        if ftype == TType.STRING:
4394 rajveer 13180 
          self.description = iprot.readString();
3064 chandransh 13181 
        else:
13182 
          iprot.skip(ftype)
94 ashish 13183 
      else:
13184 
        iprot.skip(ftype)
13185 
      iprot.readFieldEnd()
13186 
    iprot.readStructEnd()
13187 
 
13188 
  def write(self, oprot):
13189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13191 
      return
4394 rajveer 13192 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13193 
    if self.type is not None:
4394 rajveer 13194 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13195 
      oprot.writeI64(self.type)
13196 
      oprot.writeFieldEnd()
4444 rajveer 13197 
    if self.warehouseId is not None:
13198 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13199 
      oprot.writeI64(self.warehouseId)
13200 
      oprot.writeFieldEnd()
4394 rajveer 13201 
    if self.description is not None:
4444 rajveer 13202 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13203 
      oprot.writeString(self.description)
3064 chandransh 13204 
      oprot.writeFieldEnd()
94 ashish 13205 
    oprot.writeFieldStop()
13206 
    oprot.writeStructEnd()
13207 
 
3431 rajveer 13208 
  def validate(self):
13209 
    return
13210 
 
13211 
 
94 ashish 13212 
  def __repr__(self):
13213 
    L = ['%s=%r' % (key, value)
13214 
      for key, value in self.__dict__.iteritems()]
13215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13216 
 
13217 
  def __eq__(self, other):
13218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13219 
 
13220 
  def __ne__(self, other):
13221 
    return not (self == other)
13222 
 
4394 rajveer 13223 
class addAlert_result:
3064 chandransh 13224 
 
13225 
  thrift_spec = (
13226 
  )
13227 
 
13228 
  def read(self, iprot):
13229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13231 
      return
13232 
    iprot.readStructBegin()
13233 
    while True:
13234 
      (fname, ftype, fid) = iprot.readFieldBegin()
13235 
      if ftype == TType.STOP:
13236 
        break
13237 
      else:
13238 
        iprot.skip(ftype)
13239 
      iprot.readFieldEnd()
13240 
    iprot.readStructEnd()
13241 
 
13242 
  def write(self, oprot):
13243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13245 
      return
4394 rajveer 13246 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13247 
    oprot.writeFieldStop()
13248 
    oprot.writeStructEnd()
13249 
 
3431 rajveer 13250 
  def validate(self):
13251 
    return
13252 
 
13253 
 
3064 chandransh 13254 
  def __repr__(self):
13255 
    L = ['%s=%r' % (key, value)
13256 
      for key, value in self.__dict__.iteritems()]
13257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13258 
 
13259 
  def __eq__(self, other):
13260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13261 
 
13262 
  def __ne__(self, other):
13263 
    return not (self == other)
13264 
 
4444 rajveer 13265 
class markAlertsAsSeen_args:
13266 
  """
13267 
  Attributes:
13268 
   - warehouseId
13269 
  """
13270 
 
13271 
  thrift_spec = (
13272 
    None, # 0
13273 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13274 
  )
13275 
 
13276 
  def __init__(self, warehouseId=None,):
13277 
    self.warehouseId = warehouseId
13278 
 
13279 
  def read(self, iprot):
13280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13282 
      return
13283 
    iprot.readStructBegin()
13284 
    while True:
13285 
      (fname, ftype, fid) = iprot.readFieldBegin()
13286 
      if ftype == TType.STOP:
13287 
        break
13288 
      if fid == 1:
13289 
        if ftype == TType.I64:
13290 
          self.warehouseId = iprot.readI64();
13291 
        else:
13292 
          iprot.skip(ftype)
13293 
      else:
13294 
        iprot.skip(ftype)
13295 
      iprot.readFieldEnd()
13296 
    iprot.readStructEnd()
13297 
 
13298 
  def write(self, oprot):
13299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13301 
      return
13302 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13303 
    if self.warehouseId is not None:
13304 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13305 
      oprot.writeI64(self.warehouseId)
13306 
      oprot.writeFieldEnd()
13307 
    oprot.writeFieldStop()
13308 
    oprot.writeStructEnd()
13309 
 
13310 
  def validate(self):
13311 
    return
13312 
 
13313 
 
13314 
  def __repr__(self):
13315 
    L = ['%s=%r' % (key, value)
13316 
      for key, value in self.__dict__.iteritems()]
13317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13318 
 
13319 
  def __eq__(self, other):
13320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13321 
 
13322 
  def __ne__(self, other):
13323 
    return not (self == other)
13324 
 
13325 
class markAlertsAsSeen_result:
13326 
 
13327 
  thrift_spec = (
13328 
  )
13329 
 
13330 
  def read(self, iprot):
13331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13333 
      return
13334 
    iprot.readStructBegin()
13335 
    while True:
13336 
      (fname, ftype, fid) = iprot.readFieldBegin()
13337 
      if ftype == TType.STOP:
13338 
        break
13339 
      else:
13340 
        iprot.skip(ftype)
13341 
      iprot.readFieldEnd()
13342 
    iprot.readStructEnd()
13343 
 
13344 
  def write(self, oprot):
13345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13347 
      return
13348 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13349 
    oprot.writeFieldStop()
13350 
    oprot.writeStructEnd()
13351 
 
13352 
  def validate(self):
13353 
    return
13354 
 
13355 
 
13356 
  def __repr__(self):
13357 
    L = ['%s=%r' % (key, value)
13358 
      for key, value in self.__dict__.iteritems()]
13359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13360 
 
13361 
  def __eq__(self, other):
13362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13363 
 
13364 
  def __ne__(self, other):
13365 
    return not (self == other)
13366 
 
3064 chandransh 13367 
class getValidOrderCount_args:
13368 
 
13369 
  thrift_spec = (
13370 
  )
13371 
 
13372 
  def read(self, iprot):
13373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13375 
      return
13376 
    iprot.readStructBegin()
13377 
    while True:
13378 
      (fname, ftype, fid) = iprot.readFieldBegin()
13379 
      if ftype == TType.STOP:
13380 
        break
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('getValidOrderCount_args')
13391 
    oprot.writeFieldStop()
13392 
    oprot.writeStructEnd()
13393 
 
3431 rajveer 13394 
  def validate(self):
13395 
    return
13396 
 
13397 
 
3064 chandransh 13398 
  def __repr__(self):
13399 
    L = ['%s=%r' % (key, value)
13400 
      for key, value in self.__dict__.iteritems()]
13401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13402 
 
13403 
  def __eq__(self, other):
13404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13405 
 
13406 
  def __ne__(self, other):
13407 
    return not (self == other)
13408 
 
13409 
class getValidOrderCount_result:
94 ashish 13410 
  """
13411 
  Attributes:
13412 
   - success
13413 
  """
13414 
 
13415 
  thrift_spec = (
3064 chandransh 13416 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13417 
  )
13418 
 
3064 chandransh 13419 
  def __init__(self, success=None,):
94 ashish 13420 
    self.success = success
13421 
 
13422 
  def read(self, iprot):
13423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13425 
      return
13426 
    iprot.readStructBegin()
13427 
    while True:
13428 
      (fname, ftype, fid) = iprot.readFieldBegin()
13429 
      if ftype == TType.STOP:
13430 
        break
13431 
      if fid == 0:
3064 chandransh 13432 
        if ftype == TType.I64:
13433 
          self.success = iprot.readI64();
94 ashish 13434 
        else:
13435 
          iprot.skip(ftype)
13436 
      else:
13437 
        iprot.skip(ftype)
13438 
      iprot.readFieldEnd()
13439 
    iprot.readStructEnd()
13440 
 
13441 
  def write(self, oprot):
13442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13444 
      return
3064 chandransh 13445 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13446 
    if self.success is not None:
3064 chandransh 13447 
      oprot.writeFieldBegin('success', TType.I64, 0)
13448 
      oprot.writeI64(self.success)
94 ashish 13449 
      oprot.writeFieldEnd()
13450 
    oprot.writeFieldStop()
13451 
    oprot.writeStructEnd()
13452 
 
3431 rajveer 13453 
  def validate(self):
13454 
    return
13455 
 
13456 
 
94 ashish 13457 
  def __repr__(self):
13458 
    L = ['%s=%r' % (key, value)
13459 
      for key, value in self.__dict__.iteritems()]
13460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13461 
 
13462 
  def __eq__(self, other):
13463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13464 
 
13465 
  def __ne__(self, other):
13466 
    return not (self == other)
13467 
 
3064 chandransh 13468 
class getNoOfCustomersWithSuccessfulTransaction_args:
13469 
 
13470 
  thrift_spec = (
13471 
  )
13472 
 
13473 
  def read(self, iprot):
13474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13476 
      return
13477 
    iprot.readStructBegin()
13478 
    while True:
13479 
      (fname, ftype, fid) = iprot.readFieldBegin()
13480 
      if ftype == TType.STOP:
13481 
        break
13482 
      else:
13483 
        iprot.skip(ftype)
13484 
      iprot.readFieldEnd()
13485 
    iprot.readStructEnd()
13486 
 
13487 
  def write(self, oprot):
13488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13490 
      return
13491 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13492 
    oprot.writeFieldStop()
13493 
    oprot.writeStructEnd()
13494 
 
3431 rajveer 13495 
  def validate(self):
13496 
    return
13497 
 
13498 
 
3064 chandransh 13499 
  def __repr__(self):
13500 
    L = ['%s=%r' % (key, value)
13501 
      for key, value in self.__dict__.iteritems()]
13502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13503 
 
13504 
  def __eq__(self, other):
13505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13506 
 
13507 
  def __ne__(self, other):
13508 
    return not (self == other)
13509 
 
13510 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13511 
  """
13512 
  Attributes:
3064 chandransh 13513 
   - success
94 ashish 13514 
  """
13515 
 
13516 
  thrift_spec = (
3064 chandransh 13517 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13518 
  )
13519 
 
3064 chandransh 13520 
  def __init__(self, success=None,):
13521 
    self.success = success
94 ashish 13522 
 
13523 
  def read(self, iprot):
13524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13526 
      return
13527 
    iprot.readStructBegin()
13528 
    while True:
13529 
      (fname, ftype, fid) = iprot.readFieldBegin()
13530 
      if ftype == TType.STOP:
13531 
        break
3064 chandransh 13532 
      if fid == 0:
94 ashish 13533 
        if ftype == TType.I64:
3064 chandransh 13534 
          self.success = iprot.readI64();
94 ashish 13535 
        else:
13536 
          iprot.skip(ftype)
13537 
      else:
13538 
        iprot.skip(ftype)
13539 
      iprot.readFieldEnd()
13540 
    iprot.readStructEnd()
13541 
 
13542 
  def write(self, oprot):
13543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13545 
      return
3064 chandransh 13546 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13547 
    if self.success is not None:
3064 chandransh 13548 
      oprot.writeFieldBegin('success', TType.I64, 0)
13549 
      oprot.writeI64(self.success)
94 ashish 13550 
      oprot.writeFieldEnd()
13551 
    oprot.writeFieldStop()
13552 
    oprot.writeStructEnd()
13553 
 
3431 rajveer 13554 
  def validate(self):
13555 
    return
13556 
 
13557 
 
94 ashish 13558 
  def __repr__(self):
13559 
    L = ['%s=%r' % (key, value)
13560 
      for key, value in self.__dict__.iteritems()]
13561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13562 
 
13563 
  def __eq__(self, other):
13564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13565 
 
13566 
  def __ne__(self, other):
13567 
    return not (self == other)
13568 
 
3064 chandransh 13569 
class getValidOrdersAmountRange_args:
13570 
 
13571 
  thrift_spec = (
13572 
  )
13573 
 
13574 
  def read(self, iprot):
13575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13577 
      return
13578 
    iprot.readStructBegin()
13579 
    while True:
13580 
      (fname, ftype, fid) = iprot.readFieldBegin()
13581 
      if ftype == TType.STOP:
13582 
        break
13583 
      else:
13584 
        iprot.skip(ftype)
13585 
      iprot.readFieldEnd()
13586 
    iprot.readStructEnd()
13587 
 
13588 
  def write(self, oprot):
13589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13591 
      return
13592 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13593 
    oprot.writeFieldStop()
13594 
    oprot.writeStructEnd()
13595 
 
3431 rajveer 13596 
  def validate(self):
13597 
    return
13598 
 
13599 
 
3064 chandransh 13600 
  def __repr__(self):
13601 
    L = ['%s=%r' % (key, value)
13602 
      for key, value in self.__dict__.iteritems()]
13603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13604 
 
13605 
  def __eq__(self, other):
13606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13607 
 
13608 
  def __ne__(self, other):
13609 
    return not (self == other)
13610 
 
13611 
class getValidOrdersAmountRange_result:
94 ashish 13612 
  """
13613 
  Attributes:
13614 
   - success
13615 
  """
13616 
 
13617 
  thrift_spec = (
3064 chandransh 13618 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13619 
  )
13620 
 
3064 chandransh 13621 
  def __init__(self, success=None,):
94 ashish 13622 
    self.success = success
13623 
 
13624 
  def read(self, iprot):
13625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13627 
      return
13628 
    iprot.readStructBegin()
13629 
    while True:
13630 
      (fname, ftype, fid) = iprot.readFieldBegin()
13631 
      if ftype == TType.STOP:
13632 
        break
13633 
      if fid == 0:
483 rajveer 13634 
        if ftype == TType.LIST:
13635 
          self.success = []
6188 rajveer 13636 
          (_etype249, _size246) = iprot.readListBegin()
13637 
          for _i250 in xrange(_size246):
13638 
            _elem251 = iprot.readDouble();
13639 
            self.success.append(_elem251)
483 rajveer 13640 
          iprot.readListEnd()
94 ashish 13641 
        else:
13642 
          iprot.skip(ftype)
13643 
      else:
13644 
        iprot.skip(ftype)
13645 
      iprot.readFieldEnd()
13646 
    iprot.readStructEnd()
13647 
 
13648 
  def write(self, oprot):
13649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13651 
      return
3064 chandransh 13652 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13653 
    if self.success is not None:
483 rajveer 13654 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13655 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13656 
      for iter252 in self.success:
13657 
        oprot.writeDouble(iter252)
483 rajveer 13658 
      oprot.writeListEnd()
94 ashish 13659 
      oprot.writeFieldEnd()
13660 
    oprot.writeFieldStop()
13661 
    oprot.writeStructEnd()
13662 
 
3431 rajveer 13663 
  def validate(self):
13664 
    return
13665 
 
13666 
 
94 ashish 13667 
  def __repr__(self):
13668 
    L = ['%s=%r' % (key, value)
13669 
      for key, value in self.__dict__.iteritems()]
13670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13671 
 
13672 
  def __eq__(self, other):
13673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13674 
 
13675 
  def __ne__(self, other):
13676 
    return not (self == other)
13677 
 
3064 chandransh 13678 
class getValidOrders_args:
1528 ankur.sing 13679 
  """
13680 
  Attributes:
3064 chandransh 13681 
   - limit
5874 rajveer 13682 
   - onlyStore
1528 ankur.sing 13683 
  """
13684 
 
13685 
  thrift_spec = (
13686 
    None, # 0
3064 chandransh 13687 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13688 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13689 
  )
13690 
 
5874 rajveer 13691 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13692 
    self.limit = limit
5874 rajveer 13693 
    self.onlyStore = onlyStore
1528 ankur.sing 13694 
 
13695 
  def read(self, iprot):
13696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13698 
      return
13699 
    iprot.readStructBegin()
13700 
    while True:
13701 
      (fname, ftype, fid) = iprot.readFieldBegin()
13702 
      if ftype == TType.STOP:
13703 
        break
13704 
      if fid == 1:
13705 
        if ftype == TType.I64:
3064 chandransh 13706 
          self.limit = iprot.readI64();
1528 ankur.sing 13707 
        else:
13708 
          iprot.skip(ftype)
5874 rajveer 13709 
      elif fid == 2:
13710 
        if ftype == TType.BOOL:
13711 
          self.onlyStore = iprot.readBool();
13712 
        else:
13713 
          iprot.skip(ftype)
1528 ankur.sing 13714 
      else:
13715 
        iprot.skip(ftype)
13716 
      iprot.readFieldEnd()
13717 
    iprot.readStructEnd()
13718 
 
13719 
  def write(self, oprot):
13720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13722 
      return
3064 chandransh 13723 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13724 
    if self.limit is not None:
3064 chandransh 13725 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13726 
      oprot.writeI64(self.limit)
1528 ankur.sing 13727 
      oprot.writeFieldEnd()
5874 rajveer 13728 
    if self.onlyStore is not None:
13729 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13730 
      oprot.writeBool(self.onlyStore)
13731 
      oprot.writeFieldEnd()
1528 ankur.sing 13732 
    oprot.writeFieldStop()
13733 
    oprot.writeStructEnd()
13734 
 
3431 rajveer 13735 
  def validate(self):
13736 
    return
13737 
 
13738 
 
1528 ankur.sing 13739 
  def __repr__(self):
13740 
    L = ['%s=%r' % (key, value)
13741 
      for key, value in self.__dict__.iteritems()]
13742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13743 
 
13744 
  def __eq__(self, other):
13745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13746 
 
13747 
  def __ne__(self, other):
13748 
    return not (self == other)
13749 
 
3064 chandransh 13750 
class getValidOrders_result:
1528 ankur.sing 13751 
  """
13752 
  Attributes:
13753 
   - success
13754 
  """
13755 
 
13756 
  thrift_spec = (
3064 chandransh 13757 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13758 
  )
13759 
 
3064 chandransh 13760 
  def __init__(self, success=None,):
1528 ankur.sing 13761 
    self.success = success
13762 
 
13763 
  def read(self, iprot):
13764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13766 
      return
13767 
    iprot.readStructBegin()
13768 
    while True:
13769 
      (fname, ftype, fid) = iprot.readFieldBegin()
13770 
      if ftype == TType.STOP:
13771 
        break
13772 
      if fid == 0:
3064 chandransh 13773 
        if ftype == TType.LIST:
13774 
          self.success = []
6188 rajveer 13775 
          (_etype256, _size253) = iprot.readListBegin()
13776 
          for _i257 in xrange(_size253):
13777 
            _elem258 = Order()
13778 
            _elem258.read(iprot)
13779 
            self.success.append(_elem258)
3064 chandransh 13780 
          iprot.readListEnd()
1528 ankur.sing 13781 
        else:
13782 
          iprot.skip(ftype)
13783 
      else:
13784 
        iprot.skip(ftype)
13785 
      iprot.readFieldEnd()
13786 
    iprot.readStructEnd()
13787 
 
13788 
  def write(self, oprot):
13789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13791 
      return
3064 chandransh 13792 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13793 
    if self.success is not None:
3064 chandransh 13794 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13795 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13796 
      for iter259 in self.success:
13797 
        iter259.write(oprot)
3064 chandransh 13798 
      oprot.writeListEnd()
1528 ankur.sing 13799 
      oprot.writeFieldEnd()
13800 
    oprot.writeFieldStop()
13801 
    oprot.writeStructEnd()
13802 
 
3431 rajveer 13803 
  def validate(self):
13804 
    return
13805 
 
13806 
 
1528 ankur.sing 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 
 
1220 chandransh 13818 
class batchOrders_args:
13819 
  """
13820 
  Attributes:
13821 
   - warehouseId
13822 
  """
13823 
 
13824 
  thrift_spec = (
13825 
    None, # 0
13826 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13827 
  )
13828 
 
13829 
  def __init__(self, warehouseId=None,):
13830 
    self.warehouseId = warehouseId
13831 
 
13832 
  def read(self, iprot):
13833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13835 
      return
13836 
    iprot.readStructBegin()
13837 
    while True:
13838 
      (fname, ftype, fid) = iprot.readFieldBegin()
13839 
      if ftype == TType.STOP:
13840 
        break
13841 
      if fid == 1:
13842 
        if ftype == TType.I64:
13843 
          self.warehouseId = iprot.readI64();
13844 
        else:
13845 
          iprot.skip(ftype)
13846 
      else:
13847 
        iprot.skip(ftype)
13848 
      iprot.readFieldEnd()
13849 
    iprot.readStructEnd()
13850 
 
13851 
  def write(self, oprot):
13852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13854 
      return
13855 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13856 
    if self.warehouseId is not None:
1220 chandransh 13857 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13858 
      oprot.writeI64(self.warehouseId)
13859 
      oprot.writeFieldEnd()
13860 
    oprot.writeFieldStop()
13861 
    oprot.writeStructEnd()
13862 
 
3431 rajveer 13863 
  def validate(self):
13864 
    return
13865 
 
13866 
 
1220 chandransh 13867 
  def __repr__(self):
13868 
    L = ['%s=%r' % (key, value)
13869 
      for key, value in self.__dict__.iteritems()]
13870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13871 
 
13872 
  def __eq__(self, other):
13873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13874 
 
13875 
  def __ne__(self, other):
13876 
    return not (self == other)
13877 
 
13878 
class batchOrders_result:
13879 
  """
13880 
  Attributes:
13881 
   - success
13882 
   - ex
13883 
  """
13884 
 
13885 
  thrift_spec = (
13886 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13887 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13888 
  )
13889 
 
13890 
  def __init__(self, success=None, ex=None,):
13891 
    self.success = success
13892 
    self.ex = ex
13893 
 
13894 
  def read(self, iprot):
13895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13897 
      return
13898 
    iprot.readStructBegin()
13899 
    while True:
13900 
      (fname, ftype, fid) = iprot.readFieldBegin()
13901 
      if ftype == TType.STOP:
13902 
        break
13903 
      if fid == 0:
13904 
        if ftype == TType.LIST:
13905 
          self.success = []
6188 rajveer 13906 
          (_etype263, _size260) = iprot.readListBegin()
13907 
          for _i264 in xrange(_size260):
13908 
            _elem265 = Order()
13909 
            _elem265.read(iprot)
13910 
            self.success.append(_elem265)
1220 chandransh 13911 
          iprot.readListEnd()
13912 
        else:
13913 
          iprot.skip(ftype)
13914 
      elif fid == 1:
13915 
        if ftype == TType.STRUCT:
13916 
          self.ex = TransactionServiceException()
13917 
          self.ex.read(iprot)
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
13929 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13930 
    if self.success is not None:
1220 chandransh 13931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13933 
      for iter266 in self.success:
13934 
        iter266.write(oprot)
1220 chandransh 13935 
      oprot.writeListEnd()
13936 
      oprot.writeFieldEnd()
3431 rajveer 13937 
    if self.ex is not None:
1220 chandransh 13938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13939 
      self.ex.write(oprot)
13940 
      oprot.writeFieldEnd()
13941 
    oprot.writeFieldStop()
13942 
    oprot.writeStructEnd()
13943 
 
3431 rajveer 13944 
  def validate(self):
13945 
    return
13946 
 
13947 
 
1220 chandransh 13948 
  def __repr__(self):
13949 
    L = ['%s=%r' % (key, value)
13950 
      for key, value in self.__dict__.iteritems()]
13951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13952 
 
13953 
  def __eq__(self, other):
13954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13955 
 
13956 
  def __ne__(self, other):
13957 
    return not (self == other)
13958 
 
1208 chandransh 13959 
class markOrderAsOutOfStock_args:
13960 
  """
13961 
  Attributes:
13962 
   - orderId
13963 
  """
13964 
 
13965 
  thrift_spec = (
13966 
    None, # 0
13967 
    (1, TType.I64, 'orderId', None, None, ), # 1
13968 
  )
13969 
 
13970 
  def __init__(self, orderId=None,):
13971 
    self.orderId = orderId
13972 
 
13973 
  def read(self, iprot):
13974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13976 
      return
13977 
    iprot.readStructBegin()
13978 
    while True:
13979 
      (fname, ftype, fid) = iprot.readFieldBegin()
13980 
      if ftype == TType.STOP:
13981 
        break
13982 
      if fid == 1:
13983 
        if ftype == TType.I64:
13984 
          self.orderId = iprot.readI64();
13985 
        else:
13986 
          iprot.skip(ftype)
13987 
      else:
13988 
        iprot.skip(ftype)
13989 
      iprot.readFieldEnd()
13990 
    iprot.readStructEnd()
13991 
 
13992 
  def write(self, oprot):
13993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13995 
      return
13996 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13997 
    if self.orderId is not None:
1208 chandransh 13998 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13999 
      oprot.writeI64(self.orderId)
14000 
      oprot.writeFieldEnd()
14001 
    oprot.writeFieldStop()
14002 
    oprot.writeStructEnd()
14003 
 
3431 rajveer 14004 
  def validate(self):
14005 
    return
14006 
 
14007 
 
1208 chandransh 14008 
  def __repr__(self):
14009 
    L = ['%s=%r' % (key, value)
14010 
      for key, value in self.__dict__.iteritems()]
14011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14012 
 
14013 
  def __eq__(self, other):
14014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14015 
 
14016 
  def __ne__(self, other):
14017 
    return not (self == other)
14018 
 
14019 
class markOrderAsOutOfStock_result:
14020 
  """
14021 
  Attributes:
14022 
   - success
14023 
   - ex
14024 
  """
14025 
 
14026 
  thrift_spec = (
14027 
    (0, TType.BOOL, 'success', None, None, ), # 0
14028 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14029 
  )
14030 
 
14031 
  def __init__(self, success=None, ex=None,):
14032 
    self.success = success
14033 
    self.ex = ex
14034 
 
14035 
  def read(self, iprot):
14036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14038 
      return
14039 
    iprot.readStructBegin()
14040 
    while True:
14041 
      (fname, ftype, fid) = iprot.readFieldBegin()
14042 
      if ftype == TType.STOP:
14043 
        break
14044 
      if fid == 0:
14045 
        if ftype == TType.BOOL:
14046 
          self.success = iprot.readBool();
14047 
        else:
14048 
          iprot.skip(ftype)
14049 
      elif fid == 1:
14050 
        if ftype == TType.STRUCT:
14051 
          self.ex = TransactionServiceException()
14052 
          self.ex.read(iprot)
14053 
        else:
14054 
          iprot.skip(ftype)
14055 
      else:
14056 
        iprot.skip(ftype)
14057 
      iprot.readFieldEnd()
14058 
    iprot.readStructEnd()
14059 
 
14060 
  def write(self, oprot):
14061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14063 
      return
14064 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14065 
    if self.success is not None:
1208 chandransh 14066 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14067 
      oprot.writeBool(self.success)
14068 
      oprot.writeFieldEnd()
3431 rajveer 14069 
    if self.ex is not None:
1208 chandransh 14070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14071 
      self.ex.write(oprot)
14072 
      oprot.writeFieldEnd()
14073 
    oprot.writeFieldStop()
14074 
    oprot.writeStructEnd()
14075 
 
3431 rajveer 14076 
  def validate(self):
14077 
    return
14078 
 
14079 
 
1208 chandransh 14080 
  def __repr__(self):
14081 
    L = ['%s=%r' % (key, value)
14082 
      for key, value in self.__dict__.iteritems()]
14083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14084 
 
14085 
  def __eq__(self, other):
14086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14087 
 
14088 
  def __ne__(self, other):
14089 
    return not (self == other)
14090 
 
3064 chandransh 14091 
class verifyOrder_args:
759 chandransh 14092 
  """
14093 
  Attributes:
3064 chandransh 14094 
   - orderId
759 chandransh 14095 
  """
14096 
 
14097 
  thrift_spec = (
14098 
    None, # 0
3064 chandransh 14099 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14100 
  )
14101 
 
3064 chandransh 14102 
  def __init__(self, orderId=None,):
14103 
    self.orderId = orderId
759 chandransh 14104 
 
14105 
  def read(self, iprot):
14106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14108 
      return
14109 
    iprot.readStructBegin()
14110 
    while True:
14111 
      (fname, ftype, fid) = iprot.readFieldBegin()
14112 
      if ftype == TType.STOP:
14113 
        break
14114 
      if fid == 1:
14115 
        if ftype == TType.I64:
3064 chandransh 14116 
          self.orderId = iprot.readI64();
759 chandransh 14117 
        else:
14118 
          iprot.skip(ftype)
14119 
      else:
14120 
        iprot.skip(ftype)
14121 
      iprot.readFieldEnd()
14122 
    iprot.readStructEnd()
14123 
 
14124 
  def write(self, oprot):
14125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14127 
      return
3064 chandransh 14128 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14129 
    if self.orderId is not None:
3064 chandransh 14130 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14131 
      oprot.writeI64(self.orderId)
759 chandransh 14132 
      oprot.writeFieldEnd()
14133 
    oprot.writeFieldStop()
14134 
    oprot.writeStructEnd()
14135 
 
3431 rajveer 14136 
  def validate(self):
14137 
    return
14138 
 
14139 
 
759 chandransh 14140 
  def __repr__(self):
14141 
    L = ['%s=%r' % (key, value)
14142 
      for key, value in self.__dict__.iteritems()]
14143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14144 
 
14145 
  def __eq__(self, other):
14146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14147 
 
14148 
  def __ne__(self, other):
14149 
    return not (self == other)
14150 
 
3064 chandransh 14151 
class verifyOrder_result:
759 chandransh 14152 
  """
14153 
  Attributes:
14154 
   - success
14155 
   - ex
14156 
  """
14157 
 
14158 
  thrift_spec = (
14159 
    (0, TType.BOOL, 'success', None, None, ), # 0
14160 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14161 
  )
14162 
 
14163 
  def __init__(self, success=None, ex=None,):
14164 
    self.success = success
14165 
    self.ex = ex
14166 
 
14167 
  def read(self, iprot):
14168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14170 
      return
14171 
    iprot.readStructBegin()
14172 
    while True:
14173 
      (fname, ftype, fid) = iprot.readFieldBegin()
14174 
      if ftype == TType.STOP:
14175 
        break
14176 
      if fid == 0:
14177 
        if ftype == TType.BOOL:
14178 
          self.success = iprot.readBool();
14179 
        else:
14180 
          iprot.skip(ftype)
14181 
      elif fid == 1:
14182 
        if ftype == TType.STRUCT:
14183 
          self.ex = TransactionServiceException()
14184 
          self.ex.read(iprot)
14185 
        else:
14186 
          iprot.skip(ftype)
14187 
      else:
14188 
        iprot.skip(ftype)
14189 
      iprot.readFieldEnd()
14190 
    iprot.readStructEnd()
14191 
 
14192 
  def write(self, oprot):
14193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14195 
      return
3064 chandransh 14196 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14197 
    if self.success is not None:
759 chandransh 14198 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14199 
      oprot.writeBool(self.success)
14200 
      oprot.writeFieldEnd()
3431 rajveer 14201 
    if self.ex is not None:
759 chandransh 14202 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14203 
      self.ex.write(oprot)
14204 
      oprot.writeFieldEnd()
14205 
    oprot.writeFieldStop()
14206 
    oprot.writeStructEnd()
14207 
 
3431 rajveer 14208 
  def validate(self):
14209 
    return
14210 
 
14211 
 
759 chandransh 14212 
  def __repr__(self):
14213 
    L = ['%s=%r' % (key, value)
14214 
      for key, value in self.__dict__.iteritems()]
14215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14216 
 
14217 
  def __eq__(self, other):
14218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14219 
 
14220 
  def __ne__(self, other):
14221 
    return not (self == other)
14222 
 
3064 chandransh 14223 
class acceptOrder_args:
1113 chandransh 14224 
  """
14225 
  Attributes:
3064 chandransh 14226 
   - orderId
1113 chandransh 14227 
  """
14228 
 
14229 
  thrift_spec = (
14230 
    None, # 0
3064 chandransh 14231 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14232 
  )
14233 
 
3064 chandransh 14234 
  def __init__(self, orderId=None,):
14235 
    self.orderId = orderId
1113 chandransh 14236 
 
14237 
  def read(self, iprot):
14238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14240 
      return
14241 
    iprot.readStructBegin()
14242 
    while True:
14243 
      (fname, ftype, fid) = iprot.readFieldBegin()
14244 
      if ftype == TType.STOP:
14245 
        break
14246 
      if fid == 1:
14247 
        if ftype == TType.I64:
3064 chandransh 14248 
          self.orderId = iprot.readI64();
1113 chandransh 14249 
        else:
14250 
          iprot.skip(ftype)
14251 
      else:
14252 
        iprot.skip(ftype)
14253 
      iprot.readFieldEnd()
14254 
    iprot.readStructEnd()
14255 
 
14256 
  def write(self, oprot):
14257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14259 
      return
3064 chandransh 14260 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14261 
    if self.orderId is not None:
3064 chandransh 14262 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14263 
      oprot.writeI64(self.orderId)
1113 chandransh 14264 
      oprot.writeFieldEnd()
14265 
    oprot.writeFieldStop()
14266 
    oprot.writeStructEnd()
14267 
 
3431 rajveer 14268 
  def validate(self):
14269 
    return
14270 
 
14271 
 
1113 chandransh 14272 
  def __repr__(self):
14273 
    L = ['%s=%r' % (key, value)
14274 
      for key, value in self.__dict__.iteritems()]
14275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14276 
 
14277 
  def __eq__(self, other):
14278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14279 
 
14280 
  def __ne__(self, other):
14281 
    return not (self == other)
14282 
 
3064 chandransh 14283 
class acceptOrder_result:
1113 chandransh 14284 
  """
14285 
  Attributes:
14286 
   - success
14287 
   - ex
14288 
  """
14289 
 
14290 
  thrift_spec = (
3064 chandransh 14291 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14293 
  )
14294 
 
14295 
  def __init__(self, success=None, ex=None,):
14296 
    self.success = success
14297 
    self.ex = ex
14298 
 
14299 
  def read(self, iprot):
14300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14302 
      return
14303 
    iprot.readStructBegin()
14304 
    while True:
14305 
      (fname, ftype, fid) = iprot.readFieldBegin()
14306 
      if ftype == TType.STOP:
14307 
        break
14308 
      if fid == 0:
3064 chandransh 14309 
        if ftype == TType.BOOL:
14310 
          self.success = iprot.readBool();
1113 chandransh 14311 
        else:
14312 
          iprot.skip(ftype)
14313 
      elif fid == 1:
14314 
        if ftype == TType.STRUCT:
14315 
          self.ex = TransactionServiceException()
14316 
          self.ex.read(iprot)
14317 
        else:
14318 
          iprot.skip(ftype)
14319 
      else:
14320 
        iprot.skip(ftype)
14321 
      iprot.readFieldEnd()
14322 
    iprot.readStructEnd()
14323 
 
14324 
  def write(self, oprot):
14325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14327 
      return
3064 chandransh 14328 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14329 
    if self.success is not None:
3064 chandransh 14330 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14331 
      oprot.writeBool(self.success)
1113 chandransh 14332 
      oprot.writeFieldEnd()
3431 rajveer 14333 
    if self.ex is not None:
1113 chandransh 14334 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14335 
      self.ex.write(oprot)
14336 
      oprot.writeFieldEnd()
14337 
    oprot.writeFieldStop()
14338 
    oprot.writeStructEnd()
14339 
 
3431 rajveer 14340 
  def validate(self):
14341 
    return
14342 
 
14343 
 
1113 chandransh 14344 
  def __repr__(self):
14345 
    L = ['%s=%r' % (key, value)
14346 
      for key, value in self.__dict__.iteritems()]
14347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14348 
 
14349 
  def __eq__(self, other):
14350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14351 
 
14352 
  def __ne__(self, other):
14353 
    return not (self == other)
14354 
 
3064 chandransh 14355 
class addBillingDetails_args:
1135 chandransh 14356 
  """
14357 
  Attributes:
3064 chandransh 14358 
   - orderId
14359 
   - invoice_number
4658 mandeep.dh 14360 
   - serialNumber
4283 anupam.sin 14361 
   - itemNumber
3064 chandransh 14362 
   - billed_by
4264 rajveer 14363 
   - jacketNumber
4283 anupam.sin 14364 
   - billingType
5110 mandeep.dh 14365 
   - fulfilmentWarehouseId
4763 rajveer 14366 
   - authorize
1135 chandransh 14367 
  """
14368 
 
14369 
  thrift_spec = (
14370 
    None, # 0
3064 chandransh 14371 
    (1, TType.I64, 'orderId', None, None, ), # 1
14372 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14373 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14374 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 14375 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
14376 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
14377 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 14378 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 14379 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 14380 
  )
14381 
 
5110 mandeep.dh 14382 
  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 14383 
    self.orderId = orderId
14384 
    self.invoice_number = invoice_number
4658 mandeep.dh 14385 
    self.serialNumber = serialNumber
4283 anupam.sin 14386 
    self.itemNumber = itemNumber
3064 chandransh 14387 
    self.billed_by = billed_by
4264 rajveer 14388 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14389 
    self.billingType = billingType
5110 mandeep.dh 14390 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14391 
    self.authorize = authorize
1135 chandransh 14392 
 
14393 
  def read(self, iprot):
14394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14396 
      return
14397 
    iprot.readStructBegin()
14398 
    while True:
14399 
      (fname, ftype, fid) = iprot.readFieldBegin()
14400 
      if ftype == TType.STOP:
14401 
        break
14402 
      if fid == 1:
14403 
        if ftype == TType.I64:
3064 chandransh 14404 
          self.orderId = iprot.readI64();
1135 chandransh 14405 
        else:
14406 
          iprot.skip(ftype)
14407 
      elif fid == 2:
3064 chandransh 14408 
        if ftype == TType.STRING:
14409 
          self.invoice_number = iprot.readString();
1135 chandransh 14410 
        else:
14411 
          iprot.skip(ftype)
3064 chandransh 14412 
      elif fid == 3:
5411 rajveer 14413 
        if ftype == TType.LIST:
14414 
          self.serialNumber = []
6188 rajveer 14415 
          (_etype270, _size267) = iprot.readListBegin()
14416 
          for _i271 in xrange(_size267):
14417 
            _elem272 = iprot.readString();
14418 
            self.serialNumber.append(_elem272)
5411 rajveer 14419 
          iprot.readListEnd()
3064 chandransh 14420 
        else:
14421 
          iprot.skip(ftype)
14422 
      elif fid == 4:
5411 rajveer 14423 
        if ftype == TType.LIST:
14424 
          self.itemNumber = []
6188 rajveer 14425 
          (_etype276, _size273) = iprot.readListBegin()
14426 
          for _i277 in xrange(_size273):
14427 
            _elem278 = iprot.readString();
14428 
            self.itemNumber.append(_elem278)
5411 rajveer 14429 
          iprot.readListEnd()
3064 chandransh 14430 
        else:
14431 
          iprot.skip(ftype)
14432 
      elif fid == 5:
14433 
        if ftype == TType.STRING:
4283 anupam.sin 14434 
          self.billed_by = iprot.readString();
3064 chandransh 14435 
        else:
14436 
          iprot.skip(ftype)
14437 
      elif fid == 6:
14438 
        if ftype == TType.I64:
4283 anupam.sin 14439 
          self.jacketNumber = iprot.readI64();
14440 
        else:
14441 
          iprot.skip(ftype)
14442 
      elif fid == 7:
14443 
        if ftype == TType.I64:
3064 chandransh 14444 
          self.billingType = iprot.readI64();
14445 
        else:
14446 
          iprot.skip(ftype)
4283 anupam.sin 14447 
      elif fid == 8:
14448 
        if ftype == TType.I64:
5110 mandeep.dh 14449 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14450 
        else:
14451 
          iprot.skip(ftype)
4763 rajveer 14452 
      elif fid == 9:
14453 
        if ftype == TType.BOOL:
14454 
          self.authorize = iprot.readBool();
14455 
        else:
14456 
          iprot.skip(ftype)
1246 chandransh 14457 
      else:
14458 
        iprot.skip(ftype)
14459 
      iprot.readFieldEnd()
14460 
    iprot.readStructEnd()
14461 
 
14462 
  def write(self, oprot):
14463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14465 
      return
4283 anupam.sin 14466 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14467 
    if self.orderId is not None:
3064 chandransh 14468 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14469 
      oprot.writeI64(self.orderId)
1246 chandransh 14470 
      oprot.writeFieldEnd()
4283 anupam.sin 14471 
    if self.invoice_number is not None:
14472 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14473 
      oprot.writeString(self.invoice_number)
1246 chandransh 14474 
      oprot.writeFieldEnd()
4658 mandeep.dh 14475 
    if self.serialNumber is not None:
5411 rajveer 14476 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14477 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14478 
      for iter279 in self.serialNumber:
14479 
        oprot.writeString(iter279)
5411 rajveer 14480 
      oprot.writeListEnd()
3064 chandransh 14481 
      oprot.writeFieldEnd()
3431 rajveer 14482 
    if self.itemNumber is not None:
5411 rajveer 14483 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14484 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14485 
      for iter280 in self.itemNumber:
14486 
        oprot.writeString(iter280)
5411 rajveer 14487 
      oprot.writeListEnd()
3064 chandransh 14488 
      oprot.writeFieldEnd()
4283 anupam.sin 14489 
    if self.billed_by is not None:
14490 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
14491 
      oprot.writeString(self.billed_by)
3064 chandransh 14492 
      oprot.writeFieldEnd()
4283 anupam.sin 14493 
    if self.jacketNumber is not None:
14494 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
14495 
      oprot.writeI64(self.jacketNumber)
14496 
      oprot.writeFieldEnd()
3431 rajveer 14497 
    if self.billingType is not None:
4283 anupam.sin 14498 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 14499 
      oprot.writeI64(self.billingType)
14500 
      oprot.writeFieldEnd()
5110 mandeep.dh 14501 
    if self.fulfilmentWarehouseId is not None:
14502 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
14503 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14504 
      oprot.writeFieldEnd()
4763 rajveer 14505 
    if self.authorize is not None:
14506 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
14507 
      oprot.writeBool(self.authorize)
14508 
      oprot.writeFieldEnd()
1246 chandransh 14509 
    oprot.writeFieldStop()
14510 
    oprot.writeStructEnd()
14511 
 
3431 rajveer 14512 
  def validate(self):
14513 
    return
14514 
 
14515 
 
1246 chandransh 14516 
  def __repr__(self):
14517 
    L = ['%s=%r' % (key, value)
14518 
      for key, value in self.__dict__.iteritems()]
14519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14520 
 
14521 
  def __eq__(self, other):
14522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14523 
 
14524 
  def __ne__(self, other):
14525 
    return not (self == other)
14526 
 
4283 anupam.sin 14527 
class addBillingDetails_result:
1246 chandransh 14528 
  """
14529 
  Attributes:
3064 chandransh 14530 
   - success
1246 chandransh 14531 
   - ex
14532 
  """
14533 
 
14534 
  thrift_spec = (
3064 chandransh 14535 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14537 
  )
14538 
 
3064 chandransh 14539 
  def __init__(self, success=None, ex=None,):
14540 
    self.success = success
1246 chandransh 14541 
    self.ex = ex
14542 
 
14543 
  def read(self, iprot):
14544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14546 
      return
14547 
    iprot.readStructBegin()
14548 
    while True:
14549 
      (fname, ftype, fid) = iprot.readFieldBegin()
14550 
      if ftype == TType.STOP:
14551 
        break
3064 chandransh 14552 
      if fid == 0:
14553 
        if ftype == TType.BOOL:
14554 
          self.success = iprot.readBool();
14555 
        else:
14556 
          iprot.skip(ftype)
14557 
      elif fid == 1:
1246 chandransh 14558 
        if ftype == TType.STRUCT:
14559 
          self.ex = TransactionServiceException()
14560 
          self.ex.read(iprot)
14561 
        else:
14562 
          iprot.skip(ftype)
14563 
      else:
14564 
        iprot.skip(ftype)
14565 
      iprot.readFieldEnd()
14566 
    iprot.readStructEnd()
14567 
 
14568 
  def write(self, oprot):
14569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14571 
      return
4283 anupam.sin 14572 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14573 
    if self.success is not None:
3064 chandransh 14574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14575 
      oprot.writeBool(self.success)
14576 
      oprot.writeFieldEnd()
3431 rajveer 14577 
    if self.ex is not None:
1246 chandransh 14578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14579 
      self.ex.write(oprot)
14580 
      oprot.writeFieldEnd()
14581 
    oprot.writeFieldStop()
14582 
    oprot.writeStructEnd()
14583 
 
3431 rajveer 14584 
  def validate(self):
14585 
    return
14586 
 
14587 
 
1246 chandransh 14588 
  def __repr__(self):
14589 
    L = ['%s=%r' % (key, value)
14590 
      for key, value in self.__dict__.iteritems()]
14591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14592 
 
14593 
  def __eq__(self, other):
14594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14595 
 
14596 
  def __ne__(self, other):
14597 
    return not (self == other)
14598 
 
4579 rajveer 14599 
class addInvoiceNumber_args:
14600 
  """
14601 
  Attributes:
14602 
   - orderId
14603 
   - invoiceNumber
4763 rajveer 14604 
   - color
6756 amar.kumar 14605 
   - serialNumber
14606 
   - itemNumber
4579 rajveer 14607 
  """
14608 
 
14609 
  thrift_spec = (
14610 
    None, # 0
14611 
    (1, TType.I64, 'orderId', None, None, ), # 1
14612 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14613 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14614 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14615 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14616 
  )
14617 
 
6756 amar.kumar 14618 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14619 
    self.orderId = orderId
14620 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14621 
    self.color = color
6756 amar.kumar 14622 
    self.serialNumber = serialNumber
14623 
    self.itemNumber = itemNumber
4579 rajveer 14624 
 
14625 
  def read(self, iprot):
14626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14628 
      return
14629 
    iprot.readStructBegin()
14630 
    while True:
14631 
      (fname, ftype, fid) = iprot.readFieldBegin()
14632 
      if ftype == TType.STOP:
14633 
        break
14634 
      if fid == 1:
14635 
        if ftype == TType.I64:
14636 
          self.orderId = iprot.readI64();
14637 
        else:
14638 
          iprot.skip(ftype)
14639 
      elif fid == 2:
14640 
        if ftype == TType.STRING:
14641 
          self.invoiceNumber = iprot.readString();
14642 
        else:
14643 
          iprot.skip(ftype)
4763 rajveer 14644 
      elif fid == 3:
14645 
        if ftype == TType.STRING:
14646 
          self.color = iprot.readString();
14647 
        else:
14648 
          iprot.skip(ftype)
6756 amar.kumar 14649 
      elif fid == 4:
14650 
        if ftype == TType.STRING:
14651 
          self.serialNumber = iprot.readString();
14652 
        else:
14653 
          iprot.skip(ftype)
14654 
      elif fid == 5:
14655 
        if ftype == TType.STRING:
14656 
          self.itemNumber = iprot.readString();
14657 
        else:
14658 
          iprot.skip(ftype)
4579 rajveer 14659 
      else:
14660 
        iprot.skip(ftype)
14661 
      iprot.readFieldEnd()
14662 
    iprot.readStructEnd()
14663 
 
14664 
  def write(self, oprot):
14665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14667 
      return
14668 
    oprot.writeStructBegin('addInvoiceNumber_args')
14669 
    if self.orderId is not None:
14670 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14671 
      oprot.writeI64(self.orderId)
14672 
      oprot.writeFieldEnd()
14673 
    if self.invoiceNumber is not None:
14674 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14675 
      oprot.writeString(self.invoiceNumber)
14676 
      oprot.writeFieldEnd()
4763 rajveer 14677 
    if self.color is not None:
14678 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14679 
      oprot.writeString(self.color)
14680 
      oprot.writeFieldEnd()
6756 amar.kumar 14681 
    if self.serialNumber is not None:
14682 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14683 
      oprot.writeString(self.serialNumber)
14684 
      oprot.writeFieldEnd()
14685 
    if self.itemNumber is not None:
14686 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14687 
      oprot.writeString(self.itemNumber)
14688 
      oprot.writeFieldEnd()
4579 rajveer 14689 
    oprot.writeFieldStop()
14690 
    oprot.writeStructEnd()
14691 
 
14692 
  def validate(self):
14693 
    return
14694 
 
14695 
 
14696 
  def __repr__(self):
14697 
    L = ['%s=%r' % (key, value)
14698 
      for key, value in self.__dict__.iteritems()]
14699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14700 
 
14701 
  def __eq__(self, other):
14702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14703 
 
14704 
  def __ne__(self, other):
14705 
    return not (self == other)
14706 
 
14707 
class addInvoiceNumber_result:
14708 
  """
14709 
  Attributes:
14710 
   - ex
14711 
  """
14712 
 
14713 
  thrift_spec = (
14714 
    None, # 0
14715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14716 
  )
14717 
 
14718 
  def __init__(self, ex=None,):
14719 
    self.ex = ex
14720 
 
14721 
  def read(self, iprot):
14722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14724 
      return
14725 
    iprot.readStructBegin()
14726 
    while True:
14727 
      (fname, ftype, fid) = iprot.readFieldBegin()
14728 
      if ftype == TType.STOP:
14729 
        break
14730 
      if fid == 1:
14731 
        if ftype == TType.STRUCT:
14732 
          self.ex = TransactionServiceException()
14733 
          self.ex.read(iprot)
14734 
        else:
14735 
          iprot.skip(ftype)
14736 
      else:
14737 
        iprot.skip(ftype)
14738 
      iprot.readFieldEnd()
14739 
    iprot.readStructEnd()
14740 
 
14741 
  def write(self, oprot):
14742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14744 
      return
14745 
    oprot.writeStructBegin('addInvoiceNumber_result')
14746 
    if self.ex is not None:
14747 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14748 
      self.ex.write(oprot)
14749 
      oprot.writeFieldEnd()
14750 
    oprot.writeFieldStop()
14751 
    oprot.writeStructEnd()
14752 
 
14753 
  def validate(self):
14754 
    return
14755 
 
14756 
 
14757 
  def __repr__(self):
14758 
    L = ['%s=%r' % (key, value)
14759 
      for key, value in self.__dict__.iteritems()]
14760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14761 
 
14762 
  def __eq__(self, other):
14763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14764 
 
14765 
  def __ne__(self, other):
14766 
    return not (self == other)
14767 
 
4910 phani.kuma 14768 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14769 
  """
14770 
  Attributes:
3064 chandransh 14771 
   - warehouseId
1408 ankur.sing 14772 
   - providerId
3064 chandransh 14773 
   - cod
4910 phani.kuma 14774 
   - orderIds
1408 ankur.sing 14775 
  """
14776 
 
14777 
  thrift_spec = (
14778 
    None, # 0
3064 chandransh 14779 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14780 
    (2, TType.I64, 'providerId', None, None, ), # 2
14781 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14782 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14783 
  )
14784 
 
4910 phani.kuma 14785 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14786 
    self.warehouseId = warehouseId
1408 ankur.sing 14787 
    self.providerId = providerId
3064 chandransh 14788 
    self.cod = cod
4910 phani.kuma 14789 
    self.orderIds = orderIds
1408 ankur.sing 14790 
 
14791 
  def read(self, iprot):
14792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14794 
      return
14795 
    iprot.readStructBegin()
14796 
    while True:
14797 
      (fname, ftype, fid) = iprot.readFieldBegin()
14798 
      if ftype == TType.STOP:
14799 
        break
14800 
      if fid == 1:
14801 
        if ftype == TType.I64:
3064 chandransh 14802 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14803 
        else:
14804 
          iprot.skip(ftype)
14805 
      elif fid == 2:
14806 
        if ftype == TType.I64:
3064 chandransh 14807 
          self.providerId = iprot.readI64();
1408 ankur.sing 14808 
        else:
14809 
          iprot.skip(ftype)
3064 chandransh 14810 
      elif fid == 3:
14811 
        if ftype == TType.BOOL:
14812 
          self.cod = iprot.readBool();
14813 
        else:
14814 
          iprot.skip(ftype)
4910 phani.kuma 14815 
      elif fid == 4:
14816 
        if ftype == TType.LIST:
14817 
          self.orderIds = []
6188 rajveer 14818 
          (_etype284, _size281) = iprot.readListBegin()
14819 
          for _i285 in xrange(_size281):
14820 
            _elem286 = iprot.readI64();
14821 
            self.orderIds.append(_elem286)
4910 phani.kuma 14822 
          iprot.readListEnd()
14823 
        else:
14824 
          iprot.skip(ftype)
1408 ankur.sing 14825 
      else:
14826 
        iprot.skip(ftype)
14827 
      iprot.readFieldEnd()
14828 
    iprot.readStructEnd()
14829 
 
14830 
  def write(self, oprot):
14831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14833 
      return
4910 phani.kuma 14834 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14835 
    if self.warehouseId is not None:
3064 chandransh 14836 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14837 
      oprot.writeI64(self.warehouseId)
14838 
      oprot.writeFieldEnd()
3431 rajveer 14839 
    if self.providerId is not None:
3064 chandransh 14840 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14841 
      oprot.writeI64(self.providerId)
14842 
      oprot.writeFieldEnd()
3431 rajveer 14843 
    if self.cod is not None:
3064 chandransh 14844 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14845 
      oprot.writeBool(self.cod)
1408 ankur.sing 14846 
      oprot.writeFieldEnd()
4910 phani.kuma 14847 
    if self.orderIds is not None:
14848 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14849 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14850 
      for iter287 in self.orderIds:
14851 
        oprot.writeI64(iter287)
4910 phani.kuma 14852 
      oprot.writeListEnd()
14853 
      oprot.writeFieldEnd()
1408 ankur.sing 14854 
    oprot.writeFieldStop()
14855 
    oprot.writeStructEnd()
14856 
 
3431 rajveer 14857 
  def validate(self):
14858 
    return
14859 
 
14860 
 
1408 ankur.sing 14861 
  def __repr__(self):
14862 
    L = ['%s=%r' % (key, value)
14863 
      for key, value in self.__dict__.iteritems()]
14864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14865 
 
14866 
  def __eq__(self, other):
14867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14868 
 
14869 
  def __ne__(self, other):
14870 
    return not (self == other)
14871 
 
4910 phani.kuma 14872 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14873 
  """
14874 
  Attributes:
14875 
   - success
3064 chandransh 14876 
   - ex
1408 ankur.sing 14877 
  """
14878 
 
14879 
  thrift_spec = (
3064 chandransh 14880 
    (0, TType.BOOL, 'success', None, None, ), # 0
14881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14882 
  )
14883 
 
3064 chandransh 14884 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14885 
    self.success = success
3064 chandransh 14886 
    self.ex = ex
1408 ankur.sing 14887 
 
14888 
  def read(self, iprot):
14889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14891 
      return
14892 
    iprot.readStructBegin()
14893 
    while True:
14894 
      (fname, ftype, fid) = iprot.readFieldBegin()
14895 
      if ftype == TType.STOP:
14896 
        break
14897 
      if fid == 0:
3064 chandransh 14898 
        if ftype == TType.BOOL:
14899 
          self.success = iprot.readBool();
1408 ankur.sing 14900 
        else:
14901 
          iprot.skip(ftype)
3064 chandransh 14902 
      elif fid == 1:
14903 
        if ftype == TType.STRUCT:
14904 
          self.ex = TransactionServiceException()
14905 
          self.ex.read(iprot)
14906 
        else:
14907 
          iprot.skip(ftype)
1408 ankur.sing 14908 
      else:
14909 
        iprot.skip(ftype)
14910 
      iprot.readFieldEnd()
14911 
    iprot.readStructEnd()
14912 
 
14913 
  def write(self, oprot):
14914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14916 
      return
4910 phani.kuma 14917 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14918 
    if self.success is not None:
3064 chandransh 14919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14920 
      oprot.writeBool(self.success)
1408 ankur.sing 14921 
      oprot.writeFieldEnd()
3431 rajveer 14922 
    if self.ex is not None:
3064 chandransh 14923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14924 
      self.ex.write(oprot)
14925 
      oprot.writeFieldEnd()
1408 ankur.sing 14926 
    oprot.writeFieldStop()
14927 
    oprot.writeStructEnd()
14928 
 
3431 rajveer 14929 
  def validate(self):
14930 
    return
14931 
 
14932 
 
1408 ankur.sing 14933 
  def __repr__(self):
14934 
    L = ['%s=%r' % (key, value)
14935 
      for key, value in self.__dict__.iteritems()]
14936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14937 
 
14938 
  def __eq__(self, other):
14939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14940 
 
14941 
  def __ne__(self, other):
14942 
    return not (self == other)
14943 
 
5676 rajveer 14944 
class markOrdersAsReturnedFromStore_args:
14945 
  """
14946 
  Attributes:
14947 
   - providerId
14948 
   - orderIds
5713 rajveer 14949 
   - awbs
5676 rajveer 14950 
  """
14951 
 
14952 
  thrift_spec = (
14953 
    None, # 0
14954 
    (1, TType.I64, 'providerId', None, None, ), # 1
14955 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14956 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14957 
  )
14958 
 
5713 rajveer 14959 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14960 
    self.providerId = providerId
14961 
    self.orderIds = orderIds
5713 rajveer 14962 
    self.awbs = awbs
5676 rajveer 14963 
 
14964 
  def read(self, iprot):
14965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14967 
      return
14968 
    iprot.readStructBegin()
14969 
    while True:
14970 
      (fname, ftype, fid) = iprot.readFieldBegin()
14971 
      if ftype == TType.STOP:
14972 
        break
14973 
      if fid == 1:
14974 
        if ftype == TType.I64:
14975 
          self.providerId = iprot.readI64();
14976 
        else:
14977 
          iprot.skip(ftype)
14978 
      elif fid == 2:
14979 
        if ftype == TType.LIST:
14980 
          self.orderIds = []
6188 rajveer 14981 
          (_etype291, _size288) = iprot.readListBegin()
14982 
          for _i292 in xrange(_size288):
14983 
            _elem293 = iprot.readI64();
14984 
            self.orderIds.append(_elem293)
5676 rajveer 14985 
          iprot.readListEnd()
14986 
        else:
14987 
          iprot.skip(ftype)
5713 rajveer 14988 
      elif fid == 3:
14989 
        if ftype == TType.LIST:
14990 
          self.awbs = []
6188 rajveer 14991 
          (_etype297, _size294) = iprot.readListBegin()
14992 
          for _i298 in xrange(_size294):
14993 
            _elem299 = iprot.readString();
14994 
            self.awbs.append(_elem299)
5713 rajveer 14995 
          iprot.readListEnd()
14996 
        else:
14997 
          iprot.skip(ftype)
5676 rajveer 14998 
      else:
14999 
        iprot.skip(ftype)
15000 
      iprot.readFieldEnd()
15001 
    iprot.readStructEnd()
15002 
 
15003 
  def write(self, oprot):
15004 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15005 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15006 
      return
15007 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15008 
    if self.providerId is not None:
15009 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15010 
      oprot.writeI64(self.providerId)
15011 
      oprot.writeFieldEnd()
15012 
    if self.orderIds is not None:
15013 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15014 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15015 
      for iter300 in self.orderIds:
15016 
        oprot.writeI64(iter300)
5676 rajveer 15017 
      oprot.writeListEnd()
15018 
      oprot.writeFieldEnd()
5713 rajveer 15019 
    if self.awbs is not None:
15020 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15021 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15022 
      for iter301 in self.awbs:
15023 
        oprot.writeString(iter301)
5713 rajveer 15024 
      oprot.writeListEnd()
15025 
      oprot.writeFieldEnd()
5676 rajveer 15026 
    oprot.writeFieldStop()
15027 
    oprot.writeStructEnd()
15028 
 
15029 
  def validate(self):
15030 
    return
15031 
 
15032 
 
15033 
  def __repr__(self):
15034 
    L = ['%s=%r' % (key, value)
15035 
      for key, value in self.__dict__.iteritems()]
15036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15037 
 
15038 
  def __eq__(self, other):
15039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15040 
 
15041 
  def __ne__(self, other):
15042 
    return not (self == other)
15043 
 
15044 
class markOrdersAsReturnedFromStore_result:
15045 
  """
15046 
  Attributes:
15047 
   - success
15048 
   - ex
15049 
  """
15050 
 
15051 
  thrift_spec = (
15052 
    (0, TType.BOOL, 'success', None, None, ), # 0
15053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15054 
  )
15055 
 
15056 
  def __init__(self, success=None, ex=None,):
15057 
    self.success = success
15058 
    self.ex = ex
15059 
 
15060 
  def read(self, iprot):
15061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15063 
      return
15064 
    iprot.readStructBegin()
15065 
    while True:
15066 
      (fname, ftype, fid) = iprot.readFieldBegin()
15067 
      if ftype == TType.STOP:
15068 
        break
15069 
      if fid == 0:
15070 
        if ftype == TType.BOOL:
15071 
          self.success = iprot.readBool();
15072 
        else:
15073 
          iprot.skip(ftype)
15074 
      elif fid == 1:
15075 
        if ftype == TType.STRUCT:
15076 
          self.ex = TransactionServiceException()
15077 
          self.ex.read(iprot)
15078 
        else:
15079 
          iprot.skip(ftype)
15080 
      else:
15081 
        iprot.skip(ftype)
15082 
      iprot.readFieldEnd()
15083 
    iprot.readStructEnd()
15084 
 
15085 
  def write(self, oprot):
15086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15088 
      return
15089 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15090 
    if self.success is not None:
15091 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15092 
      oprot.writeBool(self.success)
15093 
      oprot.writeFieldEnd()
15094 
    if self.ex is not None:
15095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15096 
      self.ex.write(oprot)
15097 
      oprot.writeFieldEnd()
15098 
    oprot.writeFieldStop()
15099 
    oprot.writeStructEnd()
15100 
 
15101 
  def validate(self):
15102 
    return
15103 
 
15104 
 
15105 
  def __repr__(self):
15106 
    L = ['%s=%r' % (key, value)
15107 
      for key, value in self.__dict__.iteritems()]
15108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15109 
 
15110 
  def __eq__(self, other):
15111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15112 
 
15113 
  def __ne__(self, other):
15114 
    return not (self == other)
15115 
 
4910 phani.kuma 15116 
class markOrdersAsPickedUp_args:
4410 rajveer 15117 
  """
15118 
  Attributes:
15119 
   - providerId
4910 phani.kuma 15120 
   - pickupDetails
4410 rajveer 15121 
  """
15122 
 
15123 
  thrift_spec = (
15124 
    None, # 0
4910 phani.kuma 15125 
    (1, TType.I64, 'providerId', None, None, ), # 1
15126 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15127 
  )
15128 
 
4910 phani.kuma 15129 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15130 
    self.providerId = providerId
4910 phani.kuma 15131 
    self.pickupDetails = pickupDetails
4410 rajveer 15132 
 
15133 
  def read(self, iprot):
15134 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15135 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15136 
      return
15137 
    iprot.readStructBegin()
15138 
    while True:
15139 
      (fname, ftype, fid) = iprot.readFieldBegin()
15140 
      if ftype == TType.STOP:
15141 
        break
15142 
      if fid == 1:
15143 
        if ftype == TType.I64:
4910 phani.kuma 15144 
          self.providerId = iprot.readI64();
4410 rajveer 15145 
        else:
15146 
          iprot.skip(ftype)
15147 
      elif fid == 2:
4910 phani.kuma 15148 
        if ftype == TType.MAP:
15149 
          self.pickupDetails = {}
6188 rajveer 15150 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15151 
          for _i306 in xrange(_size302):
15152 
            _key307 = iprot.readString();
15153 
            _val308 = iprot.readString();
15154 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15155 
          iprot.readMapEnd()
4410 rajveer 15156 
        else:
15157 
          iprot.skip(ftype)
15158 
      else:
15159 
        iprot.skip(ftype)
15160 
      iprot.readFieldEnd()
15161 
    iprot.readStructEnd()
15162 
 
15163 
  def write(self, oprot):
15164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15166 
      return
4910 phani.kuma 15167 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15168 
    if self.providerId is not None:
4910 phani.kuma 15169 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15170 
      oprot.writeI64(self.providerId)
15171 
      oprot.writeFieldEnd()
4910 phani.kuma 15172 
    if self.pickupDetails is not None:
15173 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15174 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15175 
      for kiter309,viter310 in self.pickupDetails.items():
15176 
        oprot.writeString(kiter309)
15177 
        oprot.writeString(viter310)
4910 phani.kuma 15178 
      oprot.writeMapEnd()
4410 rajveer 15179 
      oprot.writeFieldEnd()
15180 
    oprot.writeFieldStop()
15181 
    oprot.writeStructEnd()
15182 
 
15183 
  def validate(self):
15184 
    return
15185 
 
15186 
 
15187 
  def __repr__(self):
15188 
    L = ['%s=%r' % (key, value)
15189 
      for key, value in self.__dict__.iteritems()]
15190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15191 
 
15192 
  def __eq__(self, other):
15193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15194 
 
15195 
  def __ne__(self, other):
15196 
    return not (self == other)
15197 
 
4910 phani.kuma 15198 
class markOrdersAsPickedUp_result:
4410 rajveer 15199 
  """
15200 
  Attributes:
15201 
   - ex
15202 
  """
15203 
 
15204 
  thrift_spec = (
4910 phani.kuma 15205 
    None, # 0
4410 rajveer 15206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15207 
  )
15208 
 
4910 phani.kuma 15209 
  def __init__(self, ex=None,):
4410 rajveer 15210 
    self.ex = ex
15211 
 
15212 
  def read(self, iprot):
15213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15215 
      return
15216 
    iprot.readStructBegin()
15217 
    while True:
15218 
      (fname, ftype, fid) = iprot.readFieldBegin()
15219 
      if ftype == TType.STOP:
15220 
        break
4910 phani.kuma 15221 
      if fid == 1:
4410 rajveer 15222 
        if ftype == TType.STRUCT:
15223 
          self.ex = TransactionServiceException()
15224 
          self.ex.read(iprot)
15225 
        else:
15226 
          iprot.skip(ftype)
15227 
      else:
15228 
        iprot.skip(ftype)
15229 
      iprot.readFieldEnd()
15230 
    iprot.readStructEnd()
15231 
 
15232 
  def write(self, oprot):
15233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15235 
      return
4910 phani.kuma 15236 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15237 
    if self.ex is not None:
15238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15239 
      self.ex.write(oprot)
15240 
      oprot.writeFieldEnd()
15241 
    oprot.writeFieldStop()
15242 
    oprot.writeStructEnd()
15243 
 
15244 
  def validate(self):
15245 
    return
15246 
 
15247 
 
15248 
  def __repr__(self):
15249 
    L = ['%s=%r' % (key, value)
15250 
      for key, value in self.__dict__.iteritems()]
15251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15252 
 
15253 
  def __eq__(self, other):
15254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15255 
 
15256 
  def __ne__(self, other):
15257 
    return not (self == other)
15258 
 
4910 phani.kuma 15259 
class getOrdersNotPickedUp_args:
304 ashish 15260 
  """
15261 
  Attributes:
3064 chandransh 15262 
   - providerId
304 ashish 15263 
  """
94 ashish 15264 
 
304 ashish 15265 
  thrift_spec = (
15266 
    None, # 0
3064 chandransh 15267 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15268 
  )
15269 
 
4910 phani.kuma 15270 
  def __init__(self, providerId=None,):
3064 chandransh 15271 
    self.providerId = providerId
304 ashish 15272 
 
15273 
  def read(self, iprot):
15274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15276 
      return
15277 
    iprot.readStructBegin()
15278 
    while True:
15279 
      (fname, ftype, fid) = iprot.readFieldBegin()
15280 
      if ftype == TType.STOP:
15281 
        break
15282 
      if fid == 1:
15283 
        if ftype == TType.I64:
3064 chandransh 15284 
          self.providerId = iprot.readI64();
304 ashish 15285 
        else:
15286 
          iprot.skip(ftype)
15287 
      else:
15288 
        iprot.skip(ftype)
15289 
      iprot.readFieldEnd()
15290 
    iprot.readStructEnd()
15291 
 
15292 
  def write(self, oprot):
15293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15295 
      return
4910 phani.kuma 15296 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15297 
    if self.providerId is not None:
3064 chandransh 15298 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15299 
      oprot.writeI64(self.providerId)
304 ashish 15300 
      oprot.writeFieldEnd()
15301 
    oprot.writeFieldStop()
15302 
    oprot.writeStructEnd()
15303 
 
3431 rajveer 15304 
  def validate(self):
15305 
    return
15306 
 
15307 
 
304 ashish 15308 
  def __repr__(self):
15309 
    L = ['%s=%r' % (key, value)
15310 
      for key, value in self.__dict__.iteritems()]
15311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15312 
 
15313 
  def __eq__(self, other):
15314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15315 
 
15316 
  def __ne__(self, other):
15317 
    return not (self == other)
15318 
 
4910 phani.kuma 15319 
class getOrdersNotPickedUp_result:
304 ashish 15320 
  """
15321 
  Attributes:
15322 
   - success
15323 
  """
15324 
 
15325 
  thrift_spec = (
3064 chandransh 15326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15327 
  )
15328 
 
4910 phani.kuma 15329 
  def __init__(self, success=None,):
304 ashish 15330 
    self.success = success
15331 
 
15332 
  def read(self, iprot):
15333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15335 
      return
15336 
    iprot.readStructBegin()
15337 
    while True:
15338 
      (fname, ftype, fid) = iprot.readFieldBegin()
15339 
      if ftype == TType.STOP:
15340 
        break
15341 
      if fid == 0:
15342 
        if ftype == TType.LIST:
15343 
          self.success = []
6188 rajveer 15344 
          (_etype314, _size311) = iprot.readListBegin()
15345 
          for _i315 in xrange(_size311):
15346 
            _elem316 = Order()
15347 
            _elem316.read(iprot)
15348 
            self.success.append(_elem316)
304 ashish 15349 
          iprot.readListEnd()
15350 
        else:
15351 
          iprot.skip(ftype)
15352 
      else:
15353 
        iprot.skip(ftype)
15354 
      iprot.readFieldEnd()
15355 
    iprot.readStructEnd()
15356 
 
15357 
  def write(self, oprot):
15358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15360 
      return
4910 phani.kuma 15361 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15362 
    if self.success is not None:
304 ashish 15363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15364 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15365 
      for iter317 in self.success:
15366 
        iter317.write(oprot)
304 ashish 15367 
      oprot.writeListEnd()
15368 
      oprot.writeFieldEnd()
15369 
    oprot.writeFieldStop()
15370 
    oprot.writeStructEnd()
15371 
 
3431 rajveer 15372 
  def validate(self):
15373 
    return
15374 
 
15375 
 
304 ashish 15376 
  def __repr__(self):
15377 
    L = ['%s=%r' % (key, value)
15378 
      for key, value in self.__dict__.iteritems()]
15379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15380 
 
15381 
  def __eq__(self, other):
15382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15383 
 
15384 
  def __ne__(self, other):
15385 
    return not (self == other)
15386 
 
3064 chandransh 15387 
class markOrdersAsDelivered_args:
304 ashish 15388 
  """
15389 
  Attributes:
3064 chandransh 15390 
   - providerId
15391 
   - deliveredOrders
304 ashish 15392 
  """
15393 
 
15394 
  thrift_spec = (
15395 
    None, # 0
3064 chandransh 15396 
    (1, TType.I64, 'providerId', None, None, ), # 1
15397 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15398 
  )
15399 
 
3064 chandransh 15400 
  def __init__(self, providerId=None, deliveredOrders=None,):
15401 
    self.providerId = providerId
15402 
    self.deliveredOrders = deliveredOrders
304 ashish 15403 
 
15404 
  def read(self, iprot):
15405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15407 
      return
15408 
    iprot.readStructBegin()
15409 
    while True:
15410 
      (fname, ftype, fid) = iprot.readFieldBegin()
15411 
      if ftype == TType.STOP:
15412 
        break
15413 
      if fid == 1:
15414 
        if ftype == TType.I64:
3064 chandransh 15415 
          self.providerId = iprot.readI64();
304 ashish 15416 
        else:
15417 
          iprot.skip(ftype)
15418 
      elif fid == 2:
3064 chandransh 15419 
        if ftype == TType.MAP:
15420 
          self.deliveredOrders = {}
6188 rajveer 15421 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15422 
          for _i322 in xrange(_size318):
15423 
            _key323 = iprot.readString();
15424 
            _val324 = iprot.readString();
15425 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15426 
          iprot.readMapEnd()
304 ashish 15427 
        else:
15428 
          iprot.skip(ftype)
15429 
      else:
15430 
        iprot.skip(ftype)
15431 
      iprot.readFieldEnd()
15432 
    iprot.readStructEnd()
15433 
 
15434 
  def write(self, oprot):
15435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15437 
      return
3064 chandransh 15438 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15439 
    if self.providerId is not None:
3064 chandransh 15440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15441 
      oprot.writeI64(self.providerId)
304 ashish 15442 
      oprot.writeFieldEnd()
3431 rajveer 15443 
    if self.deliveredOrders is not None:
3064 chandransh 15444 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15445 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15446 
      for kiter325,viter326 in self.deliveredOrders.items():
15447 
        oprot.writeString(kiter325)
15448 
        oprot.writeString(viter326)
3064 chandransh 15449 
      oprot.writeMapEnd()
304 ashish 15450 
      oprot.writeFieldEnd()
15451 
    oprot.writeFieldStop()
15452 
    oprot.writeStructEnd()
15453 
 
3431 rajveer 15454 
  def validate(self):
15455 
    return
15456 
 
15457 
 
304 ashish 15458 
  def __repr__(self):
15459 
    L = ['%s=%r' % (key, value)
15460 
      for key, value in self.__dict__.iteritems()]
15461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15462 
 
15463 
  def __eq__(self, other):
15464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15465 
 
15466 
  def __ne__(self, other):
15467 
    return not (self == other)
15468 
 
3064 chandransh 15469 
class markOrdersAsDelivered_result:
15470 
  """
15471 
  Attributes:
15472 
   - ex
15473 
  """
304 ashish 15474 
 
15475 
  thrift_spec = (
3064 chandransh 15476 
    None, # 0
15477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15478 
  )
15479 
 
3064 chandransh 15480 
  def __init__(self, ex=None,):
15481 
    self.ex = ex
304 ashish 15482 
 
1596 ankur.sing 15483 
  def read(self, iprot):
15484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15486 
      return
15487 
    iprot.readStructBegin()
15488 
    while True:
15489 
      (fname, ftype, fid) = iprot.readFieldBegin()
15490 
      if ftype == TType.STOP:
15491 
        break
3064 chandransh 15492 
      if fid == 1:
15493 
        if ftype == TType.STRUCT:
15494 
          self.ex = TransactionServiceException()
15495 
          self.ex.read(iprot)
15496 
        else:
15497 
          iprot.skip(ftype)
1596 ankur.sing 15498 
      else:
15499 
        iprot.skip(ftype)
15500 
      iprot.readFieldEnd()
15501 
    iprot.readStructEnd()
15502 
 
15503 
  def write(self, oprot):
15504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15506 
      return
3064 chandransh 15507 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15508 
    if self.ex is not None:
3064 chandransh 15509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15510 
      self.ex.write(oprot)
15511 
      oprot.writeFieldEnd()
1596 ankur.sing 15512 
    oprot.writeFieldStop()
15513 
    oprot.writeStructEnd()
15514 
 
3431 rajveer 15515 
  def validate(self):
15516 
    return
15517 
 
15518 
 
1596 ankur.sing 15519 
  def __repr__(self):
15520 
    L = ['%s=%r' % (key, value)
15521 
      for key, value in self.__dict__.iteritems()]
15522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15523 
 
15524 
  def __eq__(self, other):
15525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15526 
 
15527 
  def __ne__(self, other):
15528 
    return not (self == other)
15529 
 
4910 phani.kuma 15530 
class markAsRTOrders_args:
1596 ankur.sing 15531 
  """
15532 
  Attributes:
3064 chandransh 15533 
   - providerId
15534 
   - returnedOrders
1596 ankur.sing 15535 
  """
15536 
 
15537 
  thrift_spec = (
3064 chandransh 15538 
    None, # 0
15539 
    (1, TType.I64, 'providerId', None, None, ), # 1
15540 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15541 
  )
15542 
 
3064 chandransh 15543 
  def __init__(self, providerId=None, returnedOrders=None,):
15544 
    self.providerId = providerId
15545 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15546 
 
15547 
  def read(self, iprot):
15548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15550 
      return
15551 
    iprot.readStructBegin()
15552 
    while True:
15553 
      (fname, ftype, fid) = iprot.readFieldBegin()
15554 
      if ftype == TType.STOP:
15555 
        break
3064 chandransh 15556 
      if fid == 1:
1596 ankur.sing 15557 
        if ftype == TType.I64:
3064 chandransh 15558 
          self.providerId = iprot.readI64();
1596 ankur.sing 15559 
        else:
15560 
          iprot.skip(ftype)
3064 chandransh 15561 
      elif fid == 2:
15562 
        if ftype == TType.MAP:
15563 
          self.returnedOrders = {}
6188 rajveer 15564 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15565 
          for _i331 in xrange(_size327):
15566 
            _key332 = iprot.readString();
15567 
            _val333 = iprot.readString();
15568 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15569 
          iprot.readMapEnd()
15570 
        else:
15571 
          iprot.skip(ftype)
1596 ankur.sing 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
4910 phani.kuma 15581 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15582 
    if self.providerId is not None:
3064 chandransh 15583 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15584 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15585 
      oprot.writeFieldEnd()
3431 rajveer 15586 
    if self.returnedOrders is not None:
3064 chandransh 15587 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15588 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15589 
      for kiter334,viter335 in self.returnedOrders.items():
15590 
        oprot.writeString(kiter334)
15591 
        oprot.writeString(viter335)
3064 chandransh 15592 
      oprot.writeMapEnd()
15593 
      oprot.writeFieldEnd()
1596 ankur.sing 15594 
    oprot.writeFieldStop()
15595 
    oprot.writeStructEnd()
15596 
 
3431 rajveer 15597 
  def validate(self):
15598 
    return
15599 
 
15600 
 
1596 ankur.sing 15601 
  def __repr__(self):
15602 
    L = ['%s=%r' % (key, value)
15603 
      for key, value in self.__dict__.iteritems()]
15604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15605 
 
15606 
  def __eq__(self, other):
15607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15608 
 
15609 
  def __ne__(self, other):
15610 
    return not (self == other)
15611 
 
4910 phani.kuma 15612 
class markAsRTOrders_result:
3064 chandransh 15613 
  """
15614 
  Attributes:
15615 
   - ex
15616 
  """
1596 ankur.sing 15617 
 
1627 ankur.sing 15618 
  thrift_spec = (
3064 chandransh 15619 
    None, # 0
15620 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15621 
  )
15622 
 
3064 chandransh 15623 
  def __init__(self, ex=None,):
15624 
    self.ex = ex
15625 
 
1627 ankur.sing 15626 
  def read(self, iprot):
15627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15629 
      return
15630 
    iprot.readStructBegin()
15631 
    while True:
15632 
      (fname, ftype, fid) = iprot.readFieldBegin()
15633 
      if ftype == TType.STOP:
15634 
        break
3064 chandransh 15635 
      if fid == 1:
15636 
        if ftype == TType.STRUCT:
15637 
          self.ex = TransactionServiceException()
15638 
          self.ex.read(iprot)
15639 
        else:
15640 
          iprot.skip(ftype)
1627 ankur.sing 15641 
      else:
15642 
        iprot.skip(ftype)
15643 
      iprot.readFieldEnd()
15644 
    iprot.readStructEnd()
15645 
 
15646 
  def write(self, oprot):
15647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15649 
      return
4910 phani.kuma 15650 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15651 
    if self.ex is not None:
3064 chandransh 15652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15653 
      self.ex.write(oprot)
15654 
      oprot.writeFieldEnd()
1627 ankur.sing 15655 
    oprot.writeFieldStop()
15656 
    oprot.writeStructEnd()
15657 
 
3431 rajveer 15658 
  def validate(self):
15659 
    return
15660 
 
15661 
 
1627 ankur.sing 15662 
  def __repr__(self):
15663 
    L = ['%s=%r' % (key, value)
15664 
      for key, value in self.__dict__.iteritems()]
15665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15666 
 
15667 
  def __eq__(self, other):
15668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15669 
 
15670 
  def __ne__(self, other):
15671 
    return not (self == other)
15672 
 
4910 phani.kuma 15673 
class getRTOrders_args:
15674 
  """
15675 
  Attributes:
15676 
   - providerId
15677 
  """
15678 
 
15679 
  thrift_spec = (
15680 
    None, # 0
15681 
    (1, TType.I64, 'providerId', None, None, ), # 1
15682 
  )
15683 
 
15684 
  def __init__(self, providerId=None,):
15685 
    self.providerId = providerId
15686 
 
15687 
  def read(self, iprot):
15688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15690 
      return
15691 
    iprot.readStructBegin()
15692 
    while True:
15693 
      (fname, ftype, fid) = iprot.readFieldBegin()
15694 
      if ftype == TType.STOP:
15695 
        break
15696 
      if fid == 1:
15697 
        if ftype == TType.I64:
15698 
          self.providerId = iprot.readI64();
15699 
        else:
15700 
          iprot.skip(ftype)
15701 
      else:
15702 
        iprot.skip(ftype)
15703 
      iprot.readFieldEnd()
15704 
    iprot.readStructEnd()
15705 
 
15706 
  def write(self, oprot):
15707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15709 
      return
15710 
    oprot.writeStructBegin('getRTOrders_args')
15711 
    if self.providerId is not None:
15712 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15713 
      oprot.writeI64(self.providerId)
15714 
      oprot.writeFieldEnd()
15715 
    oprot.writeFieldStop()
15716 
    oprot.writeStructEnd()
15717 
 
15718 
  def validate(self):
15719 
    return
15720 
 
15721 
 
15722 
  def __repr__(self):
15723 
    L = ['%s=%r' % (key, value)
15724 
      for key, value in self.__dict__.iteritems()]
15725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15726 
 
15727 
  def __eq__(self, other):
15728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15729 
 
15730 
  def __ne__(self, other):
15731 
    return not (self == other)
15732 
 
15733 
class getRTOrders_result:
15734 
  """
15735 
  Attributes:
15736 
   - success
15737 
  """
15738 
 
15739 
  thrift_spec = (
15740 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15741 
  )
15742 
 
15743 
  def __init__(self, success=None,):
15744 
    self.success = success
15745 
 
15746 
  def read(self, iprot):
15747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15749 
      return
15750 
    iprot.readStructBegin()
15751 
    while True:
15752 
      (fname, ftype, fid) = iprot.readFieldBegin()
15753 
      if ftype == TType.STOP:
15754 
        break
15755 
      if fid == 0:
15756 
        if ftype == TType.LIST:
15757 
          self.success = []
6188 rajveer 15758 
          (_etype339, _size336) = iprot.readListBegin()
15759 
          for _i340 in xrange(_size336):
15760 
            _elem341 = Order()
15761 
            _elem341.read(iprot)
15762 
            self.success.append(_elem341)
4910 phani.kuma 15763 
          iprot.readListEnd()
15764 
        else:
15765 
          iprot.skip(ftype)
15766 
      else:
15767 
        iprot.skip(ftype)
15768 
      iprot.readFieldEnd()
15769 
    iprot.readStructEnd()
15770 
 
15771 
  def write(self, oprot):
15772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15774 
      return
15775 
    oprot.writeStructBegin('getRTOrders_result')
15776 
    if self.success is not None:
15777 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15778 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15779 
      for iter342 in self.success:
15780 
        iter342.write(oprot)
4910 phani.kuma 15781 
      oprot.writeListEnd()
15782 
      oprot.writeFieldEnd()
15783 
    oprot.writeFieldStop()
15784 
    oprot.writeStructEnd()
15785 
 
15786 
  def validate(self):
15787 
    return
15788 
 
15789 
 
15790 
  def __repr__(self):
15791 
    L = ['%s=%r' % (key, value)
15792 
      for key, value in self.__dict__.iteritems()]
15793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15794 
 
15795 
  def __eq__(self, other):
15796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15797 
 
15798 
  def __ne__(self, other):
15799 
    return not (self == other)
15800 
 
3064 chandransh 15801 
class updateNonDeliveryReason_args:
1627 ankur.sing 15802 
  """
15803 
  Attributes:
3064 chandransh 15804 
   - providerId
15805 
   - undeliveredOrders
1627 ankur.sing 15806 
  """
15807 
 
15808 
  thrift_spec = (
3064 chandransh 15809 
    None, # 0
15810 
    (1, TType.I64, 'providerId', None, None, ), # 1
15811 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15812 
  )
15813 
 
3064 chandransh 15814 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15815 
    self.providerId = providerId
15816 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15817 
 
15818 
  def read(self, iprot):
15819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15821 
      return
15822 
    iprot.readStructBegin()
15823 
    while True:
15824 
      (fname, ftype, fid) = iprot.readFieldBegin()
15825 
      if ftype == TType.STOP:
15826 
        break
3064 chandransh 15827 
      if fid == 1:
1627 ankur.sing 15828 
        if ftype == TType.I64:
3064 chandransh 15829 
          self.providerId = iprot.readI64();
1627 ankur.sing 15830 
        else:
15831 
          iprot.skip(ftype)
3064 chandransh 15832 
      elif fid == 2:
15833 
        if ftype == TType.MAP:
15834 
          self.undeliveredOrders = {}
6188 rajveer 15835 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15836 
          for _i347 in xrange(_size343):
15837 
            _key348 = iprot.readString();
15838 
            _val349 = iprot.readString();
15839 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15840 
          iprot.readMapEnd()
15841 
        else:
15842 
          iprot.skip(ftype)
1627 ankur.sing 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
3064 chandransh 15852 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15853 
    if self.providerId is not None:
3064 chandransh 15854 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15855 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15856 
      oprot.writeFieldEnd()
3431 rajveer 15857 
    if self.undeliveredOrders is not None:
3064 chandransh 15858 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15859 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15860 
      for kiter350,viter351 in self.undeliveredOrders.items():
15861 
        oprot.writeString(kiter350)
15862 
        oprot.writeString(viter351)
3064 chandransh 15863 
      oprot.writeMapEnd()
15864 
      oprot.writeFieldEnd()
1627 ankur.sing 15865 
    oprot.writeFieldStop()
15866 
    oprot.writeStructEnd()
15867 
 
3431 rajveer 15868 
  def validate(self):
15869 
    return
15870 
 
15871 
 
1627 ankur.sing 15872 
  def __repr__(self):
15873 
    L = ['%s=%r' % (key, value)
15874 
      for key, value in self.__dict__.iteritems()]
15875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15876 
 
15877 
  def __eq__(self, other):
15878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15879 
 
15880 
  def __ne__(self, other):
15881 
    return not (self == other)
15882 
 
3064 chandransh 15883 
class updateNonDeliveryReason_result:
1627 ankur.sing 15884 
  """
15885 
  Attributes:
3064 chandransh 15886 
   - ex
1627 ankur.sing 15887 
  """
15888 
 
15889 
  thrift_spec = (
4910 phani.kuma 15890 
    None, # 0
3064 chandransh 15891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15892 
  )
15893 
 
4910 phani.kuma 15894 
  def __init__(self, ex=None,):
3064 chandransh 15895 
    self.ex = ex
1627 ankur.sing 15896 
 
15897 
  def read(self, iprot):
15898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15900 
      return
15901 
    iprot.readStructBegin()
15902 
    while True:
15903 
      (fname, ftype, fid) = iprot.readFieldBegin()
15904 
      if ftype == TType.STOP:
15905 
        break
4910 phani.kuma 15906 
      if fid == 1:
15907 
        if ftype == TType.STRUCT:
15908 
          self.ex = TransactionServiceException()
15909 
          self.ex.read(iprot)
15910 
        else:
15911 
          iprot.skip(ftype)
15912 
      else:
15913 
        iprot.skip(ftype)
15914 
      iprot.readFieldEnd()
15915 
    iprot.readStructEnd()
15916 
 
15917 
  def write(self, oprot):
15918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15920 
      return
15921 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15922 
    if self.ex is not None:
15923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15924 
      self.ex.write(oprot)
15925 
      oprot.writeFieldEnd()
15926 
    oprot.writeFieldStop()
15927 
    oprot.writeStructEnd()
15928 
 
15929 
  def validate(self):
15930 
    return
15931 
 
15932 
 
15933 
  def __repr__(self):
15934 
    L = ['%s=%r' % (key, value)
15935 
      for key, value in self.__dict__.iteritems()]
15936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15937 
 
15938 
  def __eq__(self, other):
15939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15940 
 
15941 
  def __ne__(self, other):
15942 
    return not (self == other)
15943 
 
15944 
class getNonDeliveredOrdersbyCourier_args:
15945 
  """
15946 
  Attributes:
15947 
   - providerId
15948 
  """
15949 
 
15950 
  thrift_spec = (
15951 
    None, # 0
15952 
    (1, TType.I64, 'providerId', None, None, ), # 1
15953 
  )
15954 
 
15955 
  def __init__(self, providerId=None,):
15956 
    self.providerId = providerId
15957 
 
15958 
  def read(self, iprot):
15959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15961 
      return
15962 
    iprot.readStructBegin()
15963 
    while True:
15964 
      (fname, ftype, fid) = iprot.readFieldBegin()
15965 
      if ftype == TType.STOP:
15966 
        break
15967 
      if fid == 1:
15968 
        if ftype == TType.I64:
15969 
          self.providerId = iprot.readI64();
15970 
        else:
15971 
          iprot.skip(ftype)
15972 
      else:
15973 
        iprot.skip(ftype)
15974 
      iprot.readFieldEnd()
15975 
    iprot.readStructEnd()
15976 
 
15977 
  def write(self, oprot):
15978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15980 
      return
15981 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15982 
    if self.providerId is not None:
15983 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15984 
      oprot.writeI64(self.providerId)
15985 
      oprot.writeFieldEnd()
15986 
    oprot.writeFieldStop()
15987 
    oprot.writeStructEnd()
15988 
 
15989 
  def validate(self):
15990 
    return
15991 
 
15992 
 
15993 
  def __repr__(self):
15994 
    L = ['%s=%r' % (key, value)
15995 
      for key, value in self.__dict__.iteritems()]
15996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15997 
 
15998 
  def __eq__(self, other):
15999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16000 
 
16001 
  def __ne__(self, other):
16002 
    return not (self == other)
16003 
 
16004 
class getNonDeliveredOrdersbyCourier_result:
16005 
  """
16006 
  Attributes:
16007 
   - success
16008 
  """
16009 
 
16010 
  thrift_spec = (
16011 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16012 
  )
16013 
 
16014 
  def __init__(self, success=None,):
16015 
    self.success = success
16016 
 
16017 
  def read(self, iprot):
16018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16020 
      return
16021 
    iprot.readStructBegin()
16022 
    while True:
16023 
      (fname, ftype, fid) = iprot.readFieldBegin()
16024 
      if ftype == TType.STOP:
16025 
        break
4581 phani.kuma 16026 
      if fid == 0:
16027 
        if ftype == TType.LIST:
16028 
          self.success = []
6188 rajveer 16029 
          (_etype355, _size352) = iprot.readListBegin()
16030 
          for _i356 in xrange(_size352):
16031 
            _elem357 = Order()
16032 
            _elem357.read(iprot)
16033 
            self.success.append(_elem357)
4581 phani.kuma 16034 
          iprot.readListEnd()
16035 
        else:
16036 
          iprot.skip(ftype)
4910 phani.kuma 16037 
      else:
16038 
        iprot.skip(ftype)
16039 
      iprot.readFieldEnd()
16040 
    iprot.readStructEnd()
16041 
 
16042 
  def write(self, oprot):
16043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16045 
      return
16046 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16047 
    if self.success is not None:
16048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16050 
      for iter358 in self.success:
16051 
        iter358.write(oprot)
4910 phani.kuma 16052 
      oprot.writeListEnd()
16053 
      oprot.writeFieldEnd()
16054 
    oprot.writeFieldStop()
16055 
    oprot.writeStructEnd()
16056 
 
16057 
  def validate(self):
16058 
    return
16059 
 
16060 
 
16061 
  def __repr__(self):
16062 
    L = ['%s=%r' % (key, value)
16063 
      for key, value in self.__dict__.iteritems()]
16064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16065 
 
16066 
  def __eq__(self, other):
16067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16068 
 
16069 
  def __ne__(self, other):
16070 
    return not (self == other)
16071 
 
16072 
class markOrdersAsLocalConnected_args:
16073 
  """
16074 
  Attributes:
16075 
   - providerId
16076 
   - local_connected_orders
16077 
  """
16078 
 
16079 
  thrift_spec = (
16080 
    None, # 0
16081 
    (1, TType.I64, 'providerId', None, None, ), # 1
16082 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16083 
  )
16084 
 
16085 
  def __init__(self, providerId=None, local_connected_orders=None,):
16086 
    self.providerId = providerId
16087 
    self.local_connected_orders = local_connected_orders
16088 
 
16089 
  def read(self, iprot):
16090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16092 
      return
16093 
    iprot.readStructBegin()
16094 
    while True:
16095 
      (fname, ftype, fid) = iprot.readFieldBegin()
16096 
      if ftype == TType.STOP:
16097 
        break
16098 
      if fid == 1:
16099 
        if ftype == TType.I64:
16100 
          self.providerId = iprot.readI64();
16101 
        else:
16102 
          iprot.skip(ftype)
16103 
      elif fid == 2:
16104 
        if ftype == TType.MAP:
16105 
          self.local_connected_orders = {}
6188 rajveer 16106 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16107 
          for _i363 in xrange(_size359):
16108 
            _key364 = iprot.readString();
16109 
            _val365 = iprot.readString();
16110 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16111 
          iprot.readMapEnd()
16112 
        else:
16113 
          iprot.skip(ftype)
16114 
      else:
16115 
        iprot.skip(ftype)
16116 
      iprot.readFieldEnd()
16117 
    iprot.readStructEnd()
16118 
 
16119 
  def write(self, oprot):
16120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16122 
      return
16123 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16124 
    if self.providerId is not None:
16125 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16126 
      oprot.writeI64(self.providerId)
16127 
      oprot.writeFieldEnd()
16128 
    if self.local_connected_orders is not None:
16129 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16130 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16131 
      for kiter366,viter367 in self.local_connected_orders.items():
16132 
        oprot.writeString(kiter366)
16133 
        oprot.writeString(viter367)
4910 phani.kuma 16134 
      oprot.writeMapEnd()
16135 
      oprot.writeFieldEnd()
16136 
    oprot.writeFieldStop()
16137 
    oprot.writeStructEnd()
16138 
 
16139 
  def validate(self):
16140 
    return
16141 
 
16142 
 
16143 
  def __repr__(self):
16144 
    L = ['%s=%r' % (key, value)
16145 
      for key, value in self.__dict__.iteritems()]
16146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16147 
 
16148 
  def __eq__(self, other):
16149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16150 
 
16151 
  def __ne__(self, other):
16152 
    return not (self == other)
16153 
 
16154 
class markOrdersAsLocalConnected_result:
16155 
  """
16156 
  Attributes:
16157 
   - ex
16158 
  """
16159 
 
16160 
  thrift_spec = (
16161 
    None, # 0
16162 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16163 
  )
16164 
 
16165 
  def __init__(self, ex=None,):
16166 
    self.ex = ex
16167 
 
16168 
  def read(self, iprot):
16169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16171 
      return
16172 
    iprot.readStructBegin()
16173 
    while True:
16174 
      (fname, ftype, fid) = iprot.readFieldBegin()
16175 
      if ftype == TType.STOP:
16176 
        break
16177 
      if fid == 1:
3064 chandransh 16178 
        if ftype == TType.STRUCT:
16179 
          self.ex = TransactionServiceException()
16180 
          self.ex.read(iprot)
1627 ankur.sing 16181 
        else:
16182 
          iprot.skip(ftype)
16183 
      else:
16184 
        iprot.skip(ftype)
16185 
      iprot.readFieldEnd()
16186 
    iprot.readStructEnd()
16187 
 
16188 
  def write(self, oprot):
16189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16191 
      return
4910 phani.kuma 16192 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16193 
    if self.ex is not None:
16194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16195 
      self.ex.write(oprot)
16196 
      oprot.writeFieldEnd()
16197 
    oprot.writeFieldStop()
16198 
    oprot.writeStructEnd()
16199 
 
16200 
  def validate(self):
16201 
    return
16202 
 
16203 
 
16204 
  def __repr__(self):
16205 
    L = ['%s=%r' % (key, value)
16206 
      for key, value in self.__dict__.iteritems()]
16207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16208 
 
16209 
  def __eq__(self, other):
16210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16211 
 
16212 
  def __ne__(self, other):
16213 
    return not (self == other)
16214 
 
16215 
class getOrdersNotLocalConnected_args:
16216 
  """
16217 
  Attributes:
16218 
   - providerId
16219 
  """
16220 
 
16221 
  thrift_spec = (
16222 
    None, # 0
16223 
    (1, TType.I64, 'providerId', None, None, ), # 1
16224 
  )
16225 
 
16226 
  def __init__(self, providerId=None,):
16227 
    self.providerId = providerId
16228 
 
16229 
  def read(self, iprot):
16230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16232 
      return
16233 
    iprot.readStructBegin()
16234 
    while True:
16235 
      (fname, ftype, fid) = iprot.readFieldBegin()
16236 
      if ftype == TType.STOP:
16237 
        break
16238 
      if fid == 1:
16239 
        if ftype == TType.I64:
16240 
          self.providerId = iprot.readI64();
16241 
        else:
16242 
          iprot.skip(ftype)
16243 
      else:
16244 
        iprot.skip(ftype)
16245 
      iprot.readFieldEnd()
16246 
    iprot.readStructEnd()
16247 
 
16248 
  def write(self, oprot):
16249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16251 
      return
16252 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16253 
    if self.providerId is not None:
16254 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16255 
      oprot.writeI64(self.providerId)
16256 
      oprot.writeFieldEnd()
16257 
    oprot.writeFieldStop()
16258 
    oprot.writeStructEnd()
16259 
 
16260 
  def validate(self):
16261 
    return
16262 
 
16263 
 
16264 
  def __repr__(self):
16265 
    L = ['%s=%r' % (key, value)
16266 
      for key, value in self.__dict__.iteritems()]
16267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16268 
 
16269 
  def __eq__(self, other):
16270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16271 
 
16272 
  def __ne__(self, other):
16273 
    return not (self == other)
16274 
 
16275 
class getOrdersNotLocalConnected_result:
16276 
  """
16277 
  Attributes:
16278 
   - success
16279 
  """
16280 
 
16281 
  thrift_spec = (
16282 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16283 
  )
16284 
 
16285 
  def __init__(self, success=None,):
16286 
    self.success = success
16287 
 
16288 
  def read(self, iprot):
16289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16291 
      return
16292 
    iprot.readStructBegin()
16293 
    while True:
16294 
      (fname, ftype, fid) = iprot.readFieldBegin()
16295 
      if ftype == TType.STOP:
16296 
        break
16297 
      if fid == 0:
16298 
        if ftype == TType.LIST:
16299 
          self.success = []
6188 rajveer 16300 
          (_etype371, _size368) = iprot.readListBegin()
16301 
          for _i372 in xrange(_size368):
16302 
            _elem373 = Order()
16303 
            _elem373.read(iprot)
16304 
            self.success.append(_elem373)
4910 phani.kuma 16305 
          iprot.readListEnd()
16306 
        else:
16307 
          iprot.skip(ftype)
16308 
      else:
16309 
        iprot.skip(ftype)
16310 
      iprot.readFieldEnd()
16311 
    iprot.readStructEnd()
16312 
 
16313 
  def write(self, oprot):
16314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16316 
      return
16317 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16318 
    if self.success is not None:
16319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16321 
      for iter374 in self.success:
16322 
        iter374.write(oprot)
4581 phani.kuma 16323 
      oprot.writeListEnd()
16324 
      oprot.writeFieldEnd()
4910 phani.kuma 16325 
    oprot.writeFieldStop()
16326 
    oprot.writeStructEnd()
16327 
 
16328 
  def validate(self):
16329 
    return
16330 
 
16331 
 
16332 
  def __repr__(self):
16333 
    L = ['%s=%r' % (key, value)
16334 
      for key, value in self.__dict__.iteritems()]
16335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16336 
 
16337 
  def __eq__(self, other):
16338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16339 
 
16340 
  def __ne__(self, other):
16341 
    return not (self == other)
16342 
 
16343 
class markOrdersAsDestinationCityReached_args:
16344 
  """
16345 
  Attributes:
16346 
   - providerId
16347 
   - destination_city_reached_orders
16348 
  """
16349 
 
16350 
  thrift_spec = (
16351 
    None, # 0
16352 
    (1, TType.I64, 'providerId', None, None, ), # 1
16353 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16354 
  )
16355 
 
16356 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16357 
    self.providerId = providerId
16358 
    self.destination_city_reached_orders = destination_city_reached_orders
16359 
 
16360 
  def read(self, iprot):
16361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16363 
      return
16364 
    iprot.readStructBegin()
16365 
    while True:
16366 
      (fname, ftype, fid) = iprot.readFieldBegin()
16367 
      if ftype == TType.STOP:
16368 
        break
16369 
      if fid == 1:
16370 
        if ftype == TType.I64:
16371 
          self.providerId = iprot.readI64();
16372 
        else:
16373 
          iprot.skip(ftype)
16374 
      elif fid == 2:
16375 
        if ftype == TType.MAP:
16376 
          self.destination_city_reached_orders = {}
6188 rajveer 16377 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16378 
          for _i379 in xrange(_size375):
16379 
            _key380 = iprot.readString();
16380 
            _val381 = iprot.readString();
16381 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16382 
          iprot.readMapEnd()
16383 
        else:
16384 
          iprot.skip(ftype)
16385 
      else:
16386 
        iprot.skip(ftype)
16387 
      iprot.readFieldEnd()
16388 
    iprot.readStructEnd()
16389 
 
16390 
  def write(self, oprot):
16391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16393 
      return
16394 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16395 
    if self.providerId is not None:
16396 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16397 
      oprot.writeI64(self.providerId)
16398 
      oprot.writeFieldEnd()
16399 
    if self.destination_city_reached_orders is not None:
16400 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16401 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16402 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16403 
        oprot.writeString(kiter382)
16404 
        oprot.writeString(viter383)
4910 phani.kuma 16405 
      oprot.writeMapEnd()
16406 
      oprot.writeFieldEnd()
16407 
    oprot.writeFieldStop()
16408 
    oprot.writeStructEnd()
16409 
 
16410 
  def validate(self):
16411 
    return
16412 
 
16413 
 
16414 
  def __repr__(self):
16415 
    L = ['%s=%r' % (key, value)
16416 
      for key, value in self.__dict__.iteritems()]
16417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16418 
 
16419 
  def __eq__(self, other):
16420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16421 
 
16422 
  def __ne__(self, other):
16423 
    return not (self == other)
16424 
 
16425 
class markOrdersAsDestinationCityReached_result:
16426 
  """
16427 
  Attributes:
16428 
   - ex
16429 
  """
16430 
 
16431 
  thrift_spec = (
16432 
    None, # 0
16433 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16434 
  )
16435 
 
16436 
  def __init__(self, ex=None,):
16437 
    self.ex = ex
16438 
 
16439 
  def read(self, iprot):
16440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16442 
      return
16443 
    iprot.readStructBegin()
16444 
    while True:
16445 
      (fname, ftype, fid) = iprot.readFieldBegin()
16446 
      if ftype == TType.STOP:
16447 
        break
16448 
      if fid == 1:
16449 
        if ftype == TType.STRUCT:
16450 
          self.ex = TransactionServiceException()
16451 
          self.ex.read(iprot)
16452 
        else:
16453 
          iprot.skip(ftype)
16454 
      else:
16455 
        iprot.skip(ftype)
16456 
      iprot.readFieldEnd()
16457 
    iprot.readStructEnd()
16458 
 
16459 
  def write(self, oprot):
16460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16462 
      return
16463 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16464 
    if self.ex is not None:
3064 chandransh 16465 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16466 
      self.ex.write(oprot)
1627 ankur.sing 16467 
      oprot.writeFieldEnd()
16468 
    oprot.writeFieldStop()
16469 
    oprot.writeStructEnd()
16470 
 
3431 rajveer 16471 
  def validate(self):
16472 
    return
16473 
 
16474 
 
1627 ankur.sing 16475 
  def __repr__(self):
16476 
    L = ['%s=%r' % (key, value)
16477 
      for key, value in self.__dict__.iteritems()]
16478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16479 
 
16480 
  def __eq__(self, other):
16481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16482 
 
16483 
  def __ne__(self, other):
16484 
    return not (self == other)
16485 
 
4910 phani.kuma 16486 
class markOrdersAsFirstDeliveryAttempted_args:
16487 
  """
16488 
  Attributes:
16489 
   - providerId
16490 
   - first_atdl_orders
16491 
  """
16492 
 
16493 
  thrift_spec = (
16494 
    None, # 0
16495 
    (1, TType.I64, 'providerId', None, None, ), # 1
16496 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16497 
  )
16498 
 
16499 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16500 
    self.providerId = providerId
16501 
    self.first_atdl_orders = first_atdl_orders
16502 
 
16503 
  def read(self, iprot):
16504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16506 
      return
16507 
    iprot.readStructBegin()
16508 
    while True:
16509 
      (fname, ftype, fid) = iprot.readFieldBegin()
16510 
      if ftype == TType.STOP:
16511 
        break
16512 
      if fid == 1:
16513 
        if ftype == TType.I64:
16514 
          self.providerId = iprot.readI64();
16515 
        else:
16516 
          iprot.skip(ftype)
16517 
      elif fid == 2:
16518 
        if ftype == TType.MAP:
16519 
          self.first_atdl_orders = {}
6188 rajveer 16520 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16521 
          for _i388 in xrange(_size384):
16522 
            _key389 = iprot.readString();
16523 
            _val390 = iprot.readString();
16524 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16525 
          iprot.readMapEnd()
16526 
        else:
16527 
          iprot.skip(ftype)
16528 
      else:
16529 
        iprot.skip(ftype)
16530 
      iprot.readFieldEnd()
16531 
    iprot.readStructEnd()
16532 
 
16533 
  def write(self, oprot):
16534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16536 
      return
16537 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16538 
    if self.providerId is not None:
16539 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16540 
      oprot.writeI64(self.providerId)
16541 
      oprot.writeFieldEnd()
16542 
    if self.first_atdl_orders is not None:
16543 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16544 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16545 
      for kiter391,viter392 in self.first_atdl_orders.items():
16546 
        oprot.writeString(kiter391)
16547 
        oprot.writeString(viter392)
4910 phani.kuma 16548 
      oprot.writeMapEnd()
16549 
      oprot.writeFieldEnd()
16550 
    oprot.writeFieldStop()
16551 
    oprot.writeStructEnd()
16552 
 
16553 
  def validate(self):
16554 
    return
16555 
 
16556 
 
16557 
  def __repr__(self):
16558 
    L = ['%s=%r' % (key, value)
16559 
      for key, value in self.__dict__.iteritems()]
16560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16561 
 
16562 
  def __eq__(self, other):
16563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16564 
 
16565 
  def __ne__(self, other):
16566 
    return not (self == other)
16567 
 
16568 
class markOrdersAsFirstDeliveryAttempted_result:
16569 
  """
16570 
  Attributes:
16571 
   - ex
16572 
  """
16573 
 
16574 
  thrift_spec = (
16575 
    None, # 0
16576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16577 
  )
16578 
 
16579 
  def __init__(self, ex=None,):
16580 
    self.ex = ex
16581 
 
16582 
  def read(self, iprot):
16583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16585 
      return
16586 
    iprot.readStructBegin()
16587 
    while True:
16588 
      (fname, ftype, fid) = iprot.readFieldBegin()
16589 
      if ftype == TType.STOP:
16590 
        break
16591 
      if fid == 1:
16592 
        if ftype == TType.STRUCT:
16593 
          self.ex = TransactionServiceException()
16594 
          self.ex.read(iprot)
16595 
        else:
16596 
          iprot.skip(ftype)
16597 
      else:
16598 
        iprot.skip(ftype)
16599 
      iprot.readFieldEnd()
16600 
    iprot.readStructEnd()
16601 
 
16602 
  def write(self, oprot):
16603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16605 
      return
16606 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16607 
    if self.ex is not None:
16608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16609 
      self.ex.write(oprot)
16610 
      oprot.writeFieldEnd()
16611 
    oprot.writeFieldStop()
16612 
    oprot.writeStructEnd()
16613 
 
16614 
  def validate(self):
16615 
    return
16616 
 
16617 
 
16618 
  def __repr__(self):
16619 
    L = ['%s=%r' % (key, value)
16620 
      for key, value in self.__dict__.iteritems()]
16621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16622 
 
16623 
  def __eq__(self, other):
16624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16625 
 
16626 
  def __ne__(self, other):
16627 
    return not (self == other)
16628 
 
3064 chandransh 16629 
class getUndeliveredOrders_args:
1886 ankur.sing 16630 
  """
16631 
  Attributes:
3064 chandransh 16632 
   - providerId
16633 
   - warehouseId
1886 ankur.sing 16634 
  """
1627 ankur.sing 16635 
 
1886 ankur.sing 16636 
  thrift_spec = (
16637 
    None, # 0
3064 chandransh 16638 
    (1, TType.I64, 'providerId', None, None, ), # 1
16639 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16640 
  )
16641 
 
3064 chandransh 16642 
  def __init__(self, providerId=None, warehouseId=None,):
16643 
    self.providerId = providerId
16644 
    self.warehouseId = warehouseId
1886 ankur.sing 16645 
 
16646 
  def read(self, iprot):
16647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16649 
      return
16650 
    iprot.readStructBegin()
16651 
    while True:
16652 
      (fname, ftype, fid) = iprot.readFieldBegin()
16653 
      if ftype == TType.STOP:
16654 
        break
16655 
      if fid == 1:
16656 
        if ftype == TType.I64:
3064 chandransh 16657 
          self.providerId = iprot.readI64();
1886 ankur.sing 16658 
        else:
16659 
          iprot.skip(ftype)
3064 chandransh 16660 
      elif fid == 2:
16661 
        if ftype == TType.I64:
16662 
          self.warehouseId = iprot.readI64();
16663 
        else:
16664 
          iprot.skip(ftype)
1886 ankur.sing 16665 
      else:
16666 
        iprot.skip(ftype)
16667 
      iprot.readFieldEnd()
16668 
    iprot.readStructEnd()
16669 
 
16670 
  def write(self, oprot):
16671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16673 
      return
3064 chandransh 16674 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16675 
    if self.providerId is not None:
3064 chandransh 16676 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16677 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16678 
      oprot.writeFieldEnd()
3431 rajveer 16679 
    if self.warehouseId is not None:
3064 chandransh 16680 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16681 
      oprot.writeI64(self.warehouseId)
16682 
      oprot.writeFieldEnd()
1886 ankur.sing 16683 
    oprot.writeFieldStop()
16684 
    oprot.writeStructEnd()
16685 
 
3431 rajveer 16686 
  def validate(self):
16687 
    return
16688 
 
16689 
 
1886 ankur.sing 16690 
  def __repr__(self):
16691 
    L = ['%s=%r' % (key, value)
16692 
      for key, value in self.__dict__.iteritems()]
16693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16694 
 
16695 
  def __eq__(self, other):
16696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16697 
 
16698 
  def __ne__(self, other):
16699 
    return not (self == other)
16700 
 
3064 chandransh 16701 
class getUndeliveredOrders_result:
1886 ankur.sing 16702 
  """
16703 
  Attributes:
16704 
   - success
16705 
  """
16706 
 
16707 
  thrift_spec = (
16708 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16709 
  )
16710 
 
16711 
  def __init__(self, success=None,):
16712 
    self.success = success
16713 
 
16714 
  def read(self, iprot):
16715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16717 
      return
16718 
    iprot.readStructBegin()
16719 
    while True:
16720 
      (fname, ftype, fid) = iprot.readFieldBegin()
16721 
      if ftype == TType.STOP:
16722 
        break
16723 
      if fid == 0:
16724 
        if ftype == TType.LIST:
16725 
          self.success = []
6188 rajveer 16726 
          (_etype396, _size393) = iprot.readListBegin()
16727 
          for _i397 in xrange(_size393):
16728 
            _elem398 = Order()
16729 
            _elem398.read(iprot)
16730 
            self.success.append(_elem398)
1886 ankur.sing 16731 
          iprot.readListEnd()
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      else:
16735 
        iprot.skip(ftype)
16736 
      iprot.readFieldEnd()
16737 
    iprot.readStructEnd()
16738 
 
16739 
  def write(self, oprot):
16740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16742 
      return
3064 chandransh 16743 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16744 
    if self.success is not None:
1886 ankur.sing 16745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16747 
      for iter399 in self.success:
16748 
        iter399.write(oprot)
1886 ankur.sing 16749 
      oprot.writeListEnd()
16750 
      oprot.writeFieldEnd()
16751 
    oprot.writeFieldStop()
16752 
    oprot.writeStructEnd()
16753 
 
3431 rajveer 16754 
  def validate(self):
16755 
    return
16756 
 
16757 
 
1886 ankur.sing 16758 
  def __repr__(self):
16759 
    L = ['%s=%r' % (key, value)
16760 
      for key, value in self.__dict__.iteritems()]
16761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16762 
 
16763 
  def __eq__(self, other):
16764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16765 
 
16766 
  def __ne__(self, other):
16767 
    return not (self == other)
16768 
 
4783 phani.kuma 16769 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16770 
 
16771 
  thrift_spec = (
16772 
  )
16773 
 
16774 
  def read(self, iprot):
16775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16777 
      return
16778 
    iprot.readStructBegin()
16779 
    while True:
16780 
      (fname, ftype, fid) = iprot.readFieldBegin()
16781 
      if ftype == TType.STOP:
16782 
        break
16783 
      else:
16784 
        iprot.skip(ftype)
16785 
      iprot.readFieldEnd()
16786 
    iprot.readStructEnd()
16787 
 
16788 
  def write(self, oprot):
16789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16791 
      return
16792 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16793 
    oprot.writeFieldStop()
16794 
    oprot.writeStructEnd()
16795 
 
16796 
  def validate(self):
16797 
    return
16798 
 
16799 
 
16800 
  def __repr__(self):
16801 
    L = ['%s=%r' % (key, value)
16802 
      for key, value in self.__dict__.iteritems()]
16803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16804 
 
16805 
  def __eq__(self, other):
16806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16807 
 
16808 
  def __ne__(self, other):
16809 
    return not (self == other)
16810 
 
16811 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16812 
  """
16813 
  Attributes:
16814 
   - success
16815 
  """
16816 
 
16817 
  thrift_spec = (
16818 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16819 
  )
16820 
 
16821 
  def __init__(self, success=None,):
16822 
    self.success = success
16823 
 
16824 
  def read(self, iprot):
16825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16827 
      return
16828 
    iprot.readStructBegin()
16829 
    while True:
16830 
      (fname, ftype, fid) = iprot.readFieldBegin()
16831 
      if ftype == TType.STOP:
16832 
        break
16833 
      if fid == 0:
16834 
        if ftype == TType.LIST:
16835 
          self.success = []
6188 rajveer 16836 
          (_etype403, _size400) = iprot.readListBegin()
16837 
          for _i404 in xrange(_size400):
16838 
            _elem405 = Order()
16839 
            _elem405.read(iprot)
16840 
            self.success.append(_elem405)
4783 phani.kuma 16841 
          iprot.readListEnd()
16842 
        else:
16843 
          iprot.skip(ftype)
16844 
      else:
16845 
        iprot.skip(ftype)
16846 
      iprot.readFieldEnd()
16847 
    iprot.readStructEnd()
16848 
 
16849 
  def write(self, oprot):
16850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16852 
      return
16853 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16854 
    if self.success is not None:
16855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16857 
      for iter406 in self.success:
16858 
        iter406.write(oprot)
4783 phani.kuma 16859 
      oprot.writeListEnd()
16860 
      oprot.writeFieldEnd()
16861 
    oprot.writeFieldStop()
16862 
    oprot.writeStructEnd()
16863 
 
16864 
  def validate(self):
16865 
    return
16866 
 
16867 
 
16868 
  def __repr__(self):
16869 
    L = ['%s=%r' % (key, value)
16870 
      for key, value in self.__dict__.iteritems()]
16871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16872 
 
16873 
  def __eq__(self, other):
16874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16875 
 
16876 
  def __ne__(self, other):
16877 
    return not (self == other)
16878 
 
2536 chandransh 16879 
class toggleDOAFlag_args:
16880 
  """
16881 
  Attributes:
16882 
   - orderId
16883 
  """
1886 ankur.sing 16884 
 
2536 chandransh 16885 
  thrift_spec = (
16886 
    None, # 0
16887 
    (1, TType.I64, 'orderId', None, None, ), # 1
16888 
  )
16889 
 
16890 
  def __init__(self, orderId=None,):
16891 
    self.orderId = orderId
16892 
 
16893 
  def read(self, iprot):
16894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16896 
      return
16897 
    iprot.readStructBegin()
16898 
    while True:
16899 
      (fname, ftype, fid) = iprot.readFieldBegin()
16900 
      if ftype == TType.STOP:
16901 
        break
16902 
      if fid == 1:
16903 
        if ftype == TType.I64:
16904 
          self.orderId = iprot.readI64();
16905 
        else:
16906 
          iprot.skip(ftype)
16907 
      else:
16908 
        iprot.skip(ftype)
16909 
      iprot.readFieldEnd()
16910 
    iprot.readStructEnd()
16911 
 
16912 
  def write(self, oprot):
16913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16915 
      return
16916 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16917 
    if self.orderId is not None:
2536 chandransh 16918 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16919 
      oprot.writeI64(self.orderId)
16920 
      oprot.writeFieldEnd()
16921 
    oprot.writeFieldStop()
16922 
    oprot.writeStructEnd()
16923 
 
3431 rajveer 16924 
  def validate(self):
16925 
    return
16926 
 
16927 
 
2536 chandransh 16928 
  def __repr__(self):
16929 
    L = ['%s=%r' % (key, value)
16930 
      for key, value in self.__dict__.iteritems()]
16931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16932 
 
16933 
  def __eq__(self, other):
16934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16935 
 
16936 
  def __ne__(self, other):
16937 
    return not (self == other)
16938 
 
16939 
class toggleDOAFlag_result:
16940 
  """
16941 
  Attributes:
16942 
   - success
16943 
   - ex
16944 
  """
16945 
 
16946 
  thrift_spec = (
16947 
    (0, TType.BOOL, 'success', None, None, ), # 0
16948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16949 
  )
16950 
 
16951 
  def __init__(self, success=None, ex=None,):
16952 
    self.success = success
16953 
    self.ex = ex
16954 
 
16955 
  def read(self, iprot):
16956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16958 
      return
16959 
    iprot.readStructBegin()
16960 
    while True:
16961 
      (fname, ftype, fid) = iprot.readFieldBegin()
16962 
      if ftype == TType.STOP:
16963 
        break
16964 
      if fid == 0:
16965 
        if ftype == TType.BOOL:
16966 
          self.success = iprot.readBool();
16967 
        else:
16968 
          iprot.skip(ftype)
16969 
      elif fid == 1:
16970 
        if ftype == TType.STRUCT:
16971 
          self.ex = TransactionServiceException()
16972 
          self.ex.read(iprot)
16973 
        else:
16974 
          iprot.skip(ftype)
16975 
      else:
16976 
        iprot.skip(ftype)
16977 
      iprot.readFieldEnd()
16978 
    iprot.readStructEnd()
16979 
 
16980 
  def write(self, oprot):
16981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16983 
      return
16984 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16985 
    if self.success is not None:
2536 chandransh 16986 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16987 
      oprot.writeBool(self.success)
16988 
      oprot.writeFieldEnd()
3431 rajveer 16989 
    if self.ex is not None:
2536 chandransh 16990 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16991 
      self.ex.write(oprot)
16992 
      oprot.writeFieldEnd()
16993 
    oprot.writeFieldStop()
16994 
    oprot.writeStructEnd()
16995 
 
3431 rajveer 16996 
  def validate(self):
16997 
    return
16998 
 
16999 
 
2536 chandransh 17000 
  def __repr__(self):
17001 
    L = ['%s=%r' % (key, value)
17002 
      for key, value in self.__dict__.iteritems()]
17003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17004 
 
17005 
  def __eq__(self, other):
17006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17007 
 
17008 
  def __ne__(self, other):
17009 
    return not (self == other)
17010 
 
4712 rajveer 17011 
class markOrderAsDelivered_args:
17012 
  """
17013 
  Attributes:
17014 
   - orderId
17015 
   - deliveryTimestamp
17016 
   - receiver
17017 
  """
17018 
 
17019 
  thrift_spec = None
17020 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17021 
    self.orderId = orderId
17022 
    self.deliveryTimestamp = deliveryTimestamp
17023 
    self.receiver = receiver
17024 
 
17025 
  def read(self, iprot):
17026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17028 
      return
17029 
    iprot.readStructBegin()
17030 
    while True:
17031 
      (fname, ftype, fid) = iprot.readFieldBegin()
17032 
      if ftype == TType.STOP:
17033 
        break
17034 
      if fid == 1:
17035 
        if ftype == TType.I64:
17036 
          self.orderId = iprot.readI64();
17037 
        else:
17038 
          iprot.skip(ftype)
17039 
      elif fid == 2:
17040 
        if ftype == TType.I64:
17041 
          self.deliveryTimestamp = iprot.readI64();
17042 
        else:
17043 
          iprot.skip(ftype)
17044 
      elif fid == -1:
17045 
        if ftype == TType.STRING:
17046 
          self.receiver = iprot.readString();
17047 
        else:
17048 
          iprot.skip(ftype)
17049 
      else:
17050 
        iprot.skip(ftype)
17051 
      iprot.readFieldEnd()
17052 
    iprot.readStructEnd()
17053 
 
17054 
  def write(self, oprot):
17055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17057 
      return
17058 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17059 
    if self.receiver is not None:
17060 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17061 
      oprot.writeString(self.receiver)
17062 
      oprot.writeFieldEnd()
17063 
    if self.orderId is not None:
17064 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17065 
      oprot.writeI64(self.orderId)
17066 
      oprot.writeFieldEnd()
17067 
    if self.deliveryTimestamp is not None:
17068 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17069 
      oprot.writeI64(self.deliveryTimestamp)
17070 
      oprot.writeFieldEnd()
17071 
    oprot.writeFieldStop()
17072 
    oprot.writeStructEnd()
17073 
 
17074 
  def validate(self):
17075 
    return
17076 
 
17077 
 
17078 
  def __repr__(self):
17079 
    L = ['%s=%r' % (key, value)
17080 
      for key, value in self.__dict__.iteritems()]
17081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17082 
 
17083 
  def __eq__(self, other):
17084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17085 
 
17086 
  def __ne__(self, other):
17087 
    return not (self == other)
17088 
 
17089 
class markOrderAsDelivered_result:
17090 
  """
17091 
  Attributes:
17092 
   - ex
17093 
  """
17094 
 
17095 
  thrift_spec = (
17096 
    None, # 0
17097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17098 
  )
17099 
 
17100 
  def __init__(self, ex=None,):
17101 
    self.ex = ex
17102 
 
17103 
  def read(self, iprot):
17104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17106 
      return
17107 
    iprot.readStructBegin()
17108 
    while True:
17109 
      (fname, ftype, fid) = iprot.readFieldBegin()
17110 
      if ftype == TType.STOP:
17111 
        break
17112 
      if fid == 1:
17113 
        if ftype == TType.STRUCT:
17114 
          self.ex = TransactionServiceException()
17115 
          self.ex.read(iprot)
17116 
        else:
17117 
          iprot.skip(ftype)
17118 
      else:
17119 
        iprot.skip(ftype)
17120 
      iprot.readFieldEnd()
17121 
    iprot.readStructEnd()
17122 
 
17123 
  def write(self, oprot):
17124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17126 
      return
17127 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17128 
    if self.ex is not None:
17129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17130 
      self.ex.write(oprot)
17131 
      oprot.writeFieldEnd()
17132 
    oprot.writeFieldStop()
17133 
    oprot.writeStructEnd()
17134 
 
17135 
  def validate(self):
17136 
    return
17137 
 
17138 
 
17139 
  def __repr__(self):
17140 
    L = ['%s=%r' % (key, value)
17141 
      for key, value in self.__dict__.iteritems()]
17142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17143 
 
17144 
  def __eq__(self, other):
17145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17146 
 
17147 
  def __ne__(self, other):
17148 
    return not (self == other)
17149 
 
5553 rajveer 17150 
class markOrderAsReceivedAtStore_args:
17151 
  """
17152 
  Attributes:
17153 
   - orderId
17154 
   - deliveryTimestamp
17155 
  """
17156 
 
17157 
  thrift_spec = (
17158 
    None, # 0
17159 
    (1, TType.I64, 'orderId', None, None, ), # 1
17160 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17161 
  )
17162 
 
17163 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17164 
    self.orderId = orderId
17165 
    self.deliveryTimestamp = deliveryTimestamp
17166 
 
17167 
  def read(self, iprot):
17168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17170 
      return
17171 
    iprot.readStructBegin()
17172 
    while True:
17173 
      (fname, ftype, fid) = iprot.readFieldBegin()
17174 
      if ftype == TType.STOP:
17175 
        break
17176 
      if fid == 1:
17177 
        if ftype == TType.I64:
17178 
          self.orderId = iprot.readI64();
17179 
        else:
17180 
          iprot.skip(ftype)
17181 
      elif fid == 2:
17182 
        if ftype == TType.I64:
17183 
          self.deliveryTimestamp = iprot.readI64();
17184 
        else:
17185 
          iprot.skip(ftype)
17186 
      else:
17187 
        iprot.skip(ftype)
17188 
      iprot.readFieldEnd()
17189 
    iprot.readStructEnd()
17190 
 
17191 
  def write(self, oprot):
17192 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17193 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17194 
      return
17195 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17196 
    if self.orderId is not None:
17197 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17198 
      oprot.writeI64(self.orderId)
17199 
      oprot.writeFieldEnd()
17200 
    if self.deliveryTimestamp is not None:
17201 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17202 
      oprot.writeI64(self.deliveryTimestamp)
17203 
      oprot.writeFieldEnd()
17204 
    oprot.writeFieldStop()
17205 
    oprot.writeStructEnd()
17206 
 
17207 
  def validate(self):
17208 
    return
17209 
 
17210 
 
17211 
  def __repr__(self):
17212 
    L = ['%s=%r' % (key, value)
17213 
      for key, value in self.__dict__.iteritems()]
17214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17215 
 
17216 
  def __eq__(self, other):
17217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17218 
 
17219 
  def __ne__(self, other):
17220 
    return not (self == other)
17221 
 
17222 
class markOrderAsReceivedAtStore_result:
17223 
  """
17224 
  Attributes:
17225 
   - ex
17226 
  """
17227 
 
17228 
  thrift_spec = (
17229 
    None, # 0
17230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17231 
  )
17232 
 
17233 
  def __init__(self, ex=None,):
17234 
    self.ex = ex
17235 
 
17236 
  def read(self, iprot):
17237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17239 
      return
17240 
    iprot.readStructBegin()
17241 
    while True:
17242 
      (fname, ftype, fid) = iprot.readFieldBegin()
17243 
      if ftype == TType.STOP:
17244 
        break
17245 
      if fid == 1:
17246 
        if ftype == TType.STRUCT:
17247 
          self.ex = TransactionServiceException()
17248 
          self.ex.read(iprot)
17249 
        else:
17250 
          iprot.skip(ftype)
17251 
      else:
17252 
        iprot.skip(ftype)
17253 
      iprot.readFieldEnd()
17254 
    iprot.readStructEnd()
17255 
 
17256 
  def write(self, oprot):
17257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17259 
      return
17260 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17261 
    if self.ex is not None:
17262 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17263 
      self.ex.write(oprot)
17264 
      oprot.writeFieldEnd()
17265 
    oprot.writeFieldStop()
17266 
    oprot.writeStructEnd()
17267 
 
17268 
  def validate(self):
17269 
    return
17270 
 
17271 
 
17272 
  def __repr__(self):
17273 
    L = ['%s=%r' % (key, value)
17274 
      for key, value in self.__dict__.iteritems()]
17275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17276 
 
17277 
  def __eq__(self, other):
17278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17279 
 
17280 
  def __ne__(self, other):
17281 
    return not (self == other)
17282 
 
4454 rajveer 17283 
class markOrderDoaRequestReceived_args:
17284 
  """
17285 
  Attributes:
17286 
   - orderId
17287 
  """
17288 
 
17289 
  thrift_spec = (
17290 
    None, # 0
17291 
    (1, TType.I64, 'orderId', None, None, ), # 1
17292 
  )
17293 
 
17294 
  def __init__(self, orderId=None,):
17295 
    self.orderId = orderId
17296 
 
17297 
  def read(self, iprot):
17298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17300 
      return
17301 
    iprot.readStructBegin()
17302 
    while True:
17303 
      (fname, ftype, fid) = iprot.readFieldBegin()
17304 
      if ftype == TType.STOP:
17305 
        break
17306 
      if fid == 1:
17307 
        if ftype == TType.I64:
17308 
          self.orderId = iprot.readI64();
17309 
        else:
17310 
          iprot.skip(ftype)
17311 
      else:
17312 
        iprot.skip(ftype)
17313 
      iprot.readFieldEnd()
17314 
    iprot.readStructEnd()
17315 
 
17316 
  def write(self, oprot):
17317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17319 
      return
17320 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17321 
    if self.orderId is not None:
17322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17323 
      oprot.writeI64(self.orderId)
17324 
      oprot.writeFieldEnd()
17325 
    oprot.writeFieldStop()
17326 
    oprot.writeStructEnd()
17327 
 
17328 
  def validate(self):
17329 
    return
17330 
 
17331 
 
17332 
  def __repr__(self):
17333 
    L = ['%s=%r' % (key, value)
17334 
      for key, value in self.__dict__.iteritems()]
17335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17336 
 
17337 
  def __eq__(self, other):
17338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17339 
 
17340 
  def __ne__(self, other):
17341 
    return not (self == other)
17342 
 
17343 
class markOrderDoaRequestReceived_result:
17344 
  """
17345 
  Attributes:
17346 
   - success
17347 
   - ex
17348 
  """
17349 
 
17350 
  thrift_spec = (
17351 
    (0, TType.BOOL, 'success', None, None, ), # 0
17352 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17353 
  )
17354 
 
17355 
  def __init__(self, success=None, ex=None,):
17356 
    self.success = success
17357 
    self.ex = ex
17358 
 
17359 
  def read(self, iprot):
17360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17362 
      return
17363 
    iprot.readStructBegin()
17364 
    while True:
17365 
      (fname, ftype, fid) = iprot.readFieldBegin()
17366 
      if ftype == TType.STOP:
17367 
        break
17368 
      if fid == 0:
17369 
        if ftype == TType.BOOL:
17370 
          self.success = iprot.readBool();
17371 
        else:
17372 
          iprot.skip(ftype)
17373 
      elif fid == 1:
17374 
        if ftype == TType.STRUCT:
17375 
          self.ex = TransactionServiceException()
17376 
          self.ex.read(iprot)
17377 
        else:
17378 
          iprot.skip(ftype)
17379 
      else:
17380 
        iprot.skip(ftype)
17381 
      iprot.readFieldEnd()
17382 
    iprot.readStructEnd()
17383 
 
17384 
  def write(self, oprot):
17385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17387 
      return
17388 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17389 
    if self.success is not None:
17390 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17391 
      oprot.writeBool(self.success)
17392 
      oprot.writeFieldEnd()
17393 
    if self.ex is not None:
17394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17395 
      self.ex.write(oprot)
17396 
      oprot.writeFieldEnd()
17397 
    oprot.writeFieldStop()
17398 
    oprot.writeStructEnd()
17399 
 
17400 
  def validate(self):
17401 
    return
17402 
 
17403 
 
17404 
  def __repr__(self):
17405 
    L = ['%s=%r' % (key, value)
17406 
      for key, value in self.__dict__.iteritems()]
17407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17408 
 
17409 
  def __eq__(self, other):
17410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17411 
 
17412 
  def __ne__(self, other):
17413 
    return not (self == other)
17414 
 
17415 
class markOrderDoaRequestAuthorized_args:
17416 
  """
17417 
  Attributes:
17418 
   - orderId
17419 
   - isAuthorized
17420 
  """
17421 
 
17422 
  thrift_spec = (
17423 
    None, # 0
17424 
    (1, TType.I64, 'orderId', None, None, ), # 1
17425 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17426 
  )
17427 
 
17428 
  def __init__(self, orderId=None, isAuthorized=None,):
17429 
    self.orderId = orderId
17430 
    self.isAuthorized = isAuthorized
17431 
 
17432 
  def read(self, iprot):
17433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17435 
      return
17436 
    iprot.readStructBegin()
17437 
    while True:
17438 
      (fname, ftype, fid) = iprot.readFieldBegin()
17439 
      if ftype == TType.STOP:
17440 
        break
17441 
      if fid == 1:
17442 
        if ftype == TType.I64:
17443 
          self.orderId = iprot.readI64();
17444 
        else:
17445 
          iprot.skip(ftype)
17446 
      elif fid == 2:
17447 
        if ftype == TType.BOOL:
17448 
          self.isAuthorized = iprot.readBool();
17449 
        else:
17450 
          iprot.skip(ftype)
17451 
      else:
17452 
        iprot.skip(ftype)
17453 
      iprot.readFieldEnd()
17454 
    iprot.readStructEnd()
17455 
 
17456 
  def write(self, oprot):
17457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17459 
      return
17460 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17461 
    if self.orderId is not None:
17462 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17463 
      oprot.writeI64(self.orderId)
17464 
      oprot.writeFieldEnd()
17465 
    if self.isAuthorized is not None:
17466 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17467 
      oprot.writeBool(self.isAuthorized)
17468 
      oprot.writeFieldEnd()
17469 
    oprot.writeFieldStop()
17470 
    oprot.writeStructEnd()
17471 
 
17472 
  def validate(self):
17473 
    return
17474 
 
17475 
 
17476 
  def __repr__(self):
17477 
    L = ['%s=%r' % (key, value)
17478 
      for key, value in self.__dict__.iteritems()]
17479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17480 
 
17481 
  def __eq__(self, other):
17482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17483 
 
17484 
  def __ne__(self, other):
17485 
    return not (self == other)
17486 
 
17487 
class markOrderDoaRequestAuthorized_result:
17488 
  """
17489 
  Attributes:
17490 
   - success
17491 
   - ex
17492 
  """
17493 
 
17494 
  thrift_spec = (
17495 
    (0, TType.BOOL, 'success', None, None, ), # 0
17496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17497 
  )
17498 
 
17499 
  def __init__(self, success=None, ex=None,):
17500 
    self.success = success
17501 
    self.ex = ex
17502 
 
17503 
  def read(self, iprot):
17504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17506 
      return
17507 
    iprot.readStructBegin()
17508 
    while True:
17509 
      (fname, ftype, fid) = iprot.readFieldBegin()
17510 
      if ftype == TType.STOP:
17511 
        break
17512 
      if fid == 0:
17513 
        if ftype == TType.BOOL:
17514 
          self.success = iprot.readBool();
17515 
        else:
17516 
          iprot.skip(ftype)
17517 
      elif fid == 1:
17518 
        if ftype == TType.STRUCT:
17519 
          self.ex = TransactionServiceException()
17520 
          self.ex.read(iprot)
17521 
        else:
17522 
          iprot.skip(ftype)
17523 
      else:
17524 
        iprot.skip(ftype)
17525 
      iprot.readFieldEnd()
17526 
    iprot.readStructEnd()
17527 
 
17528 
  def write(self, oprot):
17529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17531 
      return
17532 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17533 
    if self.success is not None:
17534 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17535 
      oprot.writeBool(self.success)
17536 
      oprot.writeFieldEnd()
17537 
    if self.ex is not None:
17538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17539 
      self.ex.write(oprot)
17540 
      oprot.writeFieldEnd()
17541 
    oprot.writeFieldStop()
17542 
    oprot.writeStructEnd()
17543 
 
17544 
  def validate(self):
17545 
    return
17546 
 
17547 
 
17548 
  def __repr__(self):
17549 
    L = ['%s=%r' % (key, value)
17550 
      for key, value in self.__dict__.iteritems()]
17551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17552 
 
17553 
  def __eq__(self, other):
17554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17555 
 
17556 
  def __ne__(self, other):
17557 
    return not (self == other)
17558 
 
4488 rajveer 17559 
class markOrderReturnRequestReceived_args:
17560 
  """
17561 
  Attributes:
17562 
   - orderId
17563 
  """
17564 
 
17565 
  thrift_spec = (
17566 
    None, # 0
17567 
    (1, TType.I64, 'orderId', None, None, ), # 1
17568 
  )
17569 
 
17570 
  def __init__(self, orderId=None,):
17571 
    self.orderId = orderId
17572 
 
17573 
  def read(self, iprot):
17574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17576 
      return
17577 
    iprot.readStructBegin()
17578 
    while True:
17579 
      (fname, ftype, fid) = iprot.readFieldBegin()
17580 
      if ftype == TType.STOP:
17581 
        break
17582 
      if fid == 1:
17583 
        if ftype == TType.I64:
17584 
          self.orderId = iprot.readI64();
17585 
        else:
17586 
          iprot.skip(ftype)
17587 
      else:
17588 
        iprot.skip(ftype)
17589 
      iprot.readFieldEnd()
17590 
    iprot.readStructEnd()
17591 
 
17592 
  def write(self, oprot):
17593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17595 
      return
17596 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17597 
    if self.orderId is not None:
17598 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17599 
      oprot.writeI64(self.orderId)
17600 
      oprot.writeFieldEnd()
17601 
    oprot.writeFieldStop()
17602 
    oprot.writeStructEnd()
17603 
 
17604 
  def validate(self):
17605 
    return
17606 
 
17607 
 
17608 
  def __repr__(self):
17609 
    L = ['%s=%r' % (key, value)
17610 
      for key, value in self.__dict__.iteritems()]
17611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17612 
 
17613 
  def __eq__(self, other):
17614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17615 
 
17616 
  def __ne__(self, other):
17617 
    return not (self == other)
17618 
 
17619 
class markOrderReturnRequestReceived_result:
17620 
  """
17621 
  Attributes:
17622 
   - success
17623 
   - ex
17624 
  """
17625 
 
17626 
  thrift_spec = (
17627 
    (0, TType.BOOL, 'success', None, None, ), # 0
17628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17629 
  )
17630 
 
17631 
  def __init__(self, success=None, ex=None,):
17632 
    self.success = success
17633 
    self.ex = ex
17634 
 
17635 
  def read(self, iprot):
17636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17638 
      return
17639 
    iprot.readStructBegin()
17640 
    while True:
17641 
      (fname, ftype, fid) = iprot.readFieldBegin()
17642 
      if ftype == TType.STOP:
17643 
        break
17644 
      if fid == 0:
17645 
        if ftype == TType.BOOL:
17646 
          self.success = iprot.readBool();
17647 
        else:
17648 
          iprot.skip(ftype)
17649 
      elif fid == 1:
17650 
        if ftype == TType.STRUCT:
17651 
          self.ex = TransactionServiceException()
17652 
          self.ex.read(iprot)
17653 
        else:
17654 
          iprot.skip(ftype)
17655 
      else:
17656 
        iprot.skip(ftype)
17657 
      iprot.readFieldEnd()
17658 
    iprot.readStructEnd()
17659 
 
17660 
  def write(self, oprot):
17661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17663 
      return
17664 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17665 
    if self.success is not None:
17666 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17667 
      oprot.writeBool(self.success)
17668 
      oprot.writeFieldEnd()
17669 
    if self.ex is not None:
17670 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17671 
      self.ex.write(oprot)
17672 
      oprot.writeFieldEnd()
17673 
    oprot.writeFieldStop()
17674 
    oprot.writeStructEnd()
17675 
 
17676 
  def validate(self):
17677 
    return
17678 
 
17679 
 
17680 
  def __repr__(self):
17681 
    L = ['%s=%r' % (key, value)
17682 
      for key, value in self.__dict__.iteritems()]
17683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17684 
 
17685 
  def __eq__(self, other):
17686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17687 
 
17688 
  def __ne__(self, other):
17689 
    return not (self == other)
17690 
 
17691 
class markOrderReturnRequestAuthorized_args:
17692 
  """
17693 
  Attributes:
17694 
   - orderId
17695 
   - isAuthorized
17696 
  """
17697 
 
17698 
  thrift_spec = (
17699 
    None, # 0
17700 
    (1, TType.I64, 'orderId', None, None, ), # 1
17701 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17702 
  )
17703 
 
17704 
  def __init__(self, orderId=None, isAuthorized=None,):
17705 
    self.orderId = orderId
17706 
    self.isAuthorized = isAuthorized
17707 
 
17708 
  def read(self, iprot):
17709 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17710 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17711 
      return
17712 
    iprot.readStructBegin()
17713 
    while True:
17714 
      (fname, ftype, fid) = iprot.readFieldBegin()
17715 
      if ftype == TType.STOP:
17716 
        break
17717 
      if fid == 1:
17718 
        if ftype == TType.I64:
17719 
          self.orderId = iprot.readI64();
17720 
        else:
17721 
          iprot.skip(ftype)
17722 
      elif fid == 2:
17723 
        if ftype == TType.BOOL:
17724 
          self.isAuthorized = iprot.readBool();
17725 
        else:
17726 
          iprot.skip(ftype)
17727 
      else:
17728 
        iprot.skip(ftype)
17729 
      iprot.readFieldEnd()
17730 
    iprot.readStructEnd()
17731 
 
17732 
  def write(self, oprot):
17733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17735 
      return
17736 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17737 
    if self.orderId is not None:
17738 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17739 
      oprot.writeI64(self.orderId)
17740 
      oprot.writeFieldEnd()
17741 
    if self.isAuthorized is not None:
17742 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17743 
      oprot.writeBool(self.isAuthorized)
17744 
      oprot.writeFieldEnd()
17745 
    oprot.writeFieldStop()
17746 
    oprot.writeStructEnd()
17747 
 
17748 
  def validate(self):
17749 
    return
17750 
 
17751 
 
17752 
  def __repr__(self):
17753 
    L = ['%s=%r' % (key, value)
17754 
      for key, value in self.__dict__.iteritems()]
17755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17756 
 
17757 
  def __eq__(self, other):
17758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17759 
 
17760 
  def __ne__(self, other):
17761 
    return not (self == other)
17762 
 
17763 
class markOrderReturnRequestAuthorized_result:
17764 
  """
17765 
  Attributes:
17766 
   - success
17767 
   - ex
17768 
  """
17769 
 
17770 
  thrift_spec = (
17771 
    (0, TType.BOOL, 'success', None, None, ), # 0
17772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17773 
  )
17774 
 
17775 
  def __init__(self, success=None, ex=None,):
17776 
    self.success = success
17777 
    self.ex = ex
17778 
 
17779 
  def read(self, iprot):
17780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17782 
      return
17783 
    iprot.readStructBegin()
17784 
    while True:
17785 
      (fname, ftype, fid) = iprot.readFieldBegin()
17786 
      if ftype == TType.STOP:
17787 
        break
17788 
      if fid == 0:
17789 
        if ftype == TType.BOOL:
17790 
          self.success = iprot.readBool();
17791 
        else:
17792 
          iprot.skip(ftype)
17793 
      elif fid == 1:
17794 
        if ftype == TType.STRUCT:
17795 
          self.ex = TransactionServiceException()
17796 
          self.ex.read(iprot)
17797 
        else:
17798 
          iprot.skip(ftype)
17799 
      else:
17800 
        iprot.skip(ftype)
17801 
      iprot.readFieldEnd()
17802 
    iprot.readStructEnd()
17803 
 
17804 
  def write(self, oprot):
17805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17807 
      return
17808 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17809 
    if self.success is not None:
17810 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17811 
      oprot.writeBool(self.success)
17812 
      oprot.writeFieldEnd()
17813 
    if self.ex is not None:
17814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17815 
      self.ex.write(oprot)
17816 
      oprot.writeFieldEnd()
17817 
    oprot.writeFieldStop()
17818 
    oprot.writeStructEnd()
17819 
 
17820 
  def validate(self):
17821 
    return
17822 
 
17823 
 
17824 
  def __repr__(self):
17825 
    L = ['%s=%r' % (key, value)
17826 
      for key, value in self.__dict__.iteritems()]
17827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17828 
 
17829 
  def __eq__(self, other):
17830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17831 
 
17832 
  def __ne__(self, other):
17833 
    return not (self == other)
17834 
 
2536 chandransh 17835 
class requestPickupNumber_args:
17836 
  """
17837 
  Attributes:
17838 
   - orderId
4579 rajveer 17839 
   - providerId
2536 chandransh 17840 
  """
17841 
 
17842 
  thrift_spec = (
17843 
    None, # 0
17844 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17845 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17846 
  )
17847 
 
4579 rajveer 17848 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17849 
    self.orderId = orderId
4579 rajveer 17850 
    self.providerId = providerId
2536 chandransh 17851 
 
17852 
  def read(self, iprot):
17853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17855 
      return
17856 
    iprot.readStructBegin()
17857 
    while True:
17858 
      (fname, ftype, fid) = iprot.readFieldBegin()
17859 
      if ftype == TType.STOP:
17860 
        break
17861 
      if fid == 1:
17862 
        if ftype == TType.I64:
17863 
          self.orderId = iprot.readI64();
17864 
        else:
17865 
          iprot.skip(ftype)
4579 rajveer 17866 
      elif fid == 2:
17867 
        if ftype == TType.I64:
17868 
          self.providerId = iprot.readI64();
17869 
        else:
17870 
          iprot.skip(ftype)
2536 chandransh 17871 
      else:
17872 
        iprot.skip(ftype)
17873 
      iprot.readFieldEnd()
17874 
    iprot.readStructEnd()
17875 
 
17876 
  def write(self, oprot):
17877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17879 
      return
17880 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17881 
    if self.orderId is not None:
2536 chandransh 17882 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17883 
      oprot.writeI64(self.orderId)
17884 
      oprot.writeFieldEnd()
4579 rajveer 17885 
    if self.providerId is not None:
17886 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17887 
      oprot.writeI64(self.providerId)
17888 
      oprot.writeFieldEnd()
2536 chandransh 17889 
    oprot.writeFieldStop()
17890 
    oprot.writeStructEnd()
17891 
 
3431 rajveer 17892 
  def validate(self):
17893 
    return
17894 
 
17895 
 
2536 chandransh 17896 
  def __repr__(self):
17897 
    L = ['%s=%r' % (key, value)
17898 
      for key, value in self.__dict__.iteritems()]
17899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17900 
 
17901 
  def __eq__(self, other):
17902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17903 
 
17904 
  def __ne__(self, other):
17905 
    return not (self == other)
17906 
 
17907 
class requestPickupNumber_result:
17908 
  """
17909 
  Attributes:
17910 
   - success
17911 
   - ex
17912 
  """
17913 
 
17914 
  thrift_spec = (
17915 
    (0, TType.BOOL, 'success', None, None, ), # 0
17916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17917 
  )
17918 
 
17919 
  def __init__(self, success=None, ex=None,):
17920 
    self.success = success
17921 
    self.ex = ex
17922 
 
17923 
  def read(self, iprot):
17924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17926 
      return
17927 
    iprot.readStructBegin()
17928 
    while True:
17929 
      (fname, ftype, fid) = iprot.readFieldBegin()
17930 
      if ftype == TType.STOP:
17931 
        break
17932 
      if fid == 0:
17933 
        if ftype == TType.BOOL:
17934 
          self.success = iprot.readBool();
17935 
        else:
17936 
          iprot.skip(ftype)
17937 
      elif fid == 1:
17938 
        if ftype == TType.STRUCT:
17939 
          self.ex = TransactionServiceException()
17940 
          self.ex.read(iprot)
17941 
        else:
17942 
          iprot.skip(ftype)
17943 
      else:
17944 
        iprot.skip(ftype)
17945 
      iprot.readFieldEnd()
17946 
    iprot.readStructEnd()
17947 
 
17948 
  def write(self, oprot):
17949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17951 
      return
17952 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17953 
    if self.success is not None:
2536 chandransh 17954 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17955 
      oprot.writeBool(self.success)
17956 
      oprot.writeFieldEnd()
3431 rajveer 17957 
    if self.ex is not None:
2536 chandransh 17958 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17959 
      self.ex.write(oprot)
17960 
      oprot.writeFieldEnd()
17961 
    oprot.writeFieldStop()
17962 
    oprot.writeStructEnd()
17963 
 
3431 rajveer 17964 
  def validate(self):
17965 
    return
17966 
 
17967 
 
2536 chandransh 17968 
  def __repr__(self):
17969 
    L = ['%s=%r' % (key, value)
17970 
      for key, value in self.__dict__.iteritems()]
17971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17972 
 
17973 
  def __eq__(self, other):
17974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17975 
 
17976 
  def __ne__(self, other):
17977 
    return not (self == other)
17978 
 
17979 
class authorizePickup_args:
17980 
  """
17981 
  Attributes:
17982 
   - orderId
17983 
   - pickupNumber
4602 rajveer 17984 
   - providerId
2536 chandransh 17985 
  """
17986 
 
17987 
  thrift_spec = (
17988 
    None, # 0
17989 
    (1, TType.I64, 'orderId', None, None, ), # 1
17990 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17991 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17992 
  )
17993 
 
4602 rajveer 17994 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17995 
    self.orderId = orderId
17996 
    self.pickupNumber = pickupNumber
4602 rajveer 17997 
    self.providerId = providerId
2536 chandransh 17998 
 
17999 
  def read(self, iprot):
18000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18002 
      return
18003 
    iprot.readStructBegin()
18004 
    while True:
18005 
      (fname, ftype, fid) = iprot.readFieldBegin()
18006 
      if ftype == TType.STOP:
18007 
        break
18008 
      if fid == 1:
18009 
        if ftype == TType.I64:
18010 
          self.orderId = iprot.readI64();
18011 
        else:
18012 
          iprot.skip(ftype)
18013 
      elif fid == 2:
18014 
        if ftype == TType.STRING:
18015 
          self.pickupNumber = iprot.readString();
18016 
        else:
18017 
          iprot.skip(ftype)
4602 rajveer 18018 
      elif fid == 3:
18019 
        if ftype == TType.I64:
18020 
          self.providerId = iprot.readI64();
18021 
        else:
18022 
          iprot.skip(ftype)
2536 chandransh 18023 
      else:
18024 
        iprot.skip(ftype)
18025 
      iprot.readFieldEnd()
18026 
    iprot.readStructEnd()
18027 
 
18028 
  def write(self, oprot):
18029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18031 
      return
18032 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18033 
    if self.orderId is not None:
2536 chandransh 18034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18035 
      oprot.writeI64(self.orderId)
18036 
      oprot.writeFieldEnd()
3431 rajveer 18037 
    if self.pickupNumber is not None:
2536 chandransh 18038 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18039 
      oprot.writeString(self.pickupNumber)
18040 
      oprot.writeFieldEnd()
4602 rajveer 18041 
    if self.providerId is not None:
18042 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18043 
      oprot.writeI64(self.providerId)
18044 
      oprot.writeFieldEnd()
2536 chandransh 18045 
    oprot.writeFieldStop()
18046 
    oprot.writeStructEnd()
18047 
 
3431 rajveer 18048 
  def validate(self):
18049 
    return
18050 
 
18051 
 
2536 chandransh 18052 
  def __repr__(self):
18053 
    L = ['%s=%r' % (key, value)
18054 
      for key, value in self.__dict__.iteritems()]
18055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18056 
 
18057 
  def __eq__(self, other):
18058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18059 
 
18060 
  def __ne__(self, other):
18061 
    return not (self == other)
18062 
 
18063 
class authorizePickup_result:
18064 
  """
18065 
  Attributes:
18066 
   - success
18067 
   - ex
18068 
  """
18069 
 
18070 
  thrift_spec = (
18071 
    (0, TType.BOOL, 'success', None, None, ), # 0
18072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18073 
  )
18074 
 
18075 
  def __init__(self, success=None, ex=None,):
18076 
    self.success = success
18077 
    self.ex = ex
18078 
 
18079 
  def read(self, iprot):
18080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18082 
      return
18083 
    iprot.readStructBegin()
18084 
    while True:
18085 
      (fname, ftype, fid) = iprot.readFieldBegin()
18086 
      if ftype == TType.STOP:
18087 
        break
18088 
      if fid == 0:
18089 
        if ftype == TType.BOOL:
18090 
          self.success = iprot.readBool();
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      elif fid == 1:
18094 
        if ftype == TType.STRUCT:
18095 
          self.ex = TransactionServiceException()
18096 
          self.ex.read(iprot)
18097 
        else:
18098 
          iprot.skip(ftype)
18099 
      else:
18100 
        iprot.skip(ftype)
18101 
      iprot.readFieldEnd()
18102 
    iprot.readStructEnd()
18103 
 
18104 
  def write(self, oprot):
18105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18107 
      return
18108 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18109 
    if self.success is not None:
2536 chandransh 18110 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18111 
      oprot.writeBool(self.success)
18112 
      oprot.writeFieldEnd()
3431 rajveer 18113 
    if self.ex is not None:
2536 chandransh 18114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18115 
      self.ex.write(oprot)
18116 
      oprot.writeFieldEnd()
18117 
    oprot.writeFieldStop()
18118 
    oprot.writeStructEnd()
18119 
 
3431 rajveer 18120 
  def validate(self):
18121 
    return
18122 
 
18123 
 
2536 chandransh 18124 
  def __repr__(self):
18125 
    L = ['%s=%r' % (key, value)
18126 
      for key, value in self.__dict__.iteritems()]
18127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18128 
 
18129 
  def __eq__(self, other):
18130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18131 
 
18132 
  def __ne__(self, other):
18133 
    return not (self == other)
18134 
 
2764 chandransh 18135 
class markDoasAsPickedUp_args:
18136 
  """
18137 
  Attributes:
18138 
   - providerId
18139 
   - pickupDetails
18140 
  """
18141 
 
18142 
  thrift_spec = (
18143 
    None, # 0
18144 
    (1, TType.I64, 'providerId', None, None, ), # 1
18145 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18146 
  )
18147 
 
18148 
  def __init__(self, providerId=None, pickupDetails=None,):
18149 
    self.providerId = providerId
18150 
    self.pickupDetails = pickupDetails
18151 
 
18152 
  def read(self, iprot):
18153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18155 
      return
18156 
    iprot.readStructBegin()
18157 
    while True:
18158 
      (fname, ftype, fid) = iprot.readFieldBegin()
18159 
      if ftype == TType.STOP:
18160 
        break
18161 
      if fid == 1:
18162 
        if ftype == TType.I64:
18163 
          self.providerId = iprot.readI64();
18164 
        else:
18165 
          iprot.skip(ftype)
18166 
      elif fid == 2:
18167 
        if ftype == TType.MAP:
18168 
          self.pickupDetails = {}
6188 rajveer 18169 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18170 
          for _i411 in xrange(_size407):
18171 
            _key412 = iprot.readString();
18172 
            _val413 = iprot.readString();
18173 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18174 
          iprot.readMapEnd()
18175 
        else:
18176 
          iprot.skip(ftype)
18177 
      else:
18178 
        iprot.skip(ftype)
18179 
      iprot.readFieldEnd()
18180 
    iprot.readStructEnd()
18181 
 
18182 
  def write(self, oprot):
18183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18185 
      return
18186 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18187 
    if self.providerId is not None:
2764 chandransh 18188 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18189 
      oprot.writeI64(self.providerId)
18190 
      oprot.writeFieldEnd()
3431 rajveer 18191 
    if self.pickupDetails is not None:
2764 chandransh 18192 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18193 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18194 
      for kiter414,viter415 in self.pickupDetails.items():
18195 
        oprot.writeString(kiter414)
18196 
        oprot.writeString(viter415)
2764 chandransh 18197 
      oprot.writeMapEnd()
18198 
      oprot.writeFieldEnd()
18199 
    oprot.writeFieldStop()
18200 
    oprot.writeStructEnd()
18201 
 
3431 rajveer 18202 
  def validate(self):
18203 
    return
18204 
 
18205 
 
2764 chandransh 18206 
  def __repr__(self):
18207 
    L = ['%s=%r' % (key, value)
18208 
      for key, value in self.__dict__.iteritems()]
18209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18210 
 
18211 
  def __eq__(self, other):
18212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18213 
 
18214 
  def __ne__(self, other):
18215 
    return not (self == other)
18216 
 
18217 
class markDoasAsPickedUp_result:
4910 phani.kuma 18218 
 
18219 
  thrift_spec = (
18220 
  )
18221 
 
18222 
  def read(self, iprot):
18223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18225 
      return
18226 
    iprot.readStructBegin()
18227 
    while True:
18228 
      (fname, ftype, fid) = iprot.readFieldBegin()
18229 
      if ftype == TType.STOP:
18230 
        break
18231 
      else:
18232 
        iprot.skip(ftype)
18233 
      iprot.readFieldEnd()
18234 
    iprot.readStructEnd()
18235 
 
18236 
  def write(self, oprot):
18237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18239 
      return
18240 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18241 
    oprot.writeFieldStop()
18242 
    oprot.writeStructEnd()
18243 
 
18244 
  def validate(self):
18245 
    return
18246 
 
18247 
 
18248 
  def __repr__(self):
18249 
    L = ['%s=%r' % (key, value)
18250 
      for key, value in self.__dict__.iteritems()]
18251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18252 
 
18253 
  def __eq__(self, other):
18254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18255 
 
18256 
  def __ne__(self, other):
18257 
    return not (self == other)
18258 
 
18259 
class getDoasNotPickedUp_args:
2764 chandransh 18260 
  """
18261 
  Attributes:
4910 phani.kuma 18262 
   - providerId
18263 
  """
18264 
 
18265 
  thrift_spec = (
18266 
    None, # 0
18267 
    (1, TType.I64, 'providerId', None, None, ), # 1
18268 
  )
18269 
 
18270 
  def __init__(self, providerId=None,):
18271 
    self.providerId = providerId
18272 
 
18273 
  def read(self, iprot):
18274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18276 
      return
18277 
    iprot.readStructBegin()
18278 
    while True:
18279 
      (fname, ftype, fid) = iprot.readFieldBegin()
18280 
      if ftype == TType.STOP:
18281 
        break
18282 
      if fid == 1:
18283 
        if ftype == TType.I64:
18284 
          self.providerId = iprot.readI64();
18285 
        else:
18286 
          iprot.skip(ftype)
18287 
      else:
18288 
        iprot.skip(ftype)
18289 
      iprot.readFieldEnd()
18290 
    iprot.readStructEnd()
18291 
 
18292 
  def write(self, oprot):
18293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18295 
      return
18296 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18297 
    if self.providerId is not None:
18298 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18299 
      oprot.writeI64(self.providerId)
18300 
      oprot.writeFieldEnd()
18301 
    oprot.writeFieldStop()
18302 
    oprot.writeStructEnd()
18303 
 
18304 
  def validate(self):
18305 
    return
18306 
 
18307 
 
18308 
  def __repr__(self):
18309 
    L = ['%s=%r' % (key, value)
18310 
      for key, value in self.__dict__.iteritems()]
18311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18312 
 
18313 
  def __eq__(self, other):
18314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18315 
 
18316 
  def __ne__(self, other):
18317 
    return not (self == other)
18318 
 
18319 
class getDoasNotPickedUp_result:
18320 
  """
18321 
  Attributes:
2764 chandransh 18322 
   - success
18323 
  """
18324 
 
18325 
  thrift_spec = (
18326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18327 
  )
18328 
 
18329 
  def __init__(self, success=None,):
18330 
    self.success = success
18331 
 
18332 
  def read(self, iprot):
18333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18335 
      return
18336 
    iprot.readStructBegin()
18337 
    while True:
18338 
      (fname, ftype, fid) = iprot.readFieldBegin()
18339 
      if ftype == TType.STOP:
18340 
        break
18341 
      if fid == 0:
18342 
        if ftype == TType.LIST:
18343 
          self.success = []
6188 rajveer 18344 
          (_etype419, _size416) = iprot.readListBegin()
18345 
          for _i420 in xrange(_size416):
18346 
            _elem421 = Order()
18347 
            _elem421.read(iprot)
18348 
            self.success.append(_elem421)
2764 chandransh 18349 
          iprot.readListEnd()
18350 
        else:
18351 
          iprot.skip(ftype)
18352 
      else:
18353 
        iprot.skip(ftype)
18354 
      iprot.readFieldEnd()
18355 
    iprot.readStructEnd()
18356 
 
18357 
  def write(self, oprot):
18358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18360 
      return
4910 phani.kuma 18361 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18362 
    if self.success is not None:
2764 chandransh 18363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18364 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18365 
      for iter422 in self.success:
18366 
        iter422.write(oprot)
2764 chandransh 18367 
      oprot.writeListEnd()
18368 
      oprot.writeFieldEnd()
18369 
    oprot.writeFieldStop()
18370 
    oprot.writeStructEnd()
18371 
 
3431 rajveer 18372 
  def validate(self):
18373 
    return
18374 
 
18375 
 
2764 chandransh 18376 
  def __repr__(self):
18377 
    L = ['%s=%r' % (key, value)
18378 
      for key, value in self.__dict__.iteritems()]
18379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18380 
 
18381 
  def __eq__(self, other):
18382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18383 
 
18384 
  def __ne__(self, other):
18385 
    return not (self == other)
18386 
 
4741 phani.kuma 18387 
class markReturnOrdersAsPickedUp_args:
18388 
  """
18389 
  Attributes:
18390 
   - providerId
18391 
   - pickupDetails
18392 
  """
18393 
 
18394 
  thrift_spec = (
18395 
    None, # 0
18396 
    (1, TType.I64, 'providerId', None, None, ), # 1
18397 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18398 
  )
18399 
 
18400 
  def __init__(self, providerId=None, pickupDetails=None,):
18401 
    self.providerId = providerId
18402 
    self.pickupDetails = pickupDetails
18403 
 
18404 
  def read(self, iprot):
18405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18407 
      return
18408 
    iprot.readStructBegin()
18409 
    while True:
18410 
      (fname, ftype, fid) = iprot.readFieldBegin()
18411 
      if ftype == TType.STOP:
18412 
        break
18413 
      if fid == 1:
18414 
        if ftype == TType.I64:
18415 
          self.providerId = iprot.readI64();
18416 
        else:
18417 
          iprot.skip(ftype)
18418 
      elif fid == 2:
18419 
        if ftype == TType.MAP:
18420 
          self.pickupDetails = {}
6188 rajveer 18421 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18422 
          for _i427 in xrange(_size423):
18423 
            _key428 = iprot.readString();
18424 
            _val429 = iprot.readString();
18425 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18426 
          iprot.readMapEnd()
18427 
        else:
18428 
          iprot.skip(ftype)
18429 
      else:
18430 
        iprot.skip(ftype)
18431 
      iprot.readFieldEnd()
18432 
    iprot.readStructEnd()
18433 
 
18434 
  def write(self, oprot):
18435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18437 
      return
18438 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18439 
    if self.providerId is not None:
18440 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18441 
      oprot.writeI64(self.providerId)
18442 
      oprot.writeFieldEnd()
18443 
    if self.pickupDetails is not None:
18444 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18445 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18446 
      for kiter430,viter431 in self.pickupDetails.items():
18447 
        oprot.writeString(kiter430)
18448 
        oprot.writeString(viter431)
4741 phani.kuma 18449 
      oprot.writeMapEnd()
18450 
      oprot.writeFieldEnd()
18451 
    oprot.writeFieldStop()
18452 
    oprot.writeStructEnd()
18453 
 
18454 
  def validate(self):
18455 
    return
18456 
 
18457 
 
18458 
  def __repr__(self):
18459 
    L = ['%s=%r' % (key, value)
18460 
      for key, value in self.__dict__.iteritems()]
18461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18462 
 
18463 
  def __eq__(self, other):
18464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18465 
 
18466 
  def __ne__(self, other):
18467 
    return not (self == other)
18468 
 
18469 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18470 
 
18471 
  thrift_spec = (
18472 
  )
18473 
 
18474 
  def read(self, iprot):
18475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18477 
      return
18478 
    iprot.readStructBegin()
18479 
    while True:
18480 
      (fname, ftype, fid) = iprot.readFieldBegin()
18481 
      if ftype == TType.STOP:
18482 
        break
18483 
      else:
18484 
        iprot.skip(ftype)
18485 
      iprot.readFieldEnd()
18486 
    iprot.readStructEnd()
18487 
 
18488 
  def write(self, oprot):
18489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18491 
      return
18492 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18493 
    oprot.writeFieldStop()
18494 
    oprot.writeStructEnd()
18495 
 
18496 
  def validate(self):
18497 
    return
18498 
 
18499 
 
18500 
  def __repr__(self):
18501 
    L = ['%s=%r' % (key, value)
18502 
      for key, value in self.__dict__.iteritems()]
18503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18504 
 
18505 
  def __eq__(self, other):
18506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18507 
 
18508 
  def __ne__(self, other):
18509 
    return not (self == other)
18510 
 
18511 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18512 
  """
18513 
  Attributes:
4910 phani.kuma 18514 
   - providerId
18515 
  """
18516 
 
18517 
  thrift_spec = (
18518 
    None, # 0
18519 
    (1, TType.I64, 'providerId', None, None, ), # 1
18520 
  )
18521 
 
18522 
  def __init__(self, providerId=None,):
18523 
    self.providerId = providerId
18524 
 
18525 
  def read(self, iprot):
18526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18528 
      return
18529 
    iprot.readStructBegin()
18530 
    while True:
18531 
      (fname, ftype, fid) = iprot.readFieldBegin()
18532 
      if ftype == TType.STOP:
18533 
        break
18534 
      if fid == 1:
18535 
        if ftype == TType.I64:
18536 
          self.providerId = iprot.readI64();
18537 
        else:
18538 
          iprot.skip(ftype)
18539 
      else:
18540 
        iprot.skip(ftype)
18541 
      iprot.readFieldEnd()
18542 
    iprot.readStructEnd()
18543 
 
18544 
  def write(self, oprot):
18545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18547 
      return
18548 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18549 
    if self.providerId is not None:
18550 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18551 
      oprot.writeI64(self.providerId)
18552 
      oprot.writeFieldEnd()
18553 
    oprot.writeFieldStop()
18554 
    oprot.writeStructEnd()
18555 
 
18556 
  def validate(self):
18557 
    return
18558 
 
18559 
 
18560 
  def __repr__(self):
18561 
    L = ['%s=%r' % (key, value)
18562 
      for key, value in self.__dict__.iteritems()]
18563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18564 
 
18565 
  def __eq__(self, other):
18566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18567 
 
18568 
  def __ne__(self, other):
18569 
    return not (self == other)
18570 
 
18571 
class getReturnOrdersNotPickedUp_result:
18572 
  """
18573 
  Attributes:
4741 phani.kuma 18574 
   - success
18575 
  """
18576 
 
18577 
  thrift_spec = (
18578 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18579 
  )
18580 
 
18581 
  def __init__(self, success=None,):
18582 
    self.success = success
18583 
 
18584 
  def read(self, iprot):
18585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18587 
      return
18588 
    iprot.readStructBegin()
18589 
    while True:
18590 
      (fname, ftype, fid) = iprot.readFieldBegin()
18591 
      if ftype == TType.STOP:
18592 
        break
18593 
      if fid == 0:
18594 
        if ftype == TType.LIST:
18595 
          self.success = []
6188 rajveer 18596 
          (_etype435, _size432) = iprot.readListBegin()
18597 
          for _i436 in xrange(_size432):
18598 
            _elem437 = Order()
18599 
            _elem437.read(iprot)
18600 
            self.success.append(_elem437)
4741 phani.kuma 18601 
          iprot.readListEnd()
18602 
        else:
18603 
          iprot.skip(ftype)
18604 
      else:
18605 
        iprot.skip(ftype)
18606 
      iprot.readFieldEnd()
18607 
    iprot.readStructEnd()
18608 
 
18609 
  def write(self, oprot):
18610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18612 
      return
4910 phani.kuma 18613 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18614 
    if self.success is not None:
18615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18617 
      for iter438 in self.success:
18618 
        iter438.write(oprot)
4741 phani.kuma 18619 
      oprot.writeListEnd()
18620 
      oprot.writeFieldEnd()
18621 
    oprot.writeFieldStop()
18622 
    oprot.writeStructEnd()
18623 
 
18624 
  def validate(self):
18625 
    return
18626 
 
18627 
 
18628 
  def __repr__(self):
18629 
    L = ['%s=%r' % (key, value)
18630 
      for key, value in self.__dict__.iteritems()]
18631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18632 
 
18633 
  def __eq__(self, other):
18634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18635 
 
18636 
  def __ne__(self, other):
18637 
    return not (self == other)
18638 
 
2616 chandransh 18639 
class receiveReturn_args:
2591 chandransh 18640 
  """
18641 
  Attributes:
18642 
   - orderId
4479 rajveer 18643 
   - receiveCondition
2591 chandransh 18644 
  """
2536 chandransh 18645 
 
2591 chandransh 18646 
  thrift_spec = (
18647 
    None, # 0
18648 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18649 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18650 
  )
18651 
 
4479 rajveer 18652 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18653 
    self.orderId = orderId
4479 rajveer 18654 
    self.receiveCondition = receiveCondition
2591 chandransh 18655 
 
18656 
  def read(self, iprot):
18657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18659 
      return
18660 
    iprot.readStructBegin()
18661 
    while True:
18662 
      (fname, ftype, fid) = iprot.readFieldBegin()
18663 
      if ftype == TType.STOP:
18664 
        break
18665 
      if fid == 1:
18666 
        if ftype == TType.I64:
18667 
          self.orderId = iprot.readI64();
18668 
        else:
18669 
          iprot.skip(ftype)
4479 rajveer 18670 
      elif fid == 2:
18671 
        if ftype == TType.I64:
18672 
          self.receiveCondition = iprot.readI64();
18673 
        else:
18674 
          iprot.skip(ftype)
2591 chandransh 18675 
      else:
18676 
        iprot.skip(ftype)
18677 
      iprot.readFieldEnd()
18678 
    iprot.readStructEnd()
18679 
 
18680 
  def write(self, oprot):
18681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18683 
      return
2616 chandransh 18684 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18685 
    if self.orderId is not None:
2591 chandransh 18686 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18687 
      oprot.writeI64(self.orderId)
18688 
      oprot.writeFieldEnd()
4479 rajveer 18689 
    if self.receiveCondition is not None:
18690 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18691 
      oprot.writeI64(self.receiveCondition)
18692 
      oprot.writeFieldEnd()
2591 chandransh 18693 
    oprot.writeFieldStop()
18694 
    oprot.writeStructEnd()
18695 
 
3431 rajveer 18696 
  def validate(self):
18697 
    return
18698 
 
18699 
 
2591 chandransh 18700 
  def __repr__(self):
18701 
    L = ['%s=%r' % (key, value)
18702 
      for key, value in self.__dict__.iteritems()]
18703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18704 
 
18705 
  def __eq__(self, other):
18706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18707 
 
18708 
  def __ne__(self, other):
18709 
    return not (self == other)
18710 
 
2616 chandransh 18711 
class receiveReturn_result:
2591 chandransh 18712 
  """
18713 
  Attributes:
18714 
   - success
18715 
   - ex
18716 
  """
18717 
 
18718 
  thrift_spec = (
18719 
    (0, TType.BOOL, 'success', None, None, ), # 0
18720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18721 
  )
18722 
 
18723 
  def __init__(self, success=None, ex=None,):
18724 
    self.success = success
18725 
    self.ex = ex
18726 
 
18727 
  def read(self, iprot):
18728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18730 
      return
18731 
    iprot.readStructBegin()
18732 
    while True:
18733 
      (fname, ftype, fid) = iprot.readFieldBegin()
18734 
      if ftype == TType.STOP:
18735 
        break
18736 
      if fid == 0:
18737 
        if ftype == TType.BOOL:
18738 
          self.success = iprot.readBool();
18739 
        else:
18740 
          iprot.skip(ftype)
18741 
      elif fid == 1:
18742 
        if ftype == TType.STRUCT:
18743 
          self.ex = TransactionServiceException()
18744 
          self.ex.read(iprot)
18745 
        else:
18746 
          iprot.skip(ftype)
18747 
      else:
18748 
        iprot.skip(ftype)
18749 
      iprot.readFieldEnd()
18750 
    iprot.readStructEnd()
18751 
 
18752 
  def write(self, oprot):
18753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18755 
      return
2616 chandransh 18756 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18757 
    if self.success is not None:
2591 chandransh 18758 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18759 
      oprot.writeBool(self.success)
18760 
      oprot.writeFieldEnd()
3431 rajveer 18761 
    if self.ex is not None:
2591 chandransh 18762 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18763 
      self.ex.write(oprot)
18764 
      oprot.writeFieldEnd()
18765 
    oprot.writeFieldStop()
18766 
    oprot.writeStructEnd()
18767 
 
3431 rajveer 18768 
  def validate(self):
18769 
    return
18770 
 
18771 
 
2591 chandransh 18772 
  def __repr__(self):
18773 
    L = ['%s=%r' % (key, value)
18774 
      for key, value in self.__dict__.iteritems()]
18775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18776 
 
18777 
  def __eq__(self, other):
18778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18779 
 
18780 
  def __ne__(self, other):
18781 
    return not (self == other)
18782 
 
18783 
class validateDoa_args:
18784 
  """
18785 
  Attributes:
18786 
   - orderId
18787 
   - isValid
18788 
  """
18789 
 
18790 
  thrift_spec = (
18791 
    None, # 0
18792 
    (1, TType.I64, 'orderId', None, None, ), # 1
18793 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18794 
  )
18795 
 
18796 
  def __init__(self, orderId=None, isValid=None,):
18797 
    self.orderId = orderId
18798 
    self.isValid = isValid
18799 
 
18800 
  def read(self, iprot):
18801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18803 
      return
18804 
    iprot.readStructBegin()
18805 
    while True:
18806 
      (fname, ftype, fid) = iprot.readFieldBegin()
18807 
      if ftype == TType.STOP:
18808 
        break
18809 
      if fid == 1:
18810 
        if ftype == TType.I64:
18811 
          self.orderId = iprot.readI64();
18812 
        else:
18813 
          iprot.skip(ftype)
18814 
      elif fid == 2:
18815 
        if ftype == TType.BOOL:
18816 
          self.isValid = iprot.readBool();
18817 
        else:
18818 
          iprot.skip(ftype)
18819 
      else:
18820 
        iprot.skip(ftype)
18821 
      iprot.readFieldEnd()
18822 
    iprot.readStructEnd()
18823 
 
18824 
  def write(self, oprot):
18825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18827 
      return
18828 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18829 
    if self.orderId is not None:
2591 chandransh 18830 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18831 
      oprot.writeI64(self.orderId)
18832 
      oprot.writeFieldEnd()
3431 rajveer 18833 
    if self.isValid is not None:
2591 chandransh 18834 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18835 
      oprot.writeBool(self.isValid)
18836 
      oprot.writeFieldEnd()
18837 
    oprot.writeFieldStop()
18838 
    oprot.writeStructEnd()
18839 
 
3431 rajveer 18840 
  def validate(self):
18841 
    return
18842 
 
18843 
 
2591 chandransh 18844 
  def __repr__(self):
18845 
    L = ['%s=%r' % (key, value)
18846 
      for key, value in self.__dict__.iteritems()]
18847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18848 
 
18849 
  def __eq__(self, other):
18850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18851 
 
18852 
  def __ne__(self, other):
18853 
    return not (self == other)
18854 
 
18855 
class validateDoa_result:
18856 
  """
18857 
  Attributes:
18858 
   - success
18859 
   - ex
18860 
  """
18861 
 
18862 
  thrift_spec = (
18863 
    (0, TType.BOOL, 'success', None, None, ), # 0
18864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18865 
  )
18866 
 
18867 
  def __init__(self, success=None, ex=None,):
18868 
    self.success = success
18869 
    self.ex = ex
18870 
 
18871 
  def read(self, iprot):
18872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18874 
      return
18875 
    iprot.readStructBegin()
18876 
    while True:
18877 
      (fname, ftype, fid) = iprot.readFieldBegin()
18878 
      if ftype == TType.STOP:
18879 
        break
18880 
      if fid == 0:
18881 
        if ftype == TType.BOOL:
18882 
          self.success = iprot.readBool();
18883 
        else:
18884 
          iprot.skip(ftype)
18885 
      elif fid == 1:
18886 
        if ftype == TType.STRUCT:
18887 
          self.ex = TransactionServiceException()
18888 
          self.ex.read(iprot)
18889 
        else:
18890 
          iprot.skip(ftype)
18891 
      else:
18892 
        iprot.skip(ftype)
18893 
      iprot.readFieldEnd()
18894 
    iprot.readStructEnd()
18895 
 
18896 
  def write(self, oprot):
18897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18899 
      return
18900 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18901 
    if self.success is not None:
2591 chandransh 18902 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18903 
      oprot.writeBool(self.success)
18904 
      oprot.writeFieldEnd()
3431 rajveer 18905 
    if self.ex is not None:
2591 chandransh 18906 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18907 
      self.ex.write(oprot)
18908 
      oprot.writeFieldEnd()
18909 
    oprot.writeFieldStop()
18910 
    oprot.writeStructEnd()
18911 
 
3431 rajveer 18912 
  def validate(self):
18913 
    return
18914 
 
18915 
 
2591 chandransh 18916 
  def __repr__(self):
18917 
    L = ['%s=%r' % (key, value)
18918 
      for key, value in self.__dict__.iteritems()]
18919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18920 
 
18921 
  def __eq__(self, other):
18922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18923 
 
18924 
  def __ne__(self, other):
18925 
    return not (self == other)
18926 
 
4495 rajveer 18927 
class validateReturnProduct_args:
18928 
  """
18929 
  Attributes:
18930 
   - orderId
18931 
   - isUsable
18932 
  """
18933 
 
18934 
  thrift_spec = (
18935 
    None, # 0
18936 
    (1, TType.I64, 'orderId', None, None, ), # 1
18937 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18938 
  )
18939 
 
18940 
  def __init__(self, orderId=None, isUsable=None,):
18941 
    self.orderId = orderId
18942 
    self.isUsable = isUsable
18943 
 
18944 
  def read(self, iprot):
18945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18947 
      return
18948 
    iprot.readStructBegin()
18949 
    while True:
18950 
      (fname, ftype, fid) = iprot.readFieldBegin()
18951 
      if ftype == TType.STOP:
18952 
        break
18953 
      if fid == 1:
18954 
        if ftype == TType.I64:
18955 
          self.orderId = iprot.readI64();
18956 
        else:
18957 
          iprot.skip(ftype)
18958 
      elif fid == 2:
18959 
        if ftype == TType.BOOL:
18960 
          self.isUsable = iprot.readBool();
18961 
        else:
18962 
          iprot.skip(ftype)
18963 
      else:
18964 
        iprot.skip(ftype)
18965 
      iprot.readFieldEnd()
18966 
    iprot.readStructEnd()
18967 
 
18968 
  def write(self, oprot):
18969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18971 
      return
18972 
    oprot.writeStructBegin('validateReturnProduct_args')
18973 
    if self.orderId is not None:
18974 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18975 
      oprot.writeI64(self.orderId)
18976 
      oprot.writeFieldEnd()
18977 
    if self.isUsable is not None:
18978 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18979 
      oprot.writeBool(self.isUsable)
18980 
      oprot.writeFieldEnd()
18981 
    oprot.writeFieldStop()
18982 
    oprot.writeStructEnd()
18983 
 
18984 
  def validate(self):
18985 
    return
18986 
 
18987 
 
18988 
  def __repr__(self):
18989 
    L = ['%s=%r' % (key, value)
18990 
      for key, value in self.__dict__.iteritems()]
18991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18992 
 
18993 
  def __eq__(self, other):
18994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18995 
 
18996 
  def __ne__(self, other):
18997 
    return not (self == other)
18998 
 
18999 
class validateReturnProduct_result:
19000 
  """
19001 
  Attributes:
19002 
   - success
19003 
   - ex
19004 
  """
19005 
 
19006 
  thrift_spec = (
19007 
    (0, TType.BOOL, 'success', None, None, ), # 0
19008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19009 
  )
19010 
 
19011 
  def __init__(self, success=None, ex=None,):
19012 
    self.success = success
19013 
    self.ex = ex
19014 
 
19015 
  def read(self, iprot):
19016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19018 
      return
19019 
    iprot.readStructBegin()
19020 
    while True:
19021 
      (fname, ftype, fid) = iprot.readFieldBegin()
19022 
      if ftype == TType.STOP:
19023 
        break
19024 
      if fid == 0:
19025 
        if ftype == TType.BOOL:
19026 
          self.success = iprot.readBool();
19027 
        else:
19028 
          iprot.skip(ftype)
19029 
      elif fid == 1:
19030 
        if ftype == TType.STRUCT:
19031 
          self.ex = TransactionServiceException()
19032 
          self.ex.read(iprot)
19033 
        else:
19034 
          iprot.skip(ftype)
19035 
      else:
19036 
        iprot.skip(ftype)
19037 
      iprot.readFieldEnd()
19038 
    iprot.readStructEnd()
19039 
 
19040 
  def write(self, oprot):
19041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19043 
      return
19044 
    oprot.writeStructBegin('validateReturnProduct_result')
19045 
    if self.success is not None:
19046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19047 
      oprot.writeBool(self.success)
19048 
      oprot.writeFieldEnd()
19049 
    if self.ex is not None:
19050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19051 
      self.ex.write(oprot)
19052 
      oprot.writeFieldEnd()
19053 
    oprot.writeFieldStop()
19054 
    oprot.writeStructEnd()
19055 
 
19056 
  def validate(self):
19057 
    return
19058 
 
19059 
 
19060 
  def __repr__(self):
19061 
    L = ['%s=%r' % (key, value)
19062 
      for key, value in self.__dict__.iteritems()]
19063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19064 
 
19065 
  def __eq__(self, other):
19066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19067 
 
19068 
  def __ne__(self, other):
19069 
    return not (self == other)
19070 
 
2616 chandransh 19071 
class reshipOrder_args:
19072 
  """
19073 
  Attributes:
19074 
   - orderId
19075 
  """
2591 chandransh 19076 
 
2616 chandransh 19077 
  thrift_spec = (
19078 
    None, # 0
19079 
    (1, TType.I64, 'orderId', None, None, ), # 1
19080 
  )
19081 
 
19082 
  def __init__(self, orderId=None,):
19083 
    self.orderId = orderId
19084 
 
19085 
  def read(self, iprot):
19086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19088 
      return
19089 
    iprot.readStructBegin()
19090 
    while True:
19091 
      (fname, ftype, fid) = iprot.readFieldBegin()
19092 
      if ftype == TType.STOP:
19093 
        break
19094 
      if fid == 1:
19095 
        if ftype == TType.I64:
19096 
          self.orderId = iprot.readI64();
19097 
        else:
19098 
          iprot.skip(ftype)
19099 
      else:
19100 
        iprot.skip(ftype)
19101 
      iprot.readFieldEnd()
19102 
    iprot.readStructEnd()
19103 
 
19104 
  def write(self, oprot):
19105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19107 
      return
19108 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19109 
    if self.orderId is not None:
2616 chandransh 19110 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19111 
      oprot.writeI64(self.orderId)
19112 
      oprot.writeFieldEnd()
19113 
    oprot.writeFieldStop()
19114 
    oprot.writeStructEnd()
19115 
 
3431 rajveer 19116 
  def validate(self):
19117 
    return
19118 
 
19119 
 
2616 chandransh 19120 
  def __repr__(self):
19121 
    L = ['%s=%r' % (key, value)
19122 
      for key, value in self.__dict__.iteritems()]
19123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19124 
 
19125 
  def __eq__(self, other):
19126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19127 
 
19128 
  def __ne__(self, other):
19129 
    return not (self == other)
19130 
 
19131 
class reshipOrder_result:
19132 
  """
19133 
  Attributes:
19134 
   - success
19135 
   - ex
19136 
  """
19137 
 
19138 
  thrift_spec = (
19139 
    (0, TType.I64, 'success', None, None, ), # 0
19140 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19141 
  )
19142 
 
19143 
  def __init__(self, success=None, ex=None,):
19144 
    self.success = success
19145 
    self.ex = ex
19146 
 
19147 
  def read(self, iprot):
19148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19150 
      return
19151 
    iprot.readStructBegin()
19152 
    while True:
19153 
      (fname, ftype, fid) = iprot.readFieldBegin()
19154 
      if ftype == TType.STOP:
19155 
        break
19156 
      if fid == 0:
19157 
        if ftype == TType.I64:
19158 
          self.success = iprot.readI64();
19159 
        else:
19160 
          iprot.skip(ftype)
19161 
      elif fid == 1:
19162 
        if ftype == TType.STRUCT:
19163 
          self.ex = TransactionServiceException()
19164 
          self.ex.read(iprot)
19165 
        else:
19166 
          iprot.skip(ftype)
19167 
      else:
19168 
        iprot.skip(ftype)
19169 
      iprot.readFieldEnd()
19170 
    iprot.readStructEnd()
19171 
 
19172 
  def write(self, oprot):
19173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19175 
      return
19176 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19177 
    if self.success is not None:
2616 chandransh 19178 
      oprot.writeFieldBegin('success', TType.I64, 0)
19179 
      oprot.writeI64(self.success)
19180 
      oprot.writeFieldEnd()
3431 rajveer 19181 
    if self.ex is not None:
2616 chandransh 19182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19183 
      self.ex.write(oprot)
19184 
      oprot.writeFieldEnd()
19185 
    oprot.writeFieldStop()
19186 
    oprot.writeStructEnd()
19187 
 
3431 rajveer 19188 
  def validate(self):
19189 
    return
19190 
 
19191 
 
2616 chandransh 19192 
  def __repr__(self):
19193 
    L = ['%s=%r' % (key, value)
19194 
      for key, value in self.__dict__.iteritems()]
19195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19196 
 
19197 
  def __eq__(self, other):
19198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19199 
 
19200 
  def __ne__(self, other):
19201 
    return not (self == other)
19202 
 
19203 
class refundOrder_args:
19204 
  """
19205 
  Attributes:
19206 
   - orderId
3226 chandransh 19207 
   - refundedBy
19208 
   - reason
2616 chandransh 19209 
  """
19210 
 
19211 
  thrift_spec = (
19212 
    None, # 0
19213 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19214 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19215 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19216 
  )
19217 
 
3226 chandransh 19218 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19219 
    self.orderId = orderId
3226 chandransh 19220 
    self.refundedBy = refundedBy
19221 
    self.reason = reason
2616 chandransh 19222 
 
19223 
  def read(self, iprot):
19224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19226 
      return
19227 
    iprot.readStructBegin()
19228 
    while True:
19229 
      (fname, ftype, fid) = iprot.readFieldBegin()
19230 
      if ftype == TType.STOP:
19231 
        break
19232 
      if fid == 1:
19233 
        if ftype == TType.I64:
19234 
          self.orderId = iprot.readI64();
19235 
        else:
19236 
          iprot.skip(ftype)
3226 chandransh 19237 
      elif fid == 2:
19238 
        if ftype == TType.STRING:
19239 
          self.refundedBy = iprot.readString();
19240 
        else:
19241 
          iprot.skip(ftype)
19242 
      elif fid == 3:
19243 
        if ftype == TType.STRING:
19244 
          self.reason = iprot.readString();
19245 
        else:
19246 
          iprot.skip(ftype)
2616 chandransh 19247 
      else:
19248 
        iprot.skip(ftype)
19249 
      iprot.readFieldEnd()
19250 
    iprot.readStructEnd()
19251 
 
19252 
  def write(self, oprot):
19253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19255 
      return
19256 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19257 
    if self.orderId is not None:
2616 chandransh 19258 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19259 
      oprot.writeI64(self.orderId)
19260 
      oprot.writeFieldEnd()
3431 rajveer 19261 
    if self.refundedBy is not None:
3226 chandransh 19262 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19263 
      oprot.writeString(self.refundedBy)
19264 
      oprot.writeFieldEnd()
3431 rajveer 19265 
    if self.reason is not None:
3226 chandransh 19266 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19267 
      oprot.writeString(self.reason)
19268 
      oprot.writeFieldEnd()
2616 chandransh 19269 
    oprot.writeFieldStop()
19270 
    oprot.writeStructEnd()
19271 
 
3431 rajveer 19272 
  def validate(self):
19273 
    return
19274 
 
19275 
 
2616 chandransh 19276 
  def __repr__(self):
19277 
    L = ['%s=%r' % (key, value)
19278 
      for key, value in self.__dict__.iteritems()]
19279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19280 
 
19281 
  def __eq__(self, other):
19282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19283 
 
19284 
  def __ne__(self, other):
19285 
    return not (self == other)
19286 
 
19287 
class refundOrder_result:
19288 
  """
19289 
  Attributes:
19290 
   - success
19291 
   - ex
19292 
  """
19293 
 
19294 
  thrift_spec = (
19295 
    (0, TType.BOOL, 'success', None, None, ), # 0
19296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19297 
  )
19298 
 
19299 
  def __init__(self, success=None, ex=None,):
19300 
    self.success = success
19301 
    self.ex = ex
19302 
 
19303 
  def read(self, iprot):
19304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19306 
      return
19307 
    iprot.readStructBegin()
19308 
    while True:
19309 
      (fname, ftype, fid) = iprot.readFieldBegin()
19310 
      if ftype == TType.STOP:
19311 
        break
19312 
      if fid == 0:
19313 
        if ftype == TType.BOOL:
19314 
          self.success = iprot.readBool();
19315 
        else:
19316 
          iprot.skip(ftype)
19317 
      elif fid == 1:
19318 
        if ftype == TType.STRUCT:
19319 
          self.ex = TransactionServiceException()
19320 
          self.ex.read(iprot)
19321 
        else:
19322 
          iprot.skip(ftype)
19323 
      else:
19324 
        iprot.skip(ftype)
19325 
      iprot.readFieldEnd()
19326 
    iprot.readStructEnd()
19327 
 
19328 
  def write(self, oprot):
19329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19331 
      return
19332 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19333 
    if self.success is not None:
2616 chandransh 19334 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19335 
      oprot.writeBool(self.success)
19336 
      oprot.writeFieldEnd()
3431 rajveer 19337 
    if self.ex is not None:
2616 chandransh 19338 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19339 
      self.ex.write(oprot)
19340 
      oprot.writeFieldEnd()
19341 
    oprot.writeFieldStop()
19342 
    oprot.writeStructEnd()
19343 
 
3431 rajveer 19344 
  def validate(self):
19345 
    return
19346 
 
19347 
 
2616 chandransh 19348 
  def __repr__(self):
19349 
    L = ['%s=%r' % (key, value)
19350 
      for key, value in self.__dict__.iteritems()]
19351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19352 
 
19353 
  def __eq__(self, other):
19354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19355 
 
19356 
  def __ne__(self, other):
19357 
    return not (self == other)
19358 
 
2690 chandransh 19359 
class getReturnOrders_args:
19360 
  """
19361 
  Attributes:
19362 
   - warehouseId
19363 
   - fromDate
19364 
   - toDate
19365 
  """
2616 chandransh 19366 
 
2690 chandransh 19367 
  thrift_spec = (
19368 
    None, # 0
19369 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19370 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19371 
    (3, TType.I64, 'toDate', None, None, ), # 3
19372 
  )
19373 
 
19374 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19375 
    self.warehouseId = warehouseId
19376 
    self.fromDate = fromDate
19377 
    self.toDate = toDate
19378 
 
19379 
  def read(self, iprot):
19380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19382 
      return
19383 
    iprot.readStructBegin()
19384 
    while True:
19385 
      (fname, ftype, fid) = iprot.readFieldBegin()
19386 
      if ftype == TType.STOP:
19387 
        break
19388 
      if fid == 1:
19389 
        if ftype == TType.I64:
19390 
          self.warehouseId = iprot.readI64();
19391 
        else:
19392 
          iprot.skip(ftype)
19393 
      elif fid == 2:
19394 
        if ftype == TType.I64:
19395 
          self.fromDate = iprot.readI64();
19396 
        else:
19397 
          iprot.skip(ftype)
19398 
      elif fid == 3:
19399 
        if ftype == TType.I64:
19400 
          self.toDate = iprot.readI64();
19401 
        else:
19402 
          iprot.skip(ftype)
19403 
      else:
19404 
        iprot.skip(ftype)
19405 
      iprot.readFieldEnd()
19406 
    iprot.readStructEnd()
19407 
 
19408 
  def write(self, oprot):
19409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19411 
      return
19412 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19413 
    if self.warehouseId is not None:
2690 chandransh 19414 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19415 
      oprot.writeI64(self.warehouseId)
19416 
      oprot.writeFieldEnd()
3431 rajveer 19417 
    if self.fromDate is not None:
2690 chandransh 19418 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19419 
      oprot.writeI64(self.fromDate)
19420 
      oprot.writeFieldEnd()
3431 rajveer 19421 
    if self.toDate is not None:
2690 chandransh 19422 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19423 
      oprot.writeI64(self.toDate)
19424 
      oprot.writeFieldEnd()
19425 
    oprot.writeFieldStop()
19426 
    oprot.writeStructEnd()
19427 
 
3431 rajveer 19428 
  def validate(self):
19429 
    return
19430 
 
19431 
 
2690 chandransh 19432 
  def __repr__(self):
19433 
    L = ['%s=%r' % (key, value)
19434 
      for key, value in self.__dict__.iteritems()]
19435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19436 
 
19437 
  def __eq__(self, other):
19438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19439 
 
19440 
  def __ne__(self, other):
19441 
    return not (self == other)
19442 
 
19443 
class getReturnOrders_result:
19444 
  """
19445 
  Attributes:
19446 
   - success
19447 
  """
19448 
 
19449 
  thrift_spec = (
19450 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19451 
  )
19452 
 
19453 
  def __init__(self, success=None,):
19454 
    self.success = success
19455 
 
19456 
  def read(self, iprot):
19457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19459 
      return
19460 
    iprot.readStructBegin()
19461 
    while True:
19462 
      (fname, ftype, fid) = iprot.readFieldBegin()
19463 
      if ftype == TType.STOP:
19464 
        break
19465 
      if fid == 0:
19466 
        if ftype == TType.LIST:
19467 
          self.success = []
6188 rajveer 19468 
          (_etype442, _size439) = iprot.readListBegin()
19469 
          for _i443 in xrange(_size439):
19470 
            _elem444 = ReturnOrder()
19471 
            _elem444.read(iprot)
19472 
            self.success.append(_elem444)
2690 chandransh 19473 
          iprot.readListEnd()
19474 
        else:
19475 
          iprot.skip(ftype)
19476 
      else:
19477 
        iprot.skip(ftype)
19478 
      iprot.readFieldEnd()
19479 
    iprot.readStructEnd()
19480 
 
19481 
  def write(self, oprot):
19482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19484 
      return
19485 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19486 
    if self.success is not None:
2690 chandransh 19487 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19488 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19489 
      for iter445 in self.success:
19490 
        iter445.write(oprot)
2690 chandransh 19491 
      oprot.writeListEnd()
19492 
      oprot.writeFieldEnd()
19493 
    oprot.writeFieldStop()
19494 
    oprot.writeStructEnd()
19495 
 
3431 rajveer 19496 
  def validate(self):
19497 
    return
19498 
 
19499 
 
2690 chandransh 19500 
  def __repr__(self):
19501 
    L = ['%s=%r' % (key, value)
19502 
      for key, value in self.__dict__.iteritems()]
19503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19504 
 
19505 
  def __eq__(self, other):
19506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19507 
 
19508 
  def __ne__(self, other):
19509 
    return not (self == other)
19510 
 
5481 phani.kuma 19511 
class getAllReturnOrders_args:
19512 
  """
19513 
  Attributes:
19514 
   - onlyNotProcessed
19515 
   - fromDate
19516 
   - toDate
19517 
  """
19518 
 
19519 
  thrift_spec = (
19520 
    None, # 0
19521 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19522 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19523 
    (3, TType.I64, 'toDate', None, None, ), # 3
19524 
  )
19525 
 
19526 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19527 
    self.onlyNotProcessed = onlyNotProcessed
19528 
    self.fromDate = fromDate
19529 
    self.toDate = toDate
19530 
 
19531 
  def read(self, iprot):
19532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19534 
      return
19535 
    iprot.readStructBegin()
19536 
    while True:
19537 
      (fname, ftype, fid) = iprot.readFieldBegin()
19538 
      if ftype == TType.STOP:
19539 
        break
19540 
      if fid == 1:
19541 
        if ftype == TType.BOOL:
19542 
          self.onlyNotProcessed = iprot.readBool();
19543 
        else:
19544 
          iprot.skip(ftype)
19545 
      elif fid == 2:
19546 
        if ftype == TType.I64:
19547 
          self.fromDate = iprot.readI64();
19548 
        else:
19549 
          iprot.skip(ftype)
19550 
      elif fid == 3:
19551 
        if ftype == TType.I64:
19552 
          self.toDate = iprot.readI64();
19553 
        else:
19554 
          iprot.skip(ftype)
19555 
      else:
19556 
        iprot.skip(ftype)
19557 
      iprot.readFieldEnd()
19558 
    iprot.readStructEnd()
19559 
 
19560 
  def write(self, oprot):
19561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19563 
      return
19564 
    oprot.writeStructBegin('getAllReturnOrders_args')
19565 
    if self.onlyNotProcessed is not None:
19566 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19567 
      oprot.writeBool(self.onlyNotProcessed)
19568 
      oprot.writeFieldEnd()
19569 
    if self.fromDate is not None:
19570 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19571 
      oprot.writeI64(self.fromDate)
19572 
      oprot.writeFieldEnd()
19573 
    if self.toDate is not None:
19574 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19575 
      oprot.writeI64(self.toDate)
19576 
      oprot.writeFieldEnd()
19577 
    oprot.writeFieldStop()
19578 
    oprot.writeStructEnd()
19579 
 
19580 
  def validate(self):
19581 
    return
19582 
 
19583 
 
19584 
  def __repr__(self):
19585 
    L = ['%s=%r' % (key, value)
19586 
      for key, value in self.__dict__.iteritems()]
19587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19588 
 
19589 
  def __eq__(self, other):
19590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19591 
 
19592 
  def __ne__(self, other):
19593 
    return not (self == other)
19594 
 
19595 
class getAllReturnOrders_result:
19596 
  """
19597 
  Attributes:
19598 
   - success
19599 
  """
19600 
 
19601 
  thrift_spec = (
19602 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19603 
  )
19604 
 
19605 
  def __init__(self, success=None,):
19606 
    self.success = success
19607 
 
19608 
  def read(self, iprot):
19609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19611 
      return
19612 
    iprot.readStructBegin()
19613 
    while True:
19614 
      (fname, ftype, fid) = iprot.readFieldBegin()
19615 
      if ftype == TType.STOP:
19616 
        break
19617 
      if fid == 0:
19618 
        if ftype == TType.LIST:
19619 
          self.success = []
6188 rajveer 19620 
          (_etype449, _size446) = iprot.readListBegin()
19621 
          for _i450 in xrange(_size446):
19622 
            _elem451 = ReturnOrder()
19623 
            _elem451.read(iprot)
19624 
            self.success.append(_elem451)
5481 phani.kuma 19625 
          iprot.readListEnd()
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      else:
19629 
        iprot.skip(ftype)
19630 
      iprot.readFieldEnd()
19631 
    iprot.readStructEnd()
19632 
 
19633 
  def write(self, oprot):
19634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19636 
      return
19637 
    oprot.writeStructBegin('getAllReturnOrders_result')
19638 
    if self.success is not None:
19639 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19640 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19641 
      for iter452 in self.success:
19642 
        iter452.write(oprot)
5481 phani.kuma 19643 
      oprot.writeListEnd()
19644 
      oprot.writeFieldEnd()
19645 
    oprot.writeFieldStop()
19646 
    oprot.writeStructEnd()
19647 
 
19648 
  def validate(self):
19649 
    return
19650 
 
19651 
 
19652 
  def __repr__(self):
19653 
    L = ['%s=%r' % (key, value)
19654 
      for key, value in self.__dict__.iteritems()]
19655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19656 
 
19657 
  def __eq__(self, other):
19658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19659 
 
19660 
  def __ne__(self, other):
19661 
    return not (self == other)
19662 
 
2700 chandransh 19663 
class getReturnOrder_args:
19664 
  """
19665 
  Attributes:
19666 
   - id
19667 
  """
19668 
 
19669 
  thrift_spec = (
19670 
    None, # 0
19671 
    (1, TType.I64, 'id', None, None, ), # 1
19672 
  )
19673 
 
19674 
  def __init__(self, id=None,):
19675 
    self.id = id
19676 
 
19677 
  def read(self, iprot):
19678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19680 
      return
19681 
    iprot.readStructBegin()
19682 
    while True:
19683 
      (fname, ftype, fid) = iprot.readFieldBegin()
19684 
      if ftype == TType.STOP:
19685 
        break
19686 
      if fid == 1:
19687 
        if ftype == TType.I64:
19688 
          self.id = iprot.readI64();
19689 
        else:
19690 
          iprot.skip(ftype)
19691 
      else:
19692 
        iprot.skip(ftype)
19693 
      iprot.readFieldEnd()
19694 
    iprot.readStructEnd()
19695 
 
19696 
  def write(self, oprot):
19697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19699 
      return
19700 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19701 
    if self.id is not None:
2700 chandransh 19702 
      oprot.writeFieldBegin('id', TType.I64, 1)
19703 
      oprot.writeI64(self.id)
19704 
      oprot.writeFieldEnd()
19705 
    oprot.writeFieldStop()
19706 
    oprot.writeStructEnd()
19707 
 
3431 rajveer 19708 
  def validate(self):
19709 
    return
19710 
 
19711 
 
2700 chandransh 19712 
  def __repr__(self):
19713 
    L = ['%s=%r' % (key, value)
19714 
      for key, value in self.__dict__.iteritems()]
19715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19716 
 
19717 
  def __eq__(self, other):
19718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19719 
 
19720 
  def __ne__(self, other):
19721 
    return not (self == other)
19722 
 
19723 
class getReturnOrder_result:
19724 
  """
19725 
  Attributes:
19726 
   - success
19727 
   - ex
19728 
  """
19729 
 
19730 
  thrift_spec = (
19731 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19732 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19733 
  )
19734 
 
19735 
  def __init__(self, success=None, ex=None,):
19736 
    self.success = success
19737 
    self.ex = ex
19738 
 
19739 
  def read(self, iprot):
19740 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19741 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19742 
      return
19743 
    iprot.readStructBegin()
19744 
    while True:
19745 
      (fname, ftype, fid) = iprot.readFieldBegin()
19746 
      if ftype == TType.STOP:
19747 
        break
19748 
      if fid == 0:
19749 
        if ftype == TType.STRUCT:
19750 
          self.success = ReturnOrder()
19751 
          self.success.read(iprot)
19752 
        else:
19753 
          iprot.skip(ftype)
19754 
      elif fid == 1:
19755 
        if ftype == TType.STRUCT:
19756 
          self.ex = TransactionServiceException()
19757 
          self.ex.read(iprot)
19758 
        else:
19759 
          iprot.skip(ftype)
19760 
      else:
19761 
        iprot.skip(ftype)
19762 
      iprot.readFieldEnd()
19763 
    iprot.readStructEnd()
19764 
 
19765 
  def write(self, oprot):
19766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19768 
      return
19769 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19770 
    if self.success is not None:
2700 chandransh 19771 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19772 
      self.success.write(oprot)
19773 
      oprot.writeFieldEnd()
3431 rajveer 19774 
    if self.ex is not None:
2700 chandransh 19775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19776 
      self.ex.write(oprot)
19777 
      oprot.writeFieldEnd()
19778 
    oprot.writeFieldStop()
19779 
    oprot.writeStructEnd()
19780 
 
3431 rajveer 19781 
  def validate(self):
19782 
    return
19783 
 
19784 
 
2700 chandransh 19785 
  def __repr__(self):
19786 
    L = ['%s=%r' % (key, value)
19787 
      for key, value in self.__dict__.iteritems()]
19788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19789 
 
19790 
  def __eq__(self, other):
19791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19792 
 
19793 
  def __ne__(self, other):
19794 
    return not (self == other)
19795 
 
2690 chandransh 19796 
class processReturn_args:
19797 
  """
19798 
  Attributes:
19799 
   - returnOrderId
19800 
  """
19801 
 
19802 
  thrift_spec = (
19803 
    None, # 0
19804 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19805 
  )
19806 
 
19807 
  def __init__(self, returnOrderId=None,):
19808 
    self.returnOrderId = returnOrderId
19809 
 
19810 
  def read(self, iprot):
19811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19813 
      return
19814 
    iprot.readStructBegin()
19815 
    while True:
19816 
      (fname, ftype, fid) = iprot.readFieldBegin()
19817 
      if ftype == TType.STOP:
19818 
        break
19819 
      if fid == 1:
19820 
        if ftype == TType.I64:
19821 
          self.returnOrderId = iprot.readI64();
19822 
        else:
19823 
          iprot.skip(ftype)
19824 
      else:
19825 
        iprot.skip(ftype)
19826 
      iprot.readFieldEnd()
19827 
    iprot.readStructEnd()
19828 
 
19829 
  def write(self, oprot):
19830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19832 
      return
19833 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19834 
    if self.returnOrderId is not None:
2690 chandransh 19835 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19836 
      oprot.writeI64(self.returnOrderId)
19837 
      oprot.writeFieldEnd()
19838 
    oprot.writeFieldStop()
19839 
    oprot.writeStructEnd()
19840 
 
3431 rajveer 19841 
  def validate(self):
19842 
    return
19843 
 
19844 
 
2690 chandransh 19845 
  def __repr__(self):
19846 
    L = ['%s=%r' % (key, value)
19847 
      for key, value in self.__dict__.iteritems()]
19848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19849 
 
19850 
  def __eq__(self, other):
19851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19852 
 
19853 
  def __ne__(self, other):
19854 
    return not (self == other)
19855 
 
19856 
class processReturn_result:
19857 
  """
19858 
  Attributes:
19859 
   - ex
19860 
  """
19861 
 
19862 
  thrift_spec = (
19863 
    None, # 0
19864 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19865 
  )
19866 
 
19867 
  def __init__(self, ex=None,):
19868 
    self.ex = ex
19869 
 
19870 
  def read(self, iprot):
19871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19873 
      return
19874 
    iprot.readStructBegin()
19875 
    while True:
19876 
      (fname, ftype, fid) = iprot.readFieldBegin()
19877 
      if ftype == TType.STOP:
19878 
        break
19879 
      if fid == 1:
19880 
        if ftype == TType.STRUCT:
19881 
          self.ex = TransactionServiceException()
19882 
          self.ex.read(iprot)
19883 
        else:
19884 
          iprot.skip(ftype)
19885 
      else:
19886 
        iprot.skip(ftype)
19887 
      iprot.readFieldEnd()
19888 
    iprot.readStructEnd()
19889 
 
19890 
  def write(self, oprot):
19891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19893 
      return
19894 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19895 
    if self.ex is not None:
2690 chandransh 19896 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19897 
      self.ex.write(oprot)
19898 
      oprot.writeFieldEnd()
19899 
    oprot.writeFieldStop()
19900 
    oprot.writeStructEnd()
19901 
 
3431 rajveer 19902 
  def validate(self):
19903 
    return
19904 
 
19905 
 
2690 chandransh 19906 
  def __repr__(self):
19907 
    L = ['%s=%r' % (key, value)
19908 
      for key, value in self.__dict__.iteritems()]
19909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19910 
 
19911 
  def __eq__(self, other):
19912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19913 
 
19914 
  def __ne__(self, other):
19915 
    return not (self == other)
19916 
 
3451 chandransh 19917 
class updateWeight_args:
19918 
  """
19919 
  Attributes:
19920 
   - orderId
19921 
   - weight
19922 
  """
19923 
 
19924 
  thrift_spec = (
19925 
    None, # 0
19926 
    (1, TType.I64, 'orderId', None, None, ), # 1
19927 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19928 
  )
19929 
 
19930 
  def __init__(self, orderId=None, weight=None,):
19931 
    self.orderId = orderId
19932 
    self.weight = weight
19933 
 
19934 
  def read(self, iprot):
19935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19937 
      return
19938 
    iprot.readStructBegin()
19939 
    while True:
19940 
      (fname, ftype, fid) = iprot.readFieldBegin()
19941 
      if ftype == TType.STOP:
19942 
        break
19943 
      if fid == 1:
19944 
        if ftype == TType.I64:
19945 
          self.orderId = iprot.readI64();
19946 
        else:
19947 
          iprot.skip(ftype)
19948 
      elif fid == 2:
19949 
        if ftype == TType.DOUBLE:
19950 
          self.weight = iprot.readDouble();
19951 
        else:
19952 
          iprot.skip(ftype)
19953 
      else:
19954 
        iprot.skip(ftype)
19955 
      iprot.readFieldEnd()
19956 
    iprot.readStructEnd()
19957 
 
19958 
  def write(self, oprot):
19959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19961 
      return
19962 
    oprot.writeStructBegin('updateWeight_args')
19963 
    if self.orderId is not None:
19964 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19965 
      oprot.writeI64(self.orderId)
19966 
      oprot.writeFieldEnd()
19967 
    if self.weight is not None:
19968 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19969 
      oprot.writeDouble(self.weight)
19970 
      oprot.writeFieldEnd()
19971 
    oprot.writeFieldStop()
19972 
    oprot.writeStructEnd()
19973 
 
19974 
  def validate(self):
19975 
    return
19976 
 
19977 
 
19978 
  def __repr__(self):
19979 
    L = ['%s=%r' % (key, value)
19980 
      for key, value in self.__dict__.iteritems()]
19981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19982 
 
19983 
  def __eq__(self, other):
19984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19985 
 
19986 
  def __ne__(self, other):
19987 
    return not (self == other)
19988 
 
19989 
class updateWeight_result:
19990 
  """
19991 
  Attributes:
19992 
   - success
19993 
   - ex
19994 
  """
19995 
 
19996 
  thrift_spec = (
19997 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19998 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19999 
  )
20000 
 
20001 
  def __init__(self, success=None, ex=None,):
20002 
    self.success = success
20003 
    self.ex = ex
20004 
 
20005 
  def read(self, iprot):
20006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20008 
      return
20009 
    iprot.readStructBegin()
20010 
    while True:
20011 
      (fname, ftype, fid) = iprot.readFieldBegin()
20012 
      if ftype == TType.STOP:
20013 
        break
20014 
      if fid == 0:
20015 
        if ftype == TType.STRUCT:
20016 
          self.success = Order()
20017 
          self.success.read(iprot)
20018 
        else:
20019 
          iprot.skip(ftype)
20020 
      elif fid == 1:
20021 
        if ftype == TType.STRUCT:
20022 
          self.ex = TransactionServiceException()
20023 
          self.ex.read(iprot)
20024 
        else:
20025 
          iprot.skip(ftype)
20026 
      else:
20027 
        iprot.skip(ftype)
20028 
      iprot.readFieldEnd()
20029 
    iprot.readStructEnd()
20030 
 
20031 
  def write(self, oprot):
20032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20034 
      return
20035 
    oprot.writeStructBegin('updateWeight_result')
20036 
    if self.success is not None:
20037 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20038 
      self.success.write(oprot)
20039 
      oprot.writeFieldEnd()
20040 
    if self.ex is not None:
20041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20042 
      self.ex.write(oprot)
20043 
      oprot.writeFieldEnd()
20044 
    oprot.writeFieldStop()
20045 
    oprot.writeStructEnd()
20046 
 
20047 
  def validate(self):
20048 
    return
20049 
 
20050 
 
20051 
  def __repr__(self):
20052 
    L = ['%s=%r' % (key, value)
20053 
      for key, value in self.__dict__.iteritems()]
20054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20055 
 
20056 
  def __eq__(self, other):
20057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20058 
 
20059 
  def __ne__(self, other):
20060 
    return not (self == other)
3469 chandransh 20061 
 
20062 
class changeItem_args:
20063 
  """
20064 
  Attributes:
20065 
   - orderId
20066 
   - itemId
20067 
  """
20068 
 
20069 
  thrift_spec = (
20070 
    None, # 0
20071 
    (1, TType.I64, 'orderId', None, None, ), # 1
20072 
    (2, TType.I64, 'itemId', None, None, ), # 2
20073 
  )
20074 
 
20075 
  def __init__(self, orderId=None, itemId=None,):
20076 
    self.orderId = orderId
20077 
    self.itemId = itemId
20078 
 
20079 
  def read(self, iprot):
20080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20082 
      return
20083 
    iprot.readStructBegin()
20084 
    while True:
20085 
      (fname, ftype, fid) = iprot.readFieldBegin()
20086 
      if ftype == TType.STOP:
20087 
        break
20088 
      if fid == 1:
20089 
        if ftype == TType.I64:
20090 
          self.orderId = iprot.readI64();
20091 
        else:
20092 
          iprot.skip(ftype)
20093 
      elif fid == 2:
20094 
        if ftype == TType.I64:
20095 
          self.itemId = iprot.readI64();
20096 
        else:
20097 
          iprot.skip(ftype)
20098 
      else:
20099 
        iprot.skip(ftype)
20100 
      iprot.readFieldEnd()
20101 
    iprot.readStructEnd()
20102 
 
20103 
  def write(self, oprot):
20104 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20105 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20106 
      return
20107 
    oprot.writeStructBegin('changeItem_args')
20108 
    if self.orderId is not None:
20109 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20110 
      oprot.writeI64(self.orderId)
20111 
      oprot.writeFieldEnd()
20112 
    if self.itemId is not None:
20113 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20114 
      oprot.writeI64(self.itemId)
20115 
      oprot.writeFieldEnd()
20116 
    oprot.writeFieldStop()
20117 
    oprot.writeStructEnd()
20118 
 
20119 
  def validate(self):
20120 
    return
20121 
 
20122 
 
20123 
  def __repr__(self):
20124 
    L = ['%s=%r' % (key, value)
20125 
      for key, value in self.__dict__.iteritems()]
20126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20127 
 
20128 
  def __eq__(self, other):
20129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20130 
 
20131 
  def __ne__(self, other):
20132 
    return not (self == other)
20133 
 
20134 
class changeItem_result:
20135 
  """
20136 
  Attributes:
20137 
   - success
20138 
   - ex
20139 
  """
20140 
 
20141 
  thrift_spec = (
20142 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20144 
  )
20145 
 
20146 
  def __init__(self, success=None, ex=None,):
20147 
    self.success = success
20148 
    self.ex = ex
20149 
 
20150 
  def read(self, iprot):
20151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20153 
      return
20154 
    iprot.readStructBegin()
20155 
    while True:
20156 
      (fname, ftype, fid) = iprot.readFieldBegin()
20157 
      if ftype == TType.STOP:
20158 
        break
20159 
      if fid == 0:
20160 
        if ftype == TType.STRUCT:
20161 
          self.success = Order()
20162 
          self.success.read(iprot)
20163 
        else:
20164 
          iprot.skip(ftype)
20165 
      elif fid == 1:
20166 
        if ftype == TType.STRUCT:
20167 
          self.ex = TransactionServiceException()
20168 
          self.ex.read(iprot)
20169 
        else:
20170 
          iprot.skip(ftype)
20171 
      else:
20172 
        iprot.skip(ftype)
20173 
      iprot.readFieldEnd()
20174 
    iprot.readStructEnd()
20175 
 
20176 
  def write(self, oprot):
20177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20179 
      return
20180 
    oprot.writeStructBegin('changeItem_result')
20181 
    if self.success is not None:
20182 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20183 
      self.success.write(oprot)
20184 
      oprot.writeFieldEnd()
20185 
    if self.ex is not None:
20186 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20187 
      self.ex.write(oprot)
20188 
      oprot.writeFieldEnd()
20189 
    oprot.writeFieldStop()
20190 
    oprot.writeStructEnd()
20191 
 
20192 
  def validate(self):
20193 
    return
20194 
 
20195 
 
20196 
  def __repr__(self):
20197 
    L = ['%s=%r' % (key, value)
20198 
      for key, value in self.__dict__.iteritems()]
20199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20200 
 
20201 
  def __eq__(self, other):
20202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20203 
 
20204 
  def __ne__(self, other):
20205 
    return not (self == other)
20206 
 
20207 
class shiftToWarehouse_args:
20208 
  """
20209 
  Attributes:
20210 
   - orderId
20211 
   - warehouseId
20212 
  """
20213 
 
20214 
  thrift_spec = (
20215 
    None, # 0
20216 
    (1, TType.I64, 'orderId', None, None, ), # 1
20217 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20218 
  )
20219 
 
20220 
  def __init__(self, orderId=None, warehouseId=None,):
20221 
    self.orderId = orderId
20222 
    self.warehouseId = warehouseId
20223 
 
20224 
  def read(self, iprot):
20225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20227 
      return
20228 
    iprot.readStructBegin()
20229 
    while True:
20230 
      (fname, ftype, fid) = iprot.readFieldBegin()
20231 
      if ftype == TType.STOP:
20232 
        break
20233 
      if fid == 1:
20234 
        if ftype == TType.I64:
20235 
          self.orderId = iprot.readI64();
20236 
        else:
20237 
          iprot.skip(ftype)
20238 
      elif fid == 2:
20239 
        if ftype == TType.I64:
20240 
          self.warehouseId = iprot.readI64();
20241 
        else:
20242 
          iprot.skip(ftype)
20243 
      else:
20244 
        iprot.skip(ftype)
20245 
      iprot.readFieldEnd()
20246 
    iprot.readStructEnd()
20247 
 
20248 
  def write(self, oprot):
20249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20251 
      return
20252 
    oprot.writeStructBegin('shiftToWarehouse_args')
20253 
    if self.orderId is not None:
20254 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20255 
      oprot.writeI64(self.orderId)
20256 
      oprot.writeFieldEnd()
20257 
    if self.warehouseId is not None:
20258 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20259 
      oprot.writeI64(self.warehouseId)
20260 
      oprot.writeFieldEnd()
20261 
    oprot.writeFieldStop()
20262 
    oprot.writeStructEnd()
20263 
 
20264 
  def validate(self):
20265 
    return
20266 
 
20267 
 
20268 
  def __repr__(self):
20269 
    L = ['%s=%r' % (key, value)
20270 
      for key, value in self.__dict__.iteritems()]
20271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20272 
 
20273 
  def __eq__(self, other):
20274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20275 
 
20276 
  def __ne__(self, other):
20277 
    return not (self == other)
20278 
 
20279 
class shiftToWarehouse_result:
20280 
  """
20281 
  Attributes:
20282 
   - success
20283 
   - ex
20284 
  """
20285 
 
20286 
  thrift_spec = (
20287 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20289 
  )
20290 
 
20291 
  def __init__(self, success=None, ex=None,):
20292 
    self.success = success
20293 
    self.ex = ex
20294 
 
20295 
  def read(self, iprot):
20296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20298 
      return
20299 
    iprot.readStructBegin()
20300 
    while True:
20301 
      (fname, ftype, fid) = iprot.readFieldBegin()
20302 
      if ftype == TType.STOP:
20303 
        break
20304 
      if fid == 0:
20305 
        if ftype == TType.STRUCT:
20306 
          self.success = Order()
20307 
          self.success.read(iprot)
20308 
        else:
20309 
          iprot.skip(ftype)
20310 
      elif fid == 1:
20311 
        if ftype == TType.STRUCT:
20312 
          self.ex = TransactionServiceException()
20313 
          self.ex.read(iprot)
20314 
        else:
20315 
          iprot.skip(ftype)
20316 
      else:
20317 
        iprot.skip(ftype)
20318 
      iprot.readFieldEnd()
20319 
    iprot.readStructEnd()
20320 
 
20321 
  def write(self, oprot):
20322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20324 
      return
20325 
    oprot.writeStructBegin('shiftToWarehouse_result')
20326 
    if self.success is not None:
20327 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20328 
      self.success.write(oprot)
20329 
      oprot.writeFieldEnd()
20330 
    if self.ex is not None:
20331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20332 
      self.ex.write(oprot)
20333 
      oprot.writeFieldEnd()
20334 
    oprot.writeFieldStop()
20335 
    oprot.writeStructEnd()
20336 
 
20337 
  def validate(self):
20338 
    return
20339 
 
20340 
 
20341 
  def __repr__(self):
20342 
    L = ['%s=%r' % (key, value)
20343 
      for key, value in self.__dict__.iteritems()]
20344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20345 
 
20346 
  def __eq__(self, other):
20347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20348 
 
20349 
  def __ne__(self, other):
20350 
    return not (self == other)
3553 chandransh 20351 
 
20352 
class addDelayReason_args:
20353 
  """
20354 
  Attributes:
20355 
   - orderId
20356 
   - delayReason
3986 chandransh 20357 
   - furtherDelay
4647 rajveer 20358 
   - delayReasonText
3553 chandransh 20359 
  """
20360 
 
20361 
  thrift_spec = (
20362 
    None, # 0
20363 
    (1, TType.I64, 'orderId', None, None, ), # 1
20364 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20365 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20366 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20367 
  )
20368 
 
4647 rajveer 20369 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20370 
    self.orderId = orderId
20371 
    self.delayReason = delayReason
3986 chandransh 20372 
    self.furtherDelay = furtherDelay
4647 rajveer 20373 
    self.delayReasonText = delayReasonText
3553 chandransh 20374 
 
20375 
  def read(self, iprot):
20376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20378 
      return
20379 
    iprot.readStructBegin()
20380 
    while True:
20381 
      (fname, ftype, fid) = iprot.readFieldBegin()
20382 
      if ftype == TType.STOP:
20383 
        break
20384 
      if fid == 1:
20385 
        if ftype == TType.I64:
20386 
          self.orderId = iprot.readI64();
20387 
        else:
20388 
          iprot.skip(ftype)
20389 
      elif fid == 2:
20390 
        if ftype == TType.I32:
20391 
          self.delayReason = iprot.readI32();
20392 
        else:
20393 
          iprot.skip(ftype)
3986 chandransh 20394 
      elif fid == 3:
20395 
        if ftype == TType.I64:
20396 
          self.furtherDelay = iprot.readI64();
20397 
        else:
20398 
          iprot.skip(ftype)
4647 rajveer 20399 
      elif fid == 4:
20400 
        if ftype == TType.STRING:
20401 
          self.delayReasonText = iprot.readString();
20402 
        else:
20403 
          iprot.skip(ftype)
3553 chandransh 20404 
      else:
20405 
        iprot.skip(ftype)
20406 
      iprot.readFieldEnd()
20407 
    iprot.readStructEnd()
20408 
 
20409 
  def write(self, oprot):
20410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20412 
      return
20413 
    oprot.writeStructBegin('addDelayReason_args')
20414 
    if self.orderId is not None:
20415 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20416 
      oprot.writeI64(self.orderId)
20417 
      oprot.writeFieldEnd()
20418 
    if self.delayReason is not None:
20419 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20420 
      oprot.writeI32(self.delayReason)
20421 
      oprot.writeFieldEnd()
3986 chandransh 20422 
    if self.furtherDelay is not None:
20423 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20424 
      oprot.writeI64(self.furtherDelay)
20425 
      oprot.writeFieldEnd()
4647 rajveer 20426 
    if self.delayReasonText is not None:
20427 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20428 
      oprot.writeString(self.delayReasonText)
20429 
      oprot.writeFieldEnd()
3553 chandransh 20430 
    oprot.writeFieldStop()
20431 
    oprot.writeStructEnd()
20432 
 
20433 
  def validate(self):
20434 
    return
20435 
 
20436 
 
20437 
  def __repr__(self):
20438 
    L = ['%s=%r' % (key, value)
20439 
      for key, value in self.__dict__.iteritems()]
20440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20441 
 
20442 
  def __eq__(self, other):
20443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20444 
 
20445 
  def __ne__(self, other):
20446 
    return not (self == other)
20447 
 
20448 
class addDelayReason_result:
20449 
  """
20450 
  Attributes:
20451 
   - success
20452 
   - ex
20453 
  """
20454 
 
20455 
  thrift_spec = (
20456 
    (0, TType.BOOL, 'success', None, None, ), # 0
20457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20458 
  )
20459 
 
20460 
  def __init__(self, success=None, ex=None,):
20461 
    self.success = success
20462 
    self.ex = ex
20463 
 
20464 
  def read(self, iprot):
20465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20467 
      return
20468 
    iprot.readStructBegin()
20469 
    while True:
20470 
      (fname, ftype, fid) = iprot.readFieldBegin()
20471 
      if ftype == TType.STOP:
20472 
        break
20473 
      if fid == 0:
20474 
        if ftype == TType.BOOL:
20475 
          self.success = iprot.readBool();
20476 
        else:
20477 
          iprot.skip(ftype)
20478 
      elif fid == 1:
20479 
        if ftype == TType.STRUCT:
20480 
          self.ex = TransactionServiceException()
20481 
          self.ex.read(iprot)
20482 
        else:
20483 
          iprot.skip(ftype)
20484 
      else:
20485 
        iprot.skip(ftype)
20486 
      iprot.readFieldEnd()
20487 
    iprot.readStructEnd()
20488 
 
20489 
  def write(self, oprot):
20490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20492 
      return
20493 
    oprot.writeStructBegin('addDelayReason_result')
20494 
    if self.success is not None:
20495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20496 
      oprot.writeBool(self.success)
20497 
      oprot.writeFieldEnd()
20498 
    if self.ex is not None:
20499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20500 
      self.ex.write(oprot)
20501 
      oprot.writeFieldEnd()
20502 
    oprot.writeFieldStop()
20503 
    oprot.writeStructEnd()
20504 
 
20505 
  def validate(self):
20506 
    return
20507 
 
20508 
 
20509 
  def __repr__(self):
20510 
    L = ['%s=%r' % (key, value)
20511 
      for key, value in self.__dict__.iteritems()]
20512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20513 
 
20514 
  def __eq__(self, other):
20515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20516 
 
20517 
  def __ne__(self, other):
20518 
    return not (self == other)
3956 chandransh 20519 
 
20520 
class reconcileCodCollection_args:
20521 
  """
20522 
  Attributes:
20523 
   - collectedAmountMap
20524 
   - xferBy
20525 
   - xferTxnId
20526 
   - xferDate
20527 
  """
20528 
 
20529 
  thrift_spec = (
20530 
    None, # 0
20531 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20532 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20533 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20534 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20535 
  )
20536 
 
20537 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20538 
    self.collectedAmountMap = collectedAmountMap
20539 
    self.xferBy = xferBy
20540 
    self.xferTxnId = xferTxnId
20541 
    self.xferDate = xferDate
20542 
 
20543 
  def read(self, iprot):
20544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20546 
      return
20547 
    iprot.readStructBegin()
20548 
    while True:
20549 
      (fname, ftype, fid) = iprot.readFieldBegin()
20550 
      if ftype == TType.STOP:
20551 
        break
20552 
      if fid == 1:
20553 
        if ftype == TType.MAP:
20554 
          self.collectedAmountMap = {}
6188 rajveer 20555 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20556 
          for _i457 in xrange(_size453):
20557 
            _key458 = iprot.readString();
20558 
            _val459 = iprot.readDouble();
20559 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20560 
          iprot.readMapEnd()
20561 
        else:
20562 
          iprot.skip(ftype)
20563 
      elif fid == 2:
20564 
        if ftype == TType.STRING:
20565 
          self.xferBy = iprot.readString();
20566 
        else:
20567 
          iprot.skip(ftype)
20568 
      elif fid == 3:
20569 
        if ftype == TType.STRING:
20570 
          self.xferTxnId = iprot.readString();
20571 
        else:
20572 
          iprot.skip(ftype)
20573 
      elif fid == 4:
20574 
        if ftype == TType.I64:
20575 
          self.xferDate = iprot.readI64();
20576 
        else:
20577 
          iprot.skip(ftype)
20578 
      else:
20579 
        iprot.skip(ftype)
20580 
      iprot.readFieldEnd()
20581 
    iprot.readStructEnd()
20582 
 
20583 
  def write(self, oprot):
20584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20586 
      return
20587 
    oprot.writeStructBegin('reconcileCodCollection_args')
20588 
    if self.collectedAmountMap is not None:
20589 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20590 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20591 
      for kiter460,viter461 in self.collectedAmountMap.items():
20592 
        oprot.writeString(kiter460)
20593 
        oprot.writeDouble(viter461)
3956 chandransh 20594 
      oprot.writeMapEnd()
20595 
      oprot.writeFieldEnd()
20596 
    if self.xferBy is not None:
20597 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20598 
      oprot.writeString(self.xferBy)
20599 
      oprot.writeFieldEnd()
20600 
    if self.xferTxnId is not None:
20601 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20602 
      oprot.writeString(self.xferTxnId)
20603 
      oprot.writeFieldEnd()
20604 
    if self.xferDate is not None:
20605 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20606 
      oprot.writeI64(self.xferDate)
20607 
      oprot.writeFieldEnd()
20608 
    oprot.writeFieldStop()
20609 
    oprot.writeStructEnd()
20610 
 
20611 
  def validate(self):
20612 
    return
20613 
 
20614 
 
20615 
  def __repr__(self):
20616 
    L = ['%s=%r' % (key, value)
20617 
      for key, value in self.__dict__.iteritems()]
20618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20619 
 
20620 
  def __eq__(self, other):
20621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20622 
 
20623 
  def __ne__(self, other):
20624 
    return not (self == other)
20625 
 
20626 
class reconcileCodCollection_result:
20627 
  """
20628 
  Attributes:
20629 
   - success
20630 
   - ex
20631 
  """
20632 
 
20633 
  thrift_spec = (
20634 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20635 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20636 
  )
20637 
 
20638 
  def __init__(self, success=None, ex=None,):
20639 
    self.success = success
20640 
    self.ex = ex
20641 
 
20642 
  def read(self, iprot):
20643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20645 
      return
20646 
    iprot.readStructBegin()
20647 
    while True:
20648 
      (fname, ftype, fid) = iprot.readFieldBegin()
20649 
      if ftype == TType.STOP:
20650 
        break
20651 
      if fid == 0:
20652 
        if ftype == TType.MAP:
20653 
          self.success = {}
6188 rajveer 20654 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20655 
          for _i466 in xrange(_size462):
20656 
            _key467 = iprot.readString();
20657 
            _val468 = iprot.readString();
20658 
            self.success[_key467] = _val468
3956 chandransh 20659 
          iprot.readMapEnd()
20660 
        else:
20661 
          iprot.skip(ftype)
20662 
      elif fid == 1:
20663 
        if ftype == TType.STRUCT:
20664 
          self.ex = TransactionServiceException()
20665 
          self.ex.read(iprot)
20666 
        else:
20667 
          iprot.skip(ftype)
20668 
      else:
20669 
        iprot.skip(ftype)
20670 
      iprot.readFieldEnd()
20671 
    iprot.readStructEnd()
20672 
 
20673 
  def write(self, oprot):
20674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20676 
      return
20677 
    oprot.writeStructBegin('reconcileCodCollection_result')
20678 
    if self.success is not None:
20679 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20680 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20681 
      for kiter469,viter470 in self.success.items():
20682 
        oprot.writeString(kiter469)
20683 
        oprot.writeString(viter470)
3956 chandransh 20684 
      oprot.writeMapEnd()
20685 
      oprot.writeFieldEnd()
20686 
    if self.ex is not None:
20687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20688 
      self.ex.write(oprot)
20689 
      oprot.writeFieldEnd()
20690 
    oprot.writeFieldStop()
20691 
    oprot.writeStructEnd()
20692 
 
20693 
  def validate(self):
20694 
    return
20695 
 
20696 
 
20697 
  def __repr__(self):
20698 
    L = ['%s=%r' % (key, value)
20699 
      for key, value in self.__dict__.iteritems()]
20700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20701 
 
20702 
  def __eq__(self, other):
20703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20704 
 
20705 
  def __ne__(self, other):
20706 
    return not (self == other)
4008 mandeep.dh 20707 
 
20708 
class getTransactionsRequiringExtraProcessing_args:
20709 
  """
20710 
  Attributes:
20711 
   - category
20712 
  """
20713 
 
20714 
  thrift_spec = (
20715 
    None, # 0
20716 
    (1, TType.I32, 'category', None, None, ), # 1
20717 
  )
20718 
 
20719 
  def __init__(self, category=None,):
20720 
    self.category = category
20721 
 
20722 
  def read(self, iprot):
20723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20725 
      return
20726 
    iprot.readStructBegin()
20727 
    while True:
20728 
      (fname, ftype, fid) = iprot.readFieldBegin()
20729 
      if ftype == TType.STOP:
20730 
        break
20731 
      if fid == 1:
20732 
        if ftype == TType.I32:
20733 
          self.category = iprot.readI32();
20734 
        else:
20735 
          iprot.skip(ftype)
20736 
      else:
20737 
        iprot.skip(ftype)
20738 
      iprot.readFieldEnd()
20739 
    iprot.readStructEnd()
20740 
 
20741 
  def write(self, oprot):
20742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20744 
      return
20745 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20746 
    if self.category is not None:
20747 
      oprot.writeFieldBegin('category', TType.I32, 1)
20748 
      oprot.writeI32(self.category)
20749 
      oprot.writeFieldEnd()
20750 
    oprot.writeFieldStop()
20751 
    oprot.writeStructEnd()
20752 
 
20753 
  def validate(self):
20754 
    return
20755 
 
20756 
 
20757 
  def __repr__(self):
20758 
    L = ['%s=%r' % (key, value)
20759 
      for key, value in self.__dict__.iteritems()]
20760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20761 
 
20762 
  def __eq__(self, other):
20763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20764 
 
20765 
  def __ne__(self, other):
20766 
    return not (self == other)
20767 
 
20768 
class getTransactionsRequiringExtraProcessing_result:
20769 
  """
20770 
  Attributes:
20771 
   - success
20772 
  """
20773 
 
20774 
  thrift_spec = (
20775 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20776 
  )
20777 
 
20778 
  def __init__(self, success=None,):
20779 
    self.success = success
20780 
 
20781 
  def read(self, iprot):
20782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20784 
      return
20785 
    iprot.readStructBegin()
20786 
    while True:
20787 
      (fname, ftype, fid) = iprot.readFieldBegin()
20788 
      if ftype == TType.STOP:
20789 
        break
20790 
      if fid == 0:
20791 
        if ftype == TType.LIST:
20792 
          self.success = []
6188 rajveer 20793 
          (_etype474, _size471) = iprot.readListBegin()
20794 
          for _i475 in xrange(_size471):
20795 
            _elem476 = iprot.readI64();
20796 
            self.success.append(_elem476)
4008 mandeep.dh 20797 
          iprot.readListEnd()
20798 
        else:
20799 
          iprot.skip(ftype)
20800 
      else:
20801 
        iprot.skip(ftype)
20802 
      iprot.readFieldEnd()
20803 
    iprot.readStructEnd()
20804 
 
20805 
  def write(self, oprot):
20806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20808 
      return
20809 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20810 
    if self.success is not None:
20811 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20812 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20813 
      for iter477 in self.success:
20814 
        oprot.writeI64(iter477)
4008 mandeep.dh 20815 
      oprot.writeListEnd()
20816 
      oprot.writeFieldEnd()
20817 
    oprot.writeFieldStop()
20818 
    oprot.writeStructEnd()
20819 
 
20820 
  def validate(self):
20821 
    return
20822 
 
20823 
 
20824 
  def __repr__(self):
20825 
    L = ['%s=%r' % (key, value)
20826 
      for key, value in self.__dict__.iteritems()]
20827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20828 
 
20829 
  def __eq__(self, other):
20830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20831 
 
20832 
  def __ne__(self, other):
20833 
    return not (self == other)
20834 
 
20835 
class markTransactionAsProcessed_args:
20836 
  """
20837 
  Attributes:
20838 
   - transactionId
20839 
   - category
20840 
  """
20841 
 
20842 
  thrift_spec = (
20843 
    None, # 0
20844 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20845 
    (2, TType.I32, 'category', None, None, ), # 2
20846 
  )
20847 
 
20848 
  def __init__(self, transactionId=None, category=None,):
20849 
    self.transactionId = transactionId
20850 
    self.category = category
20851 
 
20852 
  def read(self, iprot):
20853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20855 
      return
20856 
    iprot.readStructBegin()
20857 
    while True:
20858 
      (fname, ftype, fid) = iprot.readFieldBegin()
20859 
      if ftype == TType.STOP:
20860 
        break
20861 
      if fid == 1:
20862 
        if ftype == TType.I64:
20863 
          self.transactionId = iprot.readI64();
20864 
        else:
20865 
          iprot.skip(ftype)
20866 
      elif fid == 2:
20867 
        if ftype == TType.I32:
20868 
          self.category = iprot.readI32();
20869 
        else:
20870 
          iprot.skip(ftype)
20871 
      else:
20872 
        iprot.skip(ftype)
20873 
      iprot.readFieldEnd()
20874 
    iprot.readStructEnd()
20875 
 
20876 
  def write(self, oprot):
20877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20879 
      return
20880 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20881 
    if self.transactionId is not None:
20882 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20883 
      oprot.writeI64(self.transactionId)
20884 
      oprot.writeFieldEnd()
20885 
    if self.category is not None:
20886 
      oprot.writeFieldBegin('category', TType.I32, 2)
20887 
      oprot.writeI32(self.category)
20888 
      oprot.writeFieldEnd()
20889 
    oprot.writeFieldStop()
20890 
    oprot.writeStructEnd()
20891 
 
20892 
  def validate(self):
20893 
    return
20894 
 
20895 
 
20896 
  def __repr__(self):
20897 
    L = ['%s=%r' % (key, value)
20898 
      for key, value in self.__dict__.iteritems()]
20899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20900 
 
20901 
  def __eq__(self, other):
20902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20903 
 
20904 
  def __ne__(self, other):
20905 
    return not (self == other)
20906 
 
20907 
class markTransactionAsProcessed_result:
20908 
 
20909 
  thrift_spec = (
20910 
  )
20911 
 
20912 
  def read(self, iprot):
20913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20915 
      return
20916 
    iprot.readStructBegin()
20917 
    while True:
20918 
      (fname, ftype, fid) = iprot.readFieldBegin()
20919 
      if ftype == TType.STOP:
20920 
        break
20921 
      else:
20922 
        iprot.skip(ftype)
20923 
      iprot.readFieldEnd()
20924 
    iprot.readStructEnd()
20925 
 
20926 
  def write(self, oprot):
20927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20929 
      return
20930 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20931 
    oprot.writeFieldStop()
20932 
    oprot.writeStructEnd()
20933 
 
20934 
  def validate(self):
20935 
    return
20936 
 
20937 
 
20938 
  def __repr__(self):
20939 
    L = ['%s=%r' % (key, value)
20940 
      for key, value in self.__dict__.iteritems()]
20941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20942 
 
20943 
  def __eq__(self, other):
20944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20945 
 
20946 
  def __ne__(self, other):
20947 
    return not (self == other)
4018 chandransh 20948 
 
20949 
class getItemWiseRiskyOrdersCount_args:
20950 
 
20951 
  thrift_spec = (
20952 
  )
20953 
 
20954 
  def read(self, iprot):
20955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20957 
      return
20958 
    iprot.readStructBegin()
20959 
    while True:
20960 
      (fname, ftype, fid) = iprot.readFieldBegin()
20961 
      if ftype == TType.STOP:
20962 
        break
20963 
      else:
20964 
        iprot.skip(ftype)
20965 
      iprot.readFieldEnd()
20966 
    iprot.readStructEnd()
20967 
 
20968 
  def write(self, oprot):
20969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20971 
      return
20972 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20973 
    oprot.writeFieldStop()
20974 
    oprot.writeStructEnd()
20975 
 
20976 
  def validate(self):
20977 
    return
20978 
 
20979 
 
20980 
  def __repr__(self):
20981 
    L = ['%s=%r' % (key, value)
20982 
      for key, value in self.__dict__.iteritems()]
20983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20984 
 
20985 
  def __eq__(self, other):
20986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20987 
 
20988 
  def __ne__(self, other):
20989 
    return not (self == other)
20990 
 
20991 
class getItemWiseRiskyOrdersCount_result:
20992 
  """
20993 
  Attributes:
20994 
   - success
20995 
  """
20996 
 
20997 
  thrift_spec = (
20998 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20999 
  )
21000 
 
21001 
  def __init__(self, success=None,):
21002 
    self.success = success
21003 
 
21004 
  def read(self, iprot):
21005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21007 
      return
21008 
    iprot.readStructBegin()
21009 
    while True:
21010 
      (fname, ftype, fid) = iprot.readFieldBegin()
21011 
      if ftype == TType.STOP:
21012 
        break
21013 
      if fid == 0:
21014 
        if ftype == TType.MAP:
21015 
          self.success = {}
6188 rajveer 21016 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21017 
          for _i482 in xrange(_size478):
21018 
            _key483 = iprot.readI64();
21019 
            _val484 = iprot.readI64();
21020 
            self.success[_key483] = _val484
4018 chandransh 21021 
          iprot.readMapEnd()
21022 
        else:
21023 
          iprot.skip(ftype)
21024 
      else:
21025 
        iprot.skip(ftype)
21026 
      iprot.readFieldEnd()
21027 
    iprot.readStructEnd()
21028 
 
21029 
  def write(self, oprot):
21030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21032 
      return
21033 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21034 
    if self.success is not None:
21035 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21036 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21037 
      for kiter485,viter486 in self.success.items():
21038 
        oprot.writeI64(kiter485)
21039 
        oprot.writeI64(viter486)
4018 chandransh 21040 
      oprot.writeMapEnd()
21041 
      oprot.writeFieldEnd()
21042 
    oprot.writeFieldStop()
21043 
    oprot.writeStructEnd()
21044 
 
21045 
  def validate(self):
21046 
    return
21047 
 
21048 
 
21049 
  def __repr__(self):
21050 
    L = ['%s=%r' % (key, value)
21051 
      for key, value in self.__dict__.iteritems()]
21052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21053 
 
21054 
  def __eq__(self, other):
21055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21056 
 
21057 
  def __ne__(self, other):
21058 
    return not (self == other)
4247 rajveer 21059 
 
4295 varun.gupt 21060 
class getOrdersForItemIds_args:
21061 
  """
21062 
  Attributes:
21063 
   - itemIds
21064 
  """
21065 
 
21066 
  thrift_spec = (
21067 
    None, # 0
21068 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21069 
  )
21070 
 
21071 
  def __init__(self, itemIds=None,):
21072 
    self.itemIds = itemIds
21073 
 
21074 
  def read(self, iprot):
21075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21077 
      return
21078 
    iprot.readStructBegin()
21079 
    while True:
21080 
      (fname, ftype, fid) = iprot.readFieldBegin()
21081 
      if ftype == TType.STOP:
21082 
        break
21083 
      if fid == 1:
21084 
        if ftype == TType.LIST:
21085 
          self.itemIds = []
6188 rajveer 21086 
          (_etype490, _size487) = iprot.readListBegin()
21087 
          for _i491 in xrange(_size487):
21088 
            _elem492 = iprot.readI64();
21089 
            self.itemIds.append(_elem492)
4295 varun.gupt 21090 
          iprot.readListEnd()
21091 
        else:
21092 
          iprot.skip(ftype)
21093 
      else:
21094 
        iprot.skip(ftype)
21095 
      iprot.readFieldEnd()
21096 
    iprot.readStructEnd()
21097 
 
21098 
  def write(self, oprot):
21099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21101 
      return
21102 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21103 
    if self.itemIds is not None:
21104 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21105 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21106 
      for iter493 in self.itemIds:
21107 
        oprot.writeI64(iter493)
4295 varun.gupt 21108 
      oprot.writeListEnd()
21109 
      oprot.writeFieldEnd()
21110 
    oprot.writeFieldStop()
21111 
    oprot.writeStructEnd()
21112 
 
21113 
  def validate(self):
21114 
    return
21115 
 
21116 
 
21117 
  def __repr__(self):
21118 
    L = ['%s=%r' % (key, value)
21119 
      for key, value in self.__dict__.iteritems()]
21120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21121 
 
21122 
  def __eq__(self, other):
21123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21124 
 
21125 
  def __ne__(self, other):
21126 
    return not (self == other)
21127 
 
21128 
class getOrdersForItemIds_result:
21129 
  """
21130 
  Attributes:
21131 
   - success
21132 
  """
21133 
 
21134 
  thrift_spec = (
21135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21136 
  )
21137 
 
21138 
  def __init__(self, success=None,):
21139 
    self.success = success
21140 
 
21141 
  def read(self, iprot):
21142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21144 
      return
21145 
    iprot.readStructBegin()
21146 
    while True:
21147 
      (fname, ftype, fid) = iprot.readFieldBegin()
21148 
      if ftype == TType.STOP:
21149 
        break
21150 
      if fid == 0:
21151 
        if ftype == TType.LIST:
21152 
          self.success = []
6188 rajveer 21153 
          (_etype497, _size494) = iprot.readListBegin()
21154 
          for _i498 in xrange(_size494):
21155 
            _elem499 = Order()
21156 
            _elem499.read(iprot)
21157 
            self.success.append(_elem499)
4295 varun.gupt 21158 
          iprot.readListEnd()
21159 
        else:
21160 
          iprot.skip(ftype)
21161 
      else:
21162 
        iprot.skip(ftype)
21163 
      iprot.readFieldEnd()
21164 
    iprot.readStructEnd()
21165 
 
21166 
  def write(self, oprot):
21167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21169 
      return
21170 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21171 
    if self.success is not None:
21172 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21173 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21174 
      for iter500 in self.success:
21175 
        iter500.write(oprot)
4295 varun.gupt 21176 
      oprot.writeListEnd()
21177 
      oprot.writeFieldEnd()
21178 
    oprot.writeFieldStop()
21179 
    oprot.writeStructEnd()
21180 
 
21181 
  def validate(self):
21182 
    return
21183 
 
21184 
 
21185 
  def __repr__(self):
21186 
    L = ['%s=%r' % (key, value)
21187 
      for key, value in self.__dict__.iteritems()]
21188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21189 
 
21190 
  def __eq__(self, other):
21191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21192 
 
21193 
  def __ne__(self, other):
21194 
    return not (self == other)
21195 
 
4247 rajveer 21196 
class markOrderCancellationRequestReceived_args:
21197 
  """
21198 
  Attributes:
21199 
   - orderId
21200 
  """
21201 
 
21202 
  thrift_spec = (
21203 
    None, # 0
21204 
    (1, TType.I64, 'orderId', None, None, ), # 1
21205 
  )
21206 
 
21207 
  def __init__(self, orderId=None,):
21208 
    self.orderId = orderId
21209 
 
21210 
  def read(self, iprot):
21211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21213 
      return
21214 
    iprot.readStructBegin()
21215 
    while True:
21216 
      (fname, ftype, fid) = iprot.readFieldBegin()
21217 
      if ftype == TType.STOP:
21218 
        break
21219 
      if fid == 1:
21220 
        if ftype == TType.I64:
21221 
          self.orderId = iprot.readI64();
21222 
        else:
21223 
          iprot.skip(ftype)
21224 
      else:
21225 
        iprot.skip(ftype)
21226 
      iprot.readFieldEnd()
21227 
    iprot.readStructEnd()
21228 
 
21229 
  def write(self, oprot):
21230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21232 
      return
21233 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21234 
    if self.orderId is not None:
21235 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21236 
      oprot.writeI64(self.orderId)
21237 
      oprot.writeFieldEnd()
21238 
    oprot.writeFieldStop()
21239 
    oprot.writeStructEnd()
21240 
 
21241 
  def validate(self):
21242 
    return
21243 
 
21244 
 
21245 
  def __repr__(self):
21246 
    L = ['%s=%r' % (key, value)
21247 
      for key, value in self.__dict__.iteritems()]
21248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21249 
 
21250 
  def __eq__(self, other):
21251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21252 
 
21253 
  def __ne__(self, other):
21254 
    return not (self == other)
21255 
 
21256 
class markOrderCancellationRequestReceived_result:
21257 
  """
21258 
  Attributes:
21259 
   - ex
21260 
  """
21261 
 
21262 
  thrift_spec = (
21263 
    None, # 0
21264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21265 
  )
21266 
 
21267 
  def __init__(self, ex=None,):
21268 
    self.ex = ex
21269 
 
21270 
  def read(self, iprot):
21271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21273 
      return
21274 
    iprot.readStructBegin()
21275 
    while True:
21276 
      (fname, ftype, fid) = iprot.readFieldBegin()
21277 
      if ftype == TType.STOP:
21278 
        break
21279 
      if fid == 1:
21280 
        if ftype == TType.STRUCT:
21281 
          self.ex = TransactionServiceException()
21282 
          self.ex.read(iprot)
21283 
        else:
21284 
          iprot.skip(ftype)
21285 
      else:
21286 
        iprot.skip(ftype)
21287 
      iprot.readFieldEnd()
21288 
    iprot.readStructEnd()
21289 
 
21290 
  def write(self, oprot):
21291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21293 
      return
21294 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21295 
    if self.ex is not None:
21296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21297 
      self.ex.write(oprot)
21298 
      oprot.writeFieldEnd()
21299 
    oprot.writeFieldStop()
21300 
    oprot.writeStructEnd()
21301 
 
21302 
  def validate(self):
21303 
    return
21304 
 
21305 
 
21306 
  def __repr__(self):
21307 
    L = ['%s=%r' % (key, value)
21308 
      for key, value in self.__dict__.iteritems()]
21309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21310 
 
21311 
  def __eq__(self, other):
21312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21313 
 
21314 
  def __ne__(self, other):
21315 
    return not (self == other)
21316 
 
21317 
class markOrderCancellationRequestConfirmed_args:
21318 
  """
21319 
  Attributes:
21320 
   - orderId
21321 
  """
21322 
 
21323 
  thrift_spec = (
21324 
    None, # 0
21325 
    (1, TType.I64, 'orderId', None, None, ), # 1
21326 
  )
21327 
 
21328 
  def __init__(self, orderId=None,):
21329 
    self.orderId = orderId
21330 
 
21331 
  def read(self, iprot):
21332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21334 
      return
21335 
    iprot.readStructBegin()
21336 
    while True:
21337 
      (fname, ftype, fid) = iprot.readFieldBegin()
21338 
      if ftype == TType.STOP:
21339 
        break
21340 
      if fid == 1:
21341 
        if ftype == TType.I64:
21342 
          self.orderId = iprot.readI64();
21343 
        else:
21344 
          iprot.skip(ftype)
21345 
      else:
21346 
        iprot.skip(ftype)
21347 
      iprot.readFieldEnd()
21348 
    iprot.readStructEnd()
21349 
 
21350 
  def write(self, oprot):
21351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21353 
      return
21354 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21355 
    if self.orderId is not None:
21356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21357 
      oprot.writeI64(self.orderId)
21358 
      oprot.writeFieldEnd()
21359 
    oprot.writeFieldStop()
21360 
    oprot.writeStructEnd()
21361 
 
21362 
  def validate(self):
21363 
    return
21364 
 
21365 
 
21366 
  def __repr__(self):
21367 
    L = ['%s=%r' % (key, value)
21368 
      for key, value in self.__dict__.iteritems()]
21369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21370 
 
21371 
  def __eq__(self, other):
21372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21373 
 
21374 
  def __ne__(self, other):
21375 
    return not (self == other)
21376 
 
21377 
class markOrderCancellationRequestConfirmed_result:
21378 
  """
21379 
  Attributes:
21380 
   - ex
21381 
  """
21382 
 
21383 
  thrift_spec = (
21384 
    None, # 0
21385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21386 
  )
21387 
 
21388 
  def __init__(self, ex=None,):
21389 
    self.ex = ex
21390 
 
21391 
  def read(self, iprot):
21392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21394 
      return
21395 
    iprot.readStructBegin()
21396 
    while True:
21397 
      (fname, ftype, fid) = iprot.readFieldBegin()
21398 
      if ftype == TType.STOP:
21399 
        break
21400 
      if fid == 1:
21401 
        if ftype == TType.STRUCT:
21402 
          self.ex = TransactionServiceException()
21403 
          self.ex.read(iprot)
21404 
        else:
21405 
          iprot.skip(ftype)
21406 
      else:
21407 
        iprot.skip(ftype)
21408 
      iprot.readFieldEnd()
21409 
    iprot.readStructEnd()
21410 
 
21411 
  def write(self, oprot):
21412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21414 
      return
21415 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21416 
    if self.ex is not None:
21417 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21418 
      self.ex.write(oprot)
21419 
      oprot.writeFieldEnd()
21420 
    oprot.writeFieldStop()
21421 
    oprot.writeStructEnd()
21422 
 
21423 
  def validate(self):
21424 
    return
21425 
 
21426 
 
21427 
  def __repr__(self):
21428 
    L = ['%s=%r' % (key, value)
21429 
      for key, value in self.__dict__.iteritems()]
21430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21431 
 
21432 
  def __eq__(self, other):
21433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21434 
 
21435 
  def __ne__(self, other):
21436 
    return not (self == other)
21437 
 
21438 
class markOrderCancellationRequestDenied_args:
21439 
  """
21440 
  Attributes:
21441 
   - orderId
21442 
  """
21443 
 
21444 
  thrift_spec = (
21445 
    None, # 0
21446 
    (1, TType.I64, 'orderId', None, None, ), # 1
21447 
  )
21448 
 
21449 
  def __init__(self, orderId=None,):
21450 
    self.orderId = orderId
21451 
 
21452 
  def read(self, iprot):
21453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21455 
      return
21456 
    iprot.readStructBegin()
21457 
    while True:
21458 
      (fname, ftype, fid) = iprot.readFieldBegin()
21459 
      if ftype == TType.STOP:
21460 
        break
21461 
      if fid == 1:
21462 
        if ftype == TType.I64:
21463 
          self.orderId = iprot.readI64();
21464 
        else:
21465 
          iprot.skip(ftype)
21466 
      else:
21467 
        iprot.skip(ftype)
21468 
      iprot.readFieldEnd()
21469 
    iprot.readStructEnd()
21470 
 
21471 
  def write(self, oprot):
21472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21474 
      return
21475 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21476 
    if self.orderId is not None:
21477 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21478 
      oprot.writeI64(self.orderId)
21479 
      oprot.writeFieldEnd()
21480 
    oprot.writeFieldStop()
21481 
    oprot.writeStructEnd()
21482 
 
21483 
  def validate(self):
21484 
    return
21485 
 
21486 
 
21487 
  def __repr__(self):
21488 
    L = ['%s=%r' % (key, value)
21489 
      for key, value in self.__dict__.iteritems()]
21490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21491 
 
21492 
  def __eq__(self, other):
21493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21494 
 
21495 
  def __ne__(self, other):
21496 
    return not (self == other)
21497 
 
21498 
class markOrderCancellationRequestDenied_result:
21499 
  """
21500 
  Attributes:
21501 
   - ex
21502 
  """
21503 
 
21504 
  thrift_spec = (
21505 
    None, # 0
21506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21507 
  )
21508 
 
21509 
  def __init__(self, ex=None,):
21510 
    self.ex = ex
21511 
 
21512 
  def read(self, iprot):
21513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21515 
      return
21516 
    iprot.readStructBegin()
21517 
    while True:
21518 
      (fname, ftype, fid) = iprot.readFieldBegin()
21519 
      if ftype == TType.STOP:
21520 
        break
21521 
      if fid == 1:
21522 
        if ftype == TType.STRUCT:
21523 
          self.ex = TransactionServiceException()
21524 
          self.ex.read(iprot)
21525 
        else:
21526 
          iprot.skip(ftype)
21527 
      else:
21528 
        iprot.skip(ftype)
21529 
      iprot.readFieldEnd()
21530 
    iprot.readStructEnd()
21531 
 
21532 
  def write(self, oprot):
21533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21535 
      return
21536 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21537 
    if self.ex is not None:
21538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21539 
      self.ex.write(oprot)
21540 
      oprot.writeFieldEnd()
21541 
    oprot.writeFieldStop()
21542 
    oprot.writeStructEnd()
21543 
 
21544 
  def validate(self):
21545 
    return
21546 
 
21547 
 
21548 
  def __repr__(self):
21549 
    L = ['%s=%r' % (key, value)
21550 
      for key, value in self.__dict__.iteritems()]
21551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21552 
 
21553 
  def __eq__(self, other):
21554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21555 
 
21556 
  def __ne__(self, other):
21557 
    return not (self == other)
21558 
 
4258 rajveer 21559 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21560 
  """
21561 
  Attributes:
4258 rajveer 21562 
   - transactionId
4247 rajveer 21563 
  """
21564 
 
21565 
  thrift_spec = (
21566 
    None, # 0
4258 rajveer 21567 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21568 
  )
21569 
 
4258 rajveer 21570 
  def __init__(self, transactionId=None,):
21571 
    self.transactionId = transactionId
4247 rajveer 21572 
 
21573 
  def read(self, iprot):
21574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21576 
      return
21577 
    iprot.readStructBegin()
21578 
    while True:
21579 
      (fname, ftype, fid) = iprot.readFieldBegin()
21580 
      if ftype == TType.STOP:
21581 
        break
21582 
      if fid == 1:
21583 
        if ftype == TType.I64:
4258 rajveer 21584 
          self.transactionId = iprot.readI64();
4247 rajveer 21585 
        else:
21586 
          iprot.skip(ftype)
21587 
      else:
21588 
        iprot.skip(ftype)
21589 
      iprot.readFieldEnd()
21590 
    iprot.readStructEnd()
21591 
 
21592 
  def write(self, oprot):
21593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21595 
      return
4258 rajveer 21596 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21597 
    if self.transactionId is not None:
21598 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21599 
      oprot.writeI64(self.transactionId)
4247 rajveer 21600 
      oprot.writeFieldEnd()
21601 
    oprot.writeFieldStop()
21602 
    oprot.writeStructEnd()
21603 
 
21604 
  def validate(self):
21605 
    return
21606 
 
21607 
 
21608 
  def __repr__(self):
21609 
    L = ['%s=%r' % (key, value)
21610 
      for key, value in self.__dict__.iteritems()]
21611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21612 
 
21613 
  def __eq__(self, other):
21614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21615 
 
21616 
  def __ne__(self, other):
21617 
    return not (self == other)
21618 
 
4258 rajveer 21619 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21620 
  """
21621 
  Attributes:
21622 
   - ex
21623 
  """
21624 
 
21625 
  thrift_spec = (
21626 
    None, # 0
21627 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21628 
  )
21629 
 
21630 
  def __init__(self, ex=None,):
21631 
    self.ex = ex
21632 
 
21633 
  def read(self, iprot):
21634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21636 
      return
21637 
    iprot.readStructBegin()
21638 
    while True:
21639 
      (fname, ftype, fid) = iprot.readFieldBegin()
21640 
      if ftype == TType.STOP:
21641 
        break
21642 
      if fid == 1:
21643 
        if ftype == TType.STRUCT:
21644 
          self.ex = TransactionServiceException()
21645 
          self.ex.read(iprot)
21646 
        else:
21647 
          iprot.skip(ftype)
21648 
      else:
21649 
        iprot.skip(ftype)
21650 
      iprot.readFieldEnd()
21651 
    iprot.readStructEnd()
21652 
 
21653 
  def write(self, oprot):
21654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21656 
      return
4258 rajveer 21657 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21658 
    if self.ex is not None:
21659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21660 
      self.ex.write(oprot)
21661 
      oprot.writeFieldEnd()
21662 
    oprot.writeFieldStop()
21663 
    oprot.writeStructEnd()
21664 
 
21665 
  def validate(self):
21666 
    return
21667 
 
21668 
 
21669 
  def __repr__(self):
21670 
    L = ['%s=%r' % (key, value)
21671 
      for key, value in self.__dict__.iteritems()]
21672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21673 
 
21674 
  def __eq__(self, other):
21675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21676 
 
21677 
  def __ne__(self, other):
21678 
    return not (self == other)
4259 anupam.sin 21679 
 
21680 
class refundTransaction_args:
21681 
  """
21682 
  Attributes:
21683 
   - transactionId
21684 
   - refundedBy
21685 
   - reason
21686 
  """
21687 
 
21688 
  thrift_spec = (
21689 
    None, # 0
21690 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21691 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21692 
    (3, TType.STRING, 'reason', None, None, ), # 3
21693 
  )
21694 
 
21695 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21696 
    self.transactionId = transactionId
21697 
    self.refundedBy = refundedBy
21698 
    self.reason = reason
21699 
 
21700 
  def read(self, iprot):
21701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21703 
      return
21704 
    iprot.readStructBegin()
21705 
    while True:
21706 
      (fname, ftype, fid) = iprot.readFieldBegin()
21707 
      if ftype == TType.STOP:
21708 
        break
21709 
      if fid == 1:
21710 
        if ftype == TType.I64:
21711 
          self.transactionId = iprot.readI64();
21712 
        else:
21713 
          iprot.skip(ftype)
21714 
      elif fid == 2:
21715 
        if ftype == TType.STRING:
21716 
          self.refundedBy = iprot.readString();
21717 
        else:
21718 
          iprot.skip(ftype)
21719 
      elif fid == 3:
21720 
        if ftype == TType.STRING:
21721 
          self.reason = iprot.readString();
21722 
        else:
21723 
          iprot.skip(ftype)
21724 
      else:
21725 
        iprot.skip(ftype)
21726 
      iprot.readFieldEnd()
21727 
    iprot.readStructEnd()
21728 
 
21729 
  def write(self, oprot):
21730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21732 
      return
21733 
    oprot.writeStructBegin('refundTransaction_args')
21734 
    if self.transactionId is not None:
21735 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21736 
      oprot.writeI64(self.transactionId)
21737 
      oprot.writeFieldEnd()
21738 
    if self.refundedBy is not None:
21739 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21740 
      oprot.writeString(self.refundedBy)
21741 
      oprot.writeFieldEnd()
21742 
    if self.reason is not None:
21743 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21744 
      oprot.writeString(self.reason)
21745 
      oprot.writeFieldEnd()
21746 
    oprot.writeFieldStop()
21747 
    oprot.writeStructEnd()
21748 
 
21749 
  def validate(self):
21750 
    return
21751 
 
21752 
 
21753 
  def __repr__(self):
21754 
    L = ['%s=%r' % (key, value)
21755 
      for key, value in self.__dict__.iteritems()]
21756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21757 
 
21758 
  def __eq__(self, other):
21759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21760 
 
21761 
  def __ne__(self, other):
21762 
    return not (self == other)
21763 
 
21764 
class refundTransaction_result:
21765 
  """
21766 
  Attributes:
21767 
   - ex
21768 
  """
21769 
 
21770 
  thrift_spec = (
21771 
    None, # 0
21772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21773 
  )
21774 
 
21775 
  def __init__(self, ex=None,):
21776 
    self.ex = ex
21777 
 
21778 
  def read(self, iprot):
21779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21781 
      return
21782 
    iprot.readStructBegin()
21783 
    while True:
21784 
      (fname, ftype, fid) = iprot.readFieldBegin()
21785 
      if ftype == TType.STOP:
21786 
        break
21787 
      if fid == 1:
21788 
        if ftype == TType.STRUCT:
21789 
          self.ex = TransactionServiceException()
21790 
          self.ex.read(iprot)
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      else:
21794 
        iprot.skip(ftype)
21795 
      iprot.readFieldEnd()
21796 
    iprot.readStructEnd()
21797 
 
21798 
  def write(self, oprot):
21799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21801 
      return
21802 
    oprot.writeStructBegin('refundTransaction_result')
21803 
    if self.ex is not None:
21804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21805 
      self.ex.write(oprot)
21806 
      oprot.writeFieldEnd()
21807 
    oprot.writeFieldStop()
21808 
    oprot.writeStructEnd()
21809 
 
21810 
  def validate(self):
21811 
    return
21812 
 
21813 
 
21814 
  def __repr__(self):
21815 
    L = ['%s=%r' % (key, value)
21816 
      for key, value in self.__dict__.iteritems()]
21817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21818 
 
21819 
  def __eq__(self, other):
21820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21821 
 
21822 
  def __ne__(self, other):
21823 
    return not (self == other)
4285 rajveer 21824 
 
4324 mandeep.dh 21825 
class updateShipmentAddress_args:
21826 
  """
21827 
  Attributes:
21828 
   - orderId
21829 
   - addressId
21830 
  """
21831 
 
21832 
  thrift_spec = (
21833 
    None, # 0
21834 
    (1, TType.I64, 'orderId', None, None, ), # 1
21835 
    (2, TType.I64, 'addressId', None, None, ), # 2
21836 
  )
21837 
 
21838 
  def __init__(self, orderId=None, addressId=None,):
21839 
    self.orderId = orderId
21840 
    self.addressId = addressId
21841 
 
21842 
  def read(self, iprot):
21843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21845 
      return
21846 
    iprot.readStructBegin()
21847 
    while True:
21848 
      (fname, ftype, fid) = iprot.readFieldBegin()
21849 
      if ftype == TType.STOP:
21850 
        break
21851 
      if fid == 1:
21852 
        if ftype == TType.I64:
21853 
          self.orderId = iprot.readI64();
21854 
        else:
21855 
          iprot.skip(ftype)
21856 
      elif fid == 2:
21857 
        if ftype == TType.I64:
21858 
          self.addressId = iprot.readI64();
21859 
        else:
21860 
          iprot.skip(ftype)
21861 
      else:
21862 
        iprot.skip(ftype)
21863 
      iprot.readFieldEnd()
21864 
    iprot.readStructEnd()
21865 
 
21866 
  def write(self, oprot):
21867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21869 
      return
21870 
    oprot.writeStructBegin('updateShipmentAddress_args')
21871 
    if self.orderId is not None:
21872 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21873 
      oprot.writeI64(self.orderId)
21874 
      oprot.writeFieldEnd()
21875 
    if self.addressId is not None:
21876 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21877 
      oprot.writeI64(self.addressId)
21878 
      oprot.writeFieldEnd()
21879 
    oprot.writeFieldStop()
21880 
    oprot.writeStructEnd()
21881 
 
21882 
  def validate(self):
21883 
    return
21884 
 
21885 
 
21886 
  def __repr__(self):
21887 
    L = ['%s=%r' % (key, value)
21888 
      for key, value in self.__dict__.iteritems()]
21889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21890 
 
21891 
  def __eq__(self, other):
21892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21893 
 
21894 
  def __ne__(self, other):
21895 
    return not (self == other)
21896 
 
21897 
class updateShipmentAddress_result:
21898 
  """
21899 
  Attributes:
21900 
   - ex
21901 
  """
21902 
 
21903 
  thrift_spec = (
21904 
    None, # 0
21905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21906 
  )
21907 
 
21908 
  def __init__(self, ex=None,):
21909 
    self.ex = ex
21910 
 
21911 
  def read(self, iprot):
21912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21914 
      return
21915 
    iprot.readStructBegin()
21916 
    while True:
21917 
      (fname, ftype, fid) = iprot.readFieldBegin()
21918 
      if ftype == TType.STOP:
21919 
        break
21920 
      if fid == 1:
21921 
        if ftype == TType.STRUCT:
21922 
          self.ex = TransactionServiceException()
21923 
          self.ex.read(iprot)
21924 
        else:
21925 
          iprot.skip(ftype)
21926 
      else:
21927 
        iprot.skip(ftype)
21928 
      iprot.readFieldEnd()
21929 
    iprot.readStructEnd()
21930 
 
21931 
  def write(self, oprot):
21932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21934 
      return
21935 
    oprot.writeStructBegin('updateShipmentAddress_result')
21936 
    if self.ex is not None:
21937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21938 
      self.ex.write(oprot)
21939 
      oprot.writeFieldEnd()
21940 
    oprot.writeFieldStop()
21941 
    oprot.writeStructEnd()
21942 
 
21943 
  def validate(self):
21944 
    return
21945 
 
21946 
 
21947 
  def __repr__(self):
21948 
    L = ['%s=%r' % (key, value)
21949 
      for key, value in self.__dict__.iteritems()]
21950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21951 
 
21952 
  def __eq__(self, other):
21953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21954 
 
21955 
  def __ne__(self, other):
21956 
    return not (self == other)
21957 
 
4285 rajveer 21958 
class acceptOrdersForItemId_args:
21959 
  """
21960 
  Attributes:
21961 
   - itemId
21962 
   - inventory
21963 
  """
21964 
 
21965 
  thrift_spec = (
21966 
    None, # 0
21967 
    (1, TType.I64, 'itemId', None, None, ), # 1
21968 
    (2, TType.I64, 'inventory', None, None, ), # 2
21969 
  )
21970 
 
21971 
  def __init__(self, itemId=None, inventory=None,):
21972 
    self.itemId = itemId
21973 
    self.inventory = inventory
21974 
 
21975 
  def read(self, iprot):
21976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21978 
      return
21979 
    iprot.readStructBegin()
21980 
    while True:
21981 
      (fname, ftype, fid) = iprot.readFieldBegin()
21982 
      if ftype == TType.STOP:
21983 
        break
21984 
      if fid == 1:
21985 
        if ftype == TType.I64:
21986 
          self.itemId = iprot.readI64();
21987 
        else:
21988 
          iprot.skip(ftype)
21989 
      elif fid == 2:
21990 
        if ftype == TType.I64:
21991 
          self.inventory = iprot.readI64();
21992 
        else:
21993 
          iprot.skip(ftype)
21994 
      else:
21995 
        iprot.skip(ftype)
21996 
      iprot.readFieldEnd()
21997 
    iprot.readStructEnd()
21998 
 
21999 
  def write(self, oprot):
22000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22002 
      return
22003 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22004 
    if self.itemId is not None:
22005 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22006 
      oprot.writeI64(self.itemId)
22007 
      oprot.writeFieldEnd()
22008 
    if self.inventory is not None:
22009 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22010 
      oprot.writeI64(self.inventory)
22011 
      oprot.writeFieldEnd()
22012 
    oprot.writeFieldStop()
22013 
    oprot.writeStructEnd()
22014 
 
22015 
  def validate(self):
22016 
    return
22017 
 
22018 
 
22019 
  def __repr__(self):
22020 
    L = ['%s=%r' % (key, value)
22021 
      for key, value in self.__dict__.iteritems()]
22022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22023 
 
22024 
  def __eq__(self, other):
22025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22026 
 
22027 
  def __ne__(self, other):
22028 
    return not (self == other)
22029 
 
22030 
class acceptOrdersForItemId_result:
22031 
  """
22032 
  Attributes:
22033 
   - success
22034 
   - ex
22035 
  """
22036 
 
22037 
  thrift_spec = (
22038 
    (0, TType.BOOL, 'success', None, None, ), # 0
22039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22040 
  )
22041 
 
22042 
  def __init__(self, success=None, ex=None,):
22043 
    self.success = success
22044 
    self.ex = ex
22045 
 
22046 
  def read(self, iprot):
22047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22049 
      return
22050 
    iprot.readStructBegin()
22051 
    while True:
22052 
      (fname, ftype, fid) = iprot.readFieldBegin()
22053 
      if ftype == TType.STOP:
22054 
        break
22055 
      if fid == 0:
22056 
        if ftype == TType.BOOL:
22057 
          self.success = iprot.readBool();
22058 
        else:
22059 
          iprot.skip(ftype)
22060 
      elif fid == 1:
22061 
        if ftype == TType.STRUCT:
22062 
          self.ex = TransactionServiceException()
22063 
          self.ex.read(iprot)
22064 
        else:
22065 
          iprot.skip(ftype)
22066 
      else:
22067 
        iprot.skip(ftype)
22068 
      iprot.readFieldEnd()
22069 
    iprot.readStructEnd()
22070 
 
22071 
  def write(self, oprot):
22072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22074 
      return
22075 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22076 
    if self.success is not None:
22077 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22078 
      oprot.writeBool(self.success)
22079 
      oprot.writeFieldEnd()
22080 
    if self.ex is not None:
22081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22082 
      self.ex.write(oprot)
22083 
      oprot.writeFieldEnd()
22084 
    oprot.writeFieldStop()
22085 
    oprot.writeStructEnd()
22086 
 
22087 
  def validate(self):
22088 
    return
22089 
 
22090 
 
22091 
  def __repr__(self):
22092 
    L = ['%s=%r' % (key, value)
22093 
      for key, value in self.__dict__.iteritems()]
22094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22095 
 
22096 
  def __eq__(self, other):
22097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22098 
 
22099 
  def __ne__(self, other):
22100 
    return not (self == other)
4303 rajveer 22101 
 
22102 
class markOrdersAsPORaised_args:
22103 
  """
22104 
  Attributes:
22105 
   - vendorId
22106 
   - itemId
22107 
   - quantity
22108 
   - estimate
4369 rajveer 22109 
   - isReminder
4303 rajveer 22110 
  """
22111 
 
22112 
  thrift_spec = (
22113 
    None, # 0
22114 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22115 
    (2, TType.I64, 'itemId', None, None, ), # 2
22116 
    (3, TType.I64, 'quantity', None, None, ), # 3
22117 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22118 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22119 
  )
22120 
 
4369 rajveer 22121 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22122 
    self.vendorId = vendorId
22123 
    self.itemId = itemId
22124 
    self.quantity = quantity
22125 
    self.estimate = estimate
4369 rajveer 22126 
    self.isReminder = isReminder
4303 rajveer 22127 
 
22128 
  def read(self, iprot):
22129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22131 
      return
22132 
    iprot.readStructBegin()
22133 
    while True:
22134 
      (fname, ftype, fid) = iprot.readFieldBegin()
22135 
      if ftype == TType.STOP:
22136 
        break
22137 
      if fid == 1:
22138 
        if ftype == TType.I64:
22139 
          self.vendorId = iprot.readI64();
22140 
        else:
22141 
          iprot.skip(ftype)
22142 
      elif fid == 2:
22143 
        if ftype == TType.I64:
22144 
          self.itemId = iprot.readI64();
22145 
        else:
22146 
          iprot.skip(ftype)
22147 
      elif fid == 3:
22148 
        if ftype == TType.I64:
22149 
          self.quantity = iprot.readI64();
22150 
        else:
22151 
          iprot.skip(ftype)
22152 
      elif fid == 4:
22153 
        if ftype == TType.I64:
22154 
          self.estimate = iprot.readI64();
22155 
        else:
22156 
          iprot.skip(ftype)
4369 rajveer 22157 
      elif fid == 5:
22158 
        if ftype == TType.BOOL:
22159 
          self.isReminder = iprot.readBool();
22160 
        else:
22161 
          iprot.skip(ftype)
4303 rajveer 22162 
      else:
22163 
        iprot.skip(ftype)
22164 
      iprot.readFieldEnd()
22165 
    iprot.readStructEnd()
22166 
 
22167 
  def write(self, oprot):
22168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22170 
      return
22171 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22172 
    if self.vendorId is not None:
22173 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22174 
      oprot.writeI64(self.vendorId)
22175 
      oprot.writeFieldEnd()
22176 
    if self.itemId is not None:
22177 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22178 
      oprot.writeI64(self.itemId)
22179 
      oprot.writeFieldEnd()
22180 
    if self.quantity is not None:
22181 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22182 
      oprot.writeI64(self.quantity)
22183 
      oprot.writeFieldEnd()
22184 
    if self.estimate is not None:
22185 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22186 
      oprot.writeI64(self.estimate)
22187 
      oprot.writeFieldEnd()
4369 rajveer 22188 
    if self.isReminder is not None:
22189 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22190 
      oprot.writeBool(self.isReminder)
22191 
      oprot.writeFieldEnd()
4303 rajveer 22192 
    oprot.writeFieldStop()
22193 
    oprot.writeStructEnd()
22194 
 
22195 
  def validate(self):
22196 
    return
22197 
 
22198 
 
22199 
  def __repr__(self):
22200 
    L = ['%s=%r' % (key, value)
22201 
      for key, value in self.__dict__.iteritems()]
22202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22203 
 
22204 
  def __eq__(self, other):
22205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22206 
 
22207 
  def __ne__(self, other):
22208 
    return not (self == other)
22209 
 
22210 
class markOrdersAsPORaised_result:
22211 
  """
22212 
  Attributes:
22213 
   - ex
22214 
  """
22215 
 
22216 
  thrift_spec = (
22217 
    None, # 0
22218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22219 
  )
22220 
 
22221 
  def __init__(self, ex=None,):
22222 
    self.ex = ex
22223 
 
22224 
  def read(self, iprot):
22225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22227 
      return
22228 
    iprot.readStructBegin()
22229 
    while True:
22230 
      (fname, ftype, fid) = iprot.readFieldBegin()
22231 
      if ftype == TType.STOP:
22232 
        break
22233 
      if fid == 1:
22234 
        if ftype == TType.STRUCT:
22235 
          self.ex = TransactionServiceException()
22236 
          self.ex.read(iprot)
22237 
        else:
22238 
          iprot.skip(ftype)
22239 
      else:
22240 
        iprot.skip(ftype)
22241 
      iprot.readFieldEnd()
22242 
    iprot.readStructEnd()
22243 
 
22244 
  def write(self, oprot):
22245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22247 
      return
22248 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22249 
    if self.ex is not None:
22250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22251 
      self.ex.write(oprot)
22252 
      oprot.writeFieldEnd()
22253 
    oprot.writeFieldStop()
22254 
    oprot.writeStructEnd()
22255 
 
22256 
  def validate(self):
22257 
    return
22258 
 
22259 
 
22260 
  def __repr__(self):
22261 
    L = ['%s=%r' % (key, value)
22262 
      for key, value in self.__dict__.iteritems()]
22263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22264 
 
22265 
  def __eq__(self, other):
22266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22267 
 
22268 
  def __ne__(self, other):
22269 
    return not (self == other)
22270 
 
22271 
class markOrdersAsReversalInitiated_args:
22272 
  """
22273 
  Attributes:
22274 
   - vendorId
22275 
   - itemId
22276 
   - quantity
22277 
   - estimate
4369 rajveer 22278 
   - isReminder
4303 rajveer 22279 
  """
22280 
 
22281 
  thrift_spec = (
22282 
    None, # 0
22283 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22284 
    (2, TType.I64, 'itemId', None, None, ), # 2
22285 
    (3, TType.I64, 'quantity', None, None, ), # 3
22286 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22287 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22288 
  )
22289 
 
4369 rajveer 22290 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22291 
    self.vendorId = vendorId
22292 
    self.itemId = itemId
22293 
    self.quantity = quantity
22294 
    self.estimate = estimate
4369 rajveer 22295 
    self.isReminder = isReminder
4303 rajveer 22296 
 
22297 
  def read(self, iprot):
22298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22300 
      return
22301 
    iprot.readStructBegin()
22302 
    while True:
22303 
      (fname, ftype, fid) = iprot.readFieldBegin()
22304 
      if ftype == TType.STOP:
22305 
        break
22306 
      if fid == 1:
22307 
        if ftype == TType.I64:
22308 
          self.vendorId = iprot.readI64();
22309 
        else:
22310 
          iprot.skip(ftype)
22311 
      elif fid == 2:
22312 
        if ftype == TType.I64:
22313 
          self.itemId = iprot.readI64();
22314 
        else:
22315 
          iprot.skip(ftype)
22316 
      elif fid == 3:
22317 
        if ftype == TType.I64:
22318 
          self.quantity = iprot.readI64();
22319 
        else:
22320 
          iprot.skip(ftype)
22321 
      elif fid == 4:
22322 
        if ftype == TType.I64:
22323 
          self.estimate = iprot.readI64();
22324 
        else:
22325 
          iprot.skip(ftype)
4369 rajveer 22326 
      elif fid == 5:
22327 
        if ftype == TType.BOOL:
22328 
          self.isReminder = iprot.readBool();
22329 
        else:
22330 
          iprot.skip(ftype)
4303 rajveer 22331 
      else:
22332 
        iprot.skip(ftype)
22333 
      iprot.readFieldEnd()
22334 
    iprot.readStructEnd()
22335 
 
22336 
  def write(self, oprot):
22337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22339 
      return
22340 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22341 
    if self.vendorId is not None:
22342 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22343 
      oprot.writeI64(self.vendorId)
22344 
      oprot.writeFieldEnd()
22345 
    if self.itemId is not None:
22346 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22347 
      oprot.writeI64(self.itemId)
22348 
      oprot.writeFieldEnd()
22349 
    if self.quantity is not None:
22350 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22351 
      oprot.writeI64(self.quantity)
22352 
      oprot.writeFieldEnd()
22353 
    if self.estimate is not None:
22354 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22355 
      oprot.writeI64(self.estimate)
22356 
      oprot.writeFieldEnd()
4369 rajveer 22357 
    if self.isReminder is not None:
22358 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22359 
      oprot.writeBool(self.isReminder)
22360 
      oprot.writeFieldEnd()
4303 rajveer 22361 
    oprot.writeFieldStop()
22362 
    oprot.writeStructEnd()
22363 
 
22364 
  def validate(self):
22365 
    return
22366 
 
22367 
 
22368 
  def __repr__(self):
22369 
    L = ['%s=%r' % (key, value)
22370 
      for key, value in self.__dict__.iteritems()]
22371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22372 
 
22373 
  def __eq__(self, other):
22374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22375 
 
22376 
  def __ne__(self, other):
22377 
    return not (self == other)
22378 
 
22379 
class markOrdersAsReversalInitiated_result:
22380 
  """
22381 
  Attributes:
22382 
   - ex
22383 
  """
22384 
 
22385 
  thrift_spec = (
22386 
    None, # 0
22387 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22388 
  )
22389 
 
22390 
  def __init__(self, ex=None,):
22391 
    self.ex = ex
22392 
 
22393 
  def read(self, iprot):
22394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22396 
      return
22397 
    iprot.readStructBegin()
22398 
    while True:
22399 
      (fname, ftype, fid) = iprot.readFieldBegin()
22400 
      if ftype == TType.STOP:
22401 
        break
22402 
      if fid == 1:
22403 
        if ftype == TType.STRUCT:
22404 
          self.ex = TransactionServiceException()
22405 
          self.ex.read(iprot)
22406 
        else:
22407 
          iprot.skip(ftype)
22408 
      else:
22409 
        iprot.skip(ftype)
22410 
      iprot.readFieldEnd()
22411 
    iprot.readStructEnd()
22412 
 
22413 
  def write(self, oprot):
22414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22416 
      return
22417 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22418 
    if self.ex is not None:
22419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22420 
      self.ex.write(oprot)
22421 
      oprot.writeFieldEnd()
22422 
    oprot.writeFieldStop()
22423 
    oprot.writeStructEnd()
22424 
 
22425 
  def validate(self):
22426 
    return
22427 
 
22428 
 
22429 
  def __repr__(self):
22430 
    L = ['%s=%r' % (key, value)
22431 
      for key, value in self.__dict__.iteritems()]
22432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22433 
 
22434 
  def __eq__(self, other):
22435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22436 
 
22437 
  def __ne__(self, other):
22438 
    return not (self == other)
22439 
 
22440 
class markOrdersAsNotAvailabke_args:
22441 
  """
22442 
  Attributes:
22443 
   - vendorId
22444 
   - itemId
22445 
   - quantity
22446 
   - estimate
4369 rajveer 22447 
   - isReminder
4303 rajveer 22448 
  """
22449 
 
22450 
  thrift_spec = (
22451 
    None, # 0
22452 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22453 
    (2, TType.I64, 'itemId', None, None, ), # 2
22454 
    (3, TType.I64, 'quantity', None, None, ), # 3
22455 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22456 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22457 
  )
22458 
 
4369 rajveer 22459 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22460 
    self.vendorId = vendorId
22461 
    self.itemId = itemId
22462 
    self.quantity = quantity
22463 
    self.estimate = estimate
4369 rajveer 22464 
    self.isReminder = isReminder
4303 rajveer 22465 
 
22466 
  def read(self, iprot):
22467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22469 
      return
22470 
    iprot.readStructBegin()
22471 
    while True:
22472 
      (fname, ftype, fid) = iprot.readFieldBegin()
22473 
      if ftype == TType.STOP:
22474 
        break
22475 
      if fid == 1:
22476 
        if ftype == TType.I64:
22477 
          self.vendorId = iprot.readI64();
22478 
        else:
22479 
          iprot.skip(ftype)
22480 
      elif fid == 2:
22481 
        if ftype == TType.I64:
22482 
          self.itemId = iprot.readI64();
22483 
        else:
22484 
          iprot.skip(ftype)
22485 
      elif fid == 3:
22486 
        if ftype == TType.I64:
22487 
          self.quantity = iprot.readI64();
22488 
        else:
22489 
          iprot.skip(ftype)
22490 
      elif fid == 4:
22491 
        if ftype == TType.I64:
22492 
          self.estimate = iprot.readI64();
22493 
        else:
22494 
          iprot.skip(ftype)
4369 rajveer 22495 
      elif fid == 5:
22496 
        if ftype == TType.BOOL:
22497 
          self.isReminder = iprot.readBool();
22498 
        else:
22499 
          iprot.skip(ftype)
4303 rajveer 22500 
      else:
22501 
        iprot.skip(ftype)
22502 
      iprot.readFieldEnd()
22503 
    iprot.readStructEnd()
22504 
 
22505 
  def write(self, oprot):
22506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22508 
      return
22509 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22510 
    if self.vendorId is not None:
22511 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22512 
      oprot.writeI64(self.vendorId)
22513 
      oprot.writeFieldEnd()
22514 
    if self.itemId is not None:
22515 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22516 
      oprot.writeI64(self.itemId)
22517 
      oprot.writeFieldEnd()
22518 
    if self.quantity is not None:
22519 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22520 
      oprot.writeI64(self.quantity)
22521 
      oprot.writeFieldEnd()
22522 
    if self.estimate is not None:
22523 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22524 
      oprot.writeI64(self.estimate)
22525 
      oprot.writeFieldEnd()
4369 rajveer 22526 
    if self.isReminder is not None:
22527 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22528 
      oprot.writeBool(self.isReminder)
22529 
      oprot.writeFieldEnd()
4303 rajveer 22530 
    oprot.writeFieldStop()
22531 
    oprot.writeStructEnd()
22532 
 
22533 
  def validate(self):
22534 
    return
22535 
 
22536 
 
22537 
  def __repr__(self):
22538 
    L = ['%s=%r' % (key, value)
22539 
      for key, value in self.__dict__.iteritems()]
22540 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22541 
 
22542 
  def __eq__(self, other):
22543 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22544 
 
22545 
  def __ne__(self, other):
22546 
    return not (self == other)
22547 
 
22548 
class markOrdersAsNotAvailabke_result:
22549 
  """
22550 
  Attributes:
22551 
   - ex
22552 
  """
22553 
 
22554 
  thrift_spec = (
22555 
    None, # 0
22556 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22557 
  )
22558 
 
22559 
  def __init__(self, ex=None,):
22560 
    self.ex = ex
22561 
 
22562 
  def read(self, iprot):
22563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22565 
      return
22566 
    iprot.readStructBegin()
22567 
    while True:
22568 
      (fname, ftype, fid) = iprot.readFieldBegin()
22569 
      if ftype == TType.STOP:
22570 
        break
22571 
      if fid == 1:
22572 
        if ftype == TType.STRUCT:
22573 
          self.ex = TransactionServiceException()
22574 
          self.ex.read(iprot)
22575 
        else:
22576 
          iprot.skip(ftype)
22577 
      else:
22578 
        iprot.skip(ftype)
22579 
      iprot.readFieldEnd()
22580 
    iprot.readStructEnd()
22581 
 
22582 
  def write(self, oprot):
22583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22585 
      return
22586 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22587 
    if self.ex is not None:
22588 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22589 
      self.ex.write(oprot)
22590 
      oprot.writeFieldEnd()
22591 
    oprot.writeFieldStop()
22592 
    oprot.writeStructEnd()
22593 
 
22594 
  def validate(self):
22595 
    return
22596 
 
22597 
 
22598 
  def __repr__(self):
22599 
    L = ['%s=%r' % (key, value)
22600 
      for key, value in self.__dict__.iteritems()]
22601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22602 
 
22603 
  def __eq__(self, other):
22604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22605 
 
22606 
  def __ne__(self, other):
22607 
    return not (self == other)
4369 rajveer 22608 
 
22609 
class markOrdersAsTimeout_args:
22610 
  """
22611 
  Attributes:
22612 
   - vendorId
22613 
  """
22614 
 
22615 
  thrift_spec = (
22616 
    None, # 0
22617 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22618 
  )
22619 
 
22620 
  def __init__(self, vendorId=None,):
22621 
    self.vendorId = vendorId
22622 
 
22623 
  def read(self, iprot):
22624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22626 
      return
22627 
    iprot.readStructBegin()
22628 
    while True:
22629 
      (fname, ftype, fid) = iprot.readFieldBegin()
22630 
      if ftype == TType.STOP:
22631 
        break
22632 
      if fid == 1:
22633 
        if ftype == TType.I64:
22634 
          self.vendorId = iprot.readI64();
22635 
        else:
22636 
          iprot.skip(ftype)
22637 
      else:
22638 
        iprot.skip(ftype)
22639 
      iprot.readFieldEnd()
22640 
    iprot.readStructEnd()
22641 
 
22642 
  def write(self, oprot):
22643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22645 
      return
22646 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22647 
    if self.vendorId is not None:
22648 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22649 
      oprot.writeI64(self.vendorId)
22650 
      oprot.writeFieldEnd()
22651 
    oprot.writeFieldStop()
22652 
    oprot.writeStructEnd()
22653 
 
22654 
  def validate(self):
22655 
    return
22656 
 
22657 
 
22658 
  def __repr__(self):
22659 
    L = ['%s=%r' % (key, value)
22660 
      for key, value in self.__dict__.iteritems()]
22661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22662 
 
22663 
  def __eq__(self, other):
22664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22665 
 
22666 
  def __ne__(self, other):
22667 
    return not (self == other)
22668 
 
22669 
class markOrdersAsTimeout_result:
22670 
  """
22671 
  Attributes:
22672 
   - success
22673 
   - ex
22674 
  """
22675 
 
22676 
  thrift_spec = (
22677 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22678 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22679 
  )
22680 
 
22681 
  def __init__(self, success=None, ex=None,):
22682 
    self.success = success
22683 
    self.ex = ex
22684 
 
22685 
  def read(self, iprot):
22686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22688 
      return
22689 
    iprot.readStructBegin()
22690 
    while True:
22691 
      (fname, ftype, fid) = iprot.readFieldBegin()
22692 
      if ftype == TType.STOP:
22693 
        break
22694 
      if fid == 0:
22695 
        if ftype == TType.MAP:
22696 
          self.success = {}
6188 rajveer 22697 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22698 
          for _i505 in xrange(_size501):
22699 
            _key506 = iprot.readI32();
22700 
            _val507 = TimeoutSummary()
22701 
            _val507.read(iprot)
22702 
            self.success[_key506] = _val507
4369 rajveer 22703 
          iprot.readMapEnd()
22704 
        else:
22705 
          iprot.skip(ftype)
22706 
      elif fid == 1:
22707 
        if ftype == TType.STRUCT:
22708 
          self.ex = TransactionServiceException()
22709 
          self.ex.read(iprot)
22710 
        else:
22711 
          iprot.skip(ftype)
22712 
      else:
22713 
        iprot.skip(ftype)
22714 
      iprot.readFieldEnd()
22715 
    iprot.readStructEnd()
22716 
 
22717 
  def write(self, oprot):
22718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22720 
      return
22721 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22722 
    if self.success is not None:
22723 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22724 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22725 
      for kiter508,viter509 in self.success.items():
22726 
        oprot.writeI32(kiter508)
22727 
        viter509.write(oprot)
4369 rajveer 22728 
      oprot.writeMapEnd()
22729 
      oprot.writeFieldEnd()
22730 
    if self.ex is not None:
22731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22732 
      self.ex.write(oprot)
22733 
      oprot.writeFieldEnd()
22734 
    oprot.writeFieldStop()
22735 
    oprot.writeStructEnd()
22736 
 
22737 
  def validate(self):
22738 
    return
22739 
 
22740 
 
22741 
  def __repr__(self):
22742 
    L = ['%s=%r' % (key, value)
22743 
      for key, value in self.__dict__.iteritems()]
22744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22745 
 
22746 
  def __eq__(self, other):
22747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22748 
 
22749 
  def __ne__(self, other):
22750 
    return not (self == other)
4386 anupam.sin 22751 
 
4662 rajveer 22752 
class markOrderAsLostInTransit_args:
22753 
  """
22754 
  Attributes:
22755 
   - orderId
22756 
  """
22757 
 
22758 
  thrift_spec = (
22759 
    None, # 0
22760 
    (1, TType.I64, 'orderId', None, None, ), # 1
22761 
  )
22762 
 
22763 
  def __init__(self, orderId=None,):
22764 
    self.orderId = orderId
22765 
 
22766 
  def read(self, iprot):
22767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22769 
      return
22770 
    iprot.readStructBegin()
22771 
    while True:
22772 
      (fname, ftype, fid) = iprot.readFieldBegin()
22773 
      if ftype == TType.STOP:
22774 
        break
22775 
      if fid == 1:
22776 
        if ftype == TType.I64:
22777 
          self.orderId = iprot.readI64();
22778 
        else:
22779 
          iprot.skip(ftype)
22780 
      else:
22781 
        iprot.skip(ftype)
22782 
      iprot.readFieldEnd()
22783 
    iprot.readStructEnd()
22784 
 
22785 
  def write(self, oprot):
22786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22788 
      return
22789 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22790 
    if self.orderId is not None:
22791 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22792 
      oprot.writeI64(self.orderId)
22793 
      oprot.writeFieldEnd()
22794 
    oprot.writeFieldStop()
22795 
    oprot.writeStructEnd()
22796 
 
22797 
  def validate(self):
22798 
    return
22799 
 
22800 
 
22801 
  def __repr__(self):
22802 
    L = ['%s=%r' % (key, value)
22803 
      for key, value in self.__dict__.iteritems()]
22804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22805 
 
22806 
  def __eq__(self, other):
22807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22808 
 
22809 
  def __ne__(self, other):
22810 
    return not (self == other)
22811 
 
22812 
class markOrderAsLostInTransit_result:
22813 
  """
22814 
  Attributes:
22815 
   - success
22816 
   - ex
22817 
  """
22818 
 
22819 
  thrift_spec = (
22820 
    (0, TType.BOOL, 'success', None, None, ), # 0
22821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22822 
  )
22823 
 
22824 
  def __init__(self, success=None, ex=None,):
22825 
    self.success = success
22826 
    self.ex = ex
22827 
 
22828 
  def read(self, iprot):
22829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22831 
      return
22832 
    iprot.readStructBegin()
22833 
    while True:
22834 
      (fname, ftype, fid) = iprot.readFieldBegin()
22835 
      if ftype == TType.STOP:
22836 
        break
22837 
      if fid == 0:
22838 
        if ftype == TType.BOOL:
22839 
          self.success = iprot.readBool();
22840 
        else:
22841 
          iprot.skip(ftype)
22842 
      elif fid == 1:
22843 
        if ftype == TType.STRUCT:
22844 
          self.ex = TransactionServiceException()
22845 
          self.ex.read(iprot)
22846 
        else:
22847 
          iprot.skip(ftype)
22848 
      else:
22849 
        iprot.skip(ftype)
22850 
      iprot.readFieldEnd()
22851 
    iprot.readStructEnd()
22852 
 
22853 
  def write(self, oprot):
22854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22856 
      return
22857 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22858 
    if self.success is not None:
22859 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22860 
      oprot.writeBool(self.success)
22861 
      oprot.writeFieldEnd()
22862 
    if self.ex is not None:
22863 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22864 
      self.ex.write(oprot)
22865 
      oprot.writeFieldEnd()
22866 
    oprot.writeFieldStop()
22867 
    oprot.writeStructEnd()
22868 
 
22869 
  def validate(self):
22870 
    return
22871 
 
22872 
 
22873 
  def __repr__(self):
22874 
    L = ['%s=%r' % (key, value)
22875 
      for key, value in self.__dict__.iteritems()]
22876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22877 
 
22878 
  def __eq__(self, other):
22879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22880 
 
22881 
  def __ne__(self, other):
22882 
    return not (self == other)
22883 
 
4386 anupam.sin 22884 
class getOrderForAwb_args:
22885 
  """
22886 
  Attributes:
22887 
   - awb
22888 
  """
22889 
 
22890 
  thrift_spec = (
22891 
    None, # 0
22892 
    (1, TType.STRING, 'awb', None, None, ), # 1
22893 
  )
22894 
 
22895 
  def __init__(self, awb=None,):
22896 
    self.awb = awb
22897 
 
22898 
  def read(self, iprot):
22899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22901 
      return
22902 
    iprot.readStructBegin()
22903 
    while True:
22904 
      (fname, ftype, fid) = iprot.readFieldBegin()
22905 
      if ftype == TType.STOP:
22906 
        break
22907 
      if fid == 1:
22908 
        if ftype == TType.STRING:
22909 
          self.awb = iprot.readString();
22910 
        else:
22911 
          iprot.skip(ftype)
22912 
      else:
22913 
        iprot.skip(ftype)
22914 
      iprot.readFieldEnd()
22915 
    iprot.readStructEnd()
22916 
 
22917 
  def write(self, oprot):
22918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22920 
      return
22921 
    oprot.writeStructBegin('getOrderForAwb_args')
22922 
    if self.awb is not None:
22923 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22924 
      oprot.writeString(self.awb)
22925 
      oprot.writeFieldEnd()
22926 
    oprot.writeFieldStop()
22927 
    oprot.writeStructEnd()
22928 
 
22929 
  def validate(self):
22930 
    return
22931 
 
22932 
 
22933 
  def __repr__(self):
22934 
    L = ['%s=%r' % (key, value)
22935 
      for key, value in self.__dict__.iteritems()]
22936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22937 
 
22938 
  def __eq__(self, other):
22939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22940 
 
22941 
  def __ne__(self, other):
22942 
    return not (self == other)
22943 
 
22944 
class getOrderForAwb_result:
22945 
  """
22946 
  Attributes:
22947 
   - success
22948 
   - ex
22949 
  """
22950 
 
22951 
  thrift_spec = (
22952 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22953 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22954 
  )
22955 
 
22956 
  def __init__(self, success=None, ex=None,):
22957 
    self.success = success
22958 
    self.ex = ex
22959 
 
22960 
  def read(self, iprot):
22961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22963 
      return
22964 
    iprot.readStructBegin()
22965 
    while True:
22966 
      (fname, ftype, fid) = iprot.readFieldBegin()
22967 
      if ftype == TType.STOP:
22968 
        break
22969 
      if fid == 0:
22970 
        if ftype == TType.STRUCT:
22971 
          self.success = Order()
22972 
          self.success.read(iprot)
22973 
        else:
22974 
          iprot.skip(ftype)
22975 
      elif fid == 1:
22976 
        if ftype == TType.STRUCT:
22977 
          self.ex = TransactionServiceException()
22978 
          self.ex.read(iprot)
22979 
        else:
22980 
          iprot.skip(ftype)
22981 
      else:
22982 
        iprot.skip(ftype)
22983 
      iprot.readFieldEnd()
22984 
    iprot.readStructEnd()
22985 
 
22986 
  def write(self, oprot):
22987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22989 
      return
22990 
    oprot.writeStructBegin('getOrderForAwb_result')
22991 
    if self.success is not None:
22992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22993 
      self.success.write(oprot)
22994 
      oprot.writeFieldEnd()
22995 
    if self.ex is not None:
22996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22997 
      self.ex.write(oprot)
22998 
      oprot.writeFieldEnd()
22999 
    oprot.writeFieldStop()
23000 
    oprot.writeStructEnd()
23001 
 
23002 
  def validate(self):
23003 
    return
23004 
 
23005 
 
23006 
  def __repr__(self):
23007 
    L = ['%s=%r' % (key, value)
23008 
      for key, value in self.__dict__.iteritems()]
23009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23010 
 
23011 
  def __eq__(self, other):
23012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23013 
 
23014 
  def __ne__(self, other):
23015 
    return not (self == other)
4506 phani.kuma 23016 
 
23017 
class getOrdersForProviderForStatus_args:
23018 
  """
23019 
  Attributes:
23020 
   - logistics_provider_id
4910 phani.kuma 23021 
   - order_status_list
4506 phani.kuma 23022 
  """
23023 
 
23024 
  thrift_spec = (
23025 
    None, # 0
23026 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23027 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23028 
  )
23029 
 
4910 phani.kuma 23030 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23031 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23032 
    self.order_status_list = order_status_list
4506 phani.kuma 23033 
 
23034 
  def read(self, iprot):
23035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23037 
      return
23038 
    iprot.readStructBegin()
23039 
    while True:
23040 
      (fname, ftype, fid) = iprot.readFieldBegin()
23041 
      if ftype == TType.STOP:
23042 
        break
23043 
      if fid == 1:
23044 
        if ftype == TType.I64:
23045 
          self.logistics_provider_id = iprot.readI64();
23046 
        else:
23047 
          iprot.skip(ftype)
23048 
      elif fid == 2:
4910 phani.kuma 23049 
        if ftype == TType.LIST:
23050 
          self.order_status_list = []
6188 rajveer 23051 
          (_etype513, _size510) = iprot.readListBegin()
23052 
          for _i514 in xrange(_size510):
23053 
            _elem515 = iprot.readI32();
23054 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23055 
          iprot.readListEnd()
4506 phani.kuma 23056 
        else:
23057 
          iprot.skip(ftype)
23058 
      else:
23059 
        iprot.skip(ftype)
23060 
      iprot.readFieldEnd()
23061 
    iprot.readStructEnd()
23062 
 
23063 
  def write(self, oprot):
23064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23066 
      return
23067 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23068 
    if self.logistics_provider_id is not None:
23069 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23070 
      oprot.writeI64(self.logistics_provider_id)
23071 
      oprot.writeFieldEnd()
4910 phani.kuma 23072 
    if self.order_status_list is not None:
23073 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23074 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23075 
      for iter516 in self.order_status_list:
23076 
        oprot.writeI32(iter516)
4910 phani.kuma 23077 
      oprot.writeListEnd()
4506 phani.kuma 23078 
      oprot.writeFieldEnd()
23079 
    oprot.writeFieldStop()
23080 
    oprot.writeStructEnd()
23081 
 
23082 
  def validate(self):
23083 
    return
23084 
 
23085 
 
23086 
  def __repr__(self):
23087 
    L = ['%s=%r' % (key, value)
23088 
      for key, value in self.__dict__.iteritems()]
23089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23090 
 
23091 
  def __eq__(self, other):
23092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23093 
 
23094 
  def __ne__(self, other):
23095 
    return not (self == other)
23096 
 
23097 
class getOrdersForProviderForStatus_result:
23098 
  """
23099 
  Attributes:
23100 
   - success
23101 
   - ex
23102 
  """
23103 
 
23104 
  thrift_spec = (
23105 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23106 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23107 
  )
23108 
 
23109 
  def __init__(self, success=None, ex=None,):
23110 
    self.success = success
23111 
    self.ex = ex
23112 
 
23113 
  def read(self, iprot):
23114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23116 
      return
23117 
    iprot.readStructBegin()
23118 
    while True:
23119 
      (fname, ftype, fid) = iprot.readFieldBegin()
23120 
      if ftype == TType.STOP:
23121 
        break
23122 
      if fid == 0:
23123 
        if ftype == TType.LIST:
23124 
          self.success = []
6188 rajveer 23125 
          (_etype520, _size517) = iprot.readListBegin()
23126 
          for _i521 in xrange(_size517):
23127 
            _elem522 = Order()
23128 
            _elem522.read(iprot)
23129 
            self.success.append(_elem522)
4506 phani.kuma 23130 
          iprot.readListEnd()
23131 
        else:
23132 
          iprot.skip(ftype)
23133 
      elif fid == 1:
23134 
        if ftype == TType.STRUCT:
23135 
          self.ex = TransactionServiceException()
23136 
          self.ex.read(iprot)
23137 
        else:
23138 
          iprot.skip(ftype)
23139 
      else:
23140 
        iprot.skip(ftype)
23141 
      iprot.readFieldEnd()
23142 
    iprot.readStructEnd()
23143 
 
23144 
  def write(self, oprot):
23145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23147 
      return
23148 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23149 
    if self.success is not None:
23150 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23151 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23152 
      for iter523 in self.success:
23153 
        iter523.write(oprot)
4506 phani.kuma 23154 
      oprot.writeListEnd()
23155 
      oprot.writeFieldEnd()
23156 
    if self.ex is not None:
23157 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23158 
      self.ex.write(oprot)
23159 
      oprot.writeFieldEnd()
23160 
    oprot.writeFieldStop()
23161 
    oprot.writeStructEnd()
23162 
 
23163 
  def validate(self):
23164 
    return
23165 
 
23166 
 
23167 
  def __repr__(self):
23168 
    L = ['%s=%r' % (key, value)
23169 
      for key, value in self.__dict__.iteritems()]
23170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23171 
 
23172 
  def __eq__(self, other):
23173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23174 
 
23175 
  def __ne__(self, other):
23176 
    return not (self == other)
4600 varun.gupt 23177 
 
23178 
class getBilledOrdersForVendor_args:
23179 
  """
23180 
  Attributes:
23181 
   - vendorId
23182 
   - billingDateFrom
23183 
   - billingDateTo
23184 
  """
23185 
 
23186 
  thrift_spec = (
23187 
    None, # 0
23188 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23189 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23190 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23191 
  )
23192 
 
23193 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23194 
    self.vendorId = vendorId
23195 
    self.billingDateFrom = billingDateFrom
23196 
    self.billingDateTo = billingDateTo
23197 
 
23198 
  def read(self, iprot):
23199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23201 
      return
23202 
    iprot.readStructBegin()
23203 
    while True:
23204 
      (fname, ftype, fid) = iprot.readFieldBegin()
23205 
      if ftype == TType.STOP:
23206 
        break
23207 
      if fid == 1:
23208 
        if ftype == TType.I64:
23209 
          self.vendorId = iprot.readI64();
23210 
        else:
23211 
          iprot.skip(ftype)
23212 
      elif fid == 2:
23213 
        if ftype == TType.I64:
23214 
          self.billingDateFrom = iprot.readI64();
23215 
        else:
23216 
          iprot.skip(ftype)
23217 
      elif fid == 3:
23218 
        if ftype == TType.I64:
23219 
          self.billingDateTo = iprot.readI64();
23220 
        else:
23221 
          iprot.skip(ftype)
23222 
      else:
23223 
        iprot.skip(ftype)
23224 
      iprot.readFieldEnd()
23225 
    iprot.readStructEnd()
23226 
 
23227 
  def write(self, oprot):
23228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23230 
      return
23231 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23232 
    if self.vendorId is not None:
23233 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23234 
      oprot.writeI64(self.vendorId)
23235 
      oprot.writeFieldEnd()
23236 
    if self.billingDateFrom is not None:
23237 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23238 
      oprot.writeI64(self.billingDateFrom)
23239 
      oprot.writeFieldEnd()
23240 
    if self.billingDateTo is not None:
23241 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23242 
      oprot.writeI64(self.billingDateTo)
23243 
      oprot.writeFieldEnd()
23244 
    oprot.writeFieldStop()
23245 
    oprot.writeStructEnd()
23246 
 
23247 
  def validate(self):
23248 
    return
23249 
 
23250 
 
23251 
  def __repr__(self):
23252 
    L = ['%s=%r' % (key, value)
23253 
      for key, value in self.__dict__.iteritems()]
23254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23255 
 
23256 
  def __eq__(self, other):
23257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23258 
 
23259 
  def __ne__(self, other):
23260 
    return not (self == other)
23261 
 
23262 
class getBilledOrdersForVendor_result:
23263 
  """
23264 
  Attributes:
23265 
   - success
23266 
   - ex
23267 
  """
23268 
 
23269 
  thrift_spec = (
23270 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23272 
  )
23273 
 
23274 
  def __init__(self, success=None, ex=None,):
23275 
    self.success = success
23276 
    self.ex = ex
23277 
 
23278 
  def read(self, iprot):
23279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23281 
      return
23282 
    iprot.readStructBegin()
23283 
    while True:
23284 
      (fname, ftype, fid) = iprot.readFieldBegin()
23285 
      if ftype == TType.STOP:
23286 
        break
23287 
      if fid == 0:
23288 
        if ftype == TType.LIST:
23289 
          self.success = []
6188 rajveer 23290 
          (_etype527, _size524) = iprot.readListBegin()
23291 
          for _i528 in xrange(_size524):
23292 
            _elem529 = Order()
23293 
            _elem529.read(iprot)
23294 
            self.success.append(_elem529)
4600 varun.gupt 23295 
          iprot.readListEnd()
23296 
        else:
23297 
          iprot.skip(ftype)
23298 
      elif fid == 1:
23299 
        if ftype == TType.STRUCT:
23300 
          self.ex = TransactionServiceException()
23301 
          self.ex.read(iprot)
23302 
        else:
23303 
          iprot.skip(ftype)
23304 
      else:
23305 
        iprot.skip(ftype)
23306 
      iprot.readFieldEnd()
23307 
    iprot.readStructEnd()
23308 
 
23309 
  def write(self, oprot):
23310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23312 
      return
23313 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23314 
    if self.success is not None:
23315 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23316 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23317 
      for iter530 in self.success:
23318 
        iter530.write(oprot)
4600 varun.gupt 23319 
      oprot.writeListEnd()
23320 
      oprot.writeFieldEnd()
23321 
    if self.ex is not None:
23322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23323 
      self.ex.write(oprot)
23324 
      oprot.writeFieldEnd()
23325 
    oprot.writeFieldStop()
23326 
    oprot.writeStructEnd()
23327 
 
23328 
  def validate(self):
23329 
    return
23330 
 
23331 
 
23332 
  def __repr__(self):
23333 
    L = ['%s=%r' % (key, value)
23334 
      for key, value in self.__dict__.iteritems()]
23335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23336 
 
23337 
  def __eq__(self, other):
23338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23339 
 
23340 
  def __ne__(self, other):
23341 
    return not (self == other)
23342 
 
4607 rajveer 23343 
class getSlippedSippingDateOrders_args:
23344 
 
23345 
  thrift_spec = (
23346 
  )
23347 
 
23348 
  def read(self, iprot):
23349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23351 
      return
23352 
    iprot.readStructBegin()
23353 
    while True:
23354 
      (fname, ftype, fid) = iprot.readFieldBegin()
23355 
      if ftype == TType.STOP:
23356 
        break
23357 
      else:
23358 
        iprot.skip(ftype)
23359 
      iprot.readFieldEnd()
23360 
    iprot.readStructEnd()
23361 
 
23362 
  def write(self, oprot):
23363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23365 
      return
23366 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23367 
    oprot.writeFieldStop()
23368 
    oprot.writeStructEnd()
23369 
 
23370 
  def validate(self):
23371 
    return
23372 
 
23373 
 
23374 
  def __repr__(self):
23375 
    L = ['%s=%r' % (key, value)
23376 
      for key, value in self.__dict__.iteritems()]
23377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23378 
 
23379 
  def __eq__(self, other):
23380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23381 
 
23382 
  def __ne__(self, other):
23383 
    return not (self == other)
23384 
 
23385 
class getSlippedSippingDateOrders_result:
23386 
  """
23387 
  Attributes:
23388 
   - success
23389 
   - ex
23390 
  """
23391 
 
23392 
  thrift_spec = (
23393 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23395 
  )
23396 
 
23397 
  def __init__(self, success=None, ex=None,):
23398 
    self.success = success
23399 
    self.ex = ex
23400 
 
23401 
  def read(self, iprot):
23402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23404 
      return
23405 
    iprot.readStructBegin()
23406 
    while True:
23407 
      (fname, ftype, fid) = iprot.readFieldBegin()
23408 
      if ftype == TType.STOP:
23409 
        break
23410 
      if fid == 0:
23411 
        if ftype == TType.LIST:
23412 
          self.success = []
6188 rajveer 23413 
          (_etype534, _size531) = iprot.readListBegin()
23414 
          for _i535 in xrange(_size531):
23415 
            _elem536 = Order()
23416 
            _elem536.read(iprot)
23417 
            self.success.append(_elem536)
4607 rajveer 23418 
          iprot.readListEnd()
23419 
        else:
23420 
          iprot.skip(ftype)
23421 
      elif fid == 1:
23422 
        if ftype == TType.STRUCT:
23423 
          self.ex = TransactionServiceException()
23424 
          self.ex.read(iprot)
23425 
        else:
23426 
          iprot.skip(ftype)
23427 
      else:
23428 
        iprot.skip(ftype)
23429 
      iprot.readFieldEnd()
23430 
    iprot.readStructEnd()
23431 
 
23432 
  def write(self, oprot):
23433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23435 
      return
23436 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23437 
    if self.success is not None:
23438 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23439 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23440 
      for iter537 in self.success:
23441 
        iter537.write(oprot)
4607 rajveer 23442 
      oprot.writeListEnd()
23443 
      oprot.writeFieldEnd()
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 
 
4709 rajveer 23466 
class getCancelledOrders_args:
23467 
  """
23468 
  Attributes:
23469 
   - cancelDateFrom
23470 
   - cancelDateTo
23471 
  """
23472 
 
23473 
  thrift_spec = (
23474 
    None, # 0
23475 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23476 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23477 
  )
23478 
 
23479 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23480 
    self.cancelDateFrom = cancelDateFrom
23481 
    self.cancelDateTo = cancelDateTo
23482 
 
23483 
  def read(self, iprot):
23484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23486 
      return
23487 
    iprot.readStructBegin()
23488 
    while True:
23489 
      (fname, ftype, fid) = iprot.readFieldBegin()
23490 
      if ftype == TType.STOP:
23491 
        break
23492 
      if fid == 1:
23493 
        if ftype == TType.I64:
23494 
          self.cancelDateFrom = iprot.readI64();
23495 
        else:
23496 
          iprot.skip(ftype)
23497 
      elif fid == 2:
23498 
        if ftype == TType.I64:
23499 
          self.cancelDateTo = iprot.readI64();
23500 
        else:
23501 
          iprot.skip(ftype)
23502 
      else:
23503 
        iprot.skip(ftype)
23504 
      iprot.readFieldEnd()
23505 
    iprot.readStructEnd()
23506 
 
23507 
  def write(self, oprot):
23508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23510 
      return
23511 
    oprot.writeStructBegin('getCancelledOrders_args')
23512 
    if self.cancelDateFrom is not None:
23513 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23514 
      oprot.writeI64(self.cancelDateFrom)
23515 
      oprot.writeFieldEnd()
23516 
    if self.cancelDateTo is not None:
23517 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23518 
      oprot.writeI64(self.cancelDateTo)
23519 
      oprot.writeFieldEnd()
23520 
    oprot.writeFieldStop()
23521 
    oprot.writeStructEnd()
23522 
 
23523 
  def validate(self):
23524 
    return
23525 
 
23526 
 
23527 
  def __repr__(self):
23528 
    L = ['%s=%r' % (key, value)
23529 
      for key, value in self.__dict__.iteritems()]
23530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23531 
 
23532 
  def __eq__(self, other):
23533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23534 
 
23535 
  def __ne__(self, other):
23536 
    return not (self == other)
23537 
 
23538 
class getCancelledOrders_result:
23539 
  """
23540 
  Attributes:
23541 
   - success
23542 
   - ex
23543 
  """
23544 
 
23545 
  thrift_spec = (
23546 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23548 
  )
23549 
 
23550 
  def __init__(self, success=None, ex=None,):
23551 
    self.success = success
23552 
    self.ex = ex
23553 
 
23554 
  def read(self, iprot):
23555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23557 
      return
23558 
    iprot.readStructBegin()
23559 
    while True:
23560 
      (fname, ftype, fid) = iprot.readFieldBegin()
23561 
      if ftype == TType.STOP:
23562 
        break
23563 
      if fid == 0:
23564 
        if ftype == TType.LIST:
23565 
          self.success = []
6188 rajveer 23566 
          (_etype541, _size538) = iprot.readListBegin()
23567 
          for _i542 in xrange(_size538):
23568 
            _elem543 = Order()
23569 
            _elem543.read(iprot)
23570 
            self.success.append(_elem543)
4709 rajveer 23571 
          iprot.readListEnd()
23572 
        else:
23573 
          iprot.skip(ftype)
23574 
      elif fid == 1:
23575 
        if ftype == TType.STRUCT:
23576 
          self.ex = TransactionServiceException()
23577 
          self.ex.read(iprot)
23578 
        else:
23579 
          iprot.skip(ftype)
23580 
      else:
23581 
        iprot.skip(ftype)
23582 
      iprot.readFieldEnd()
23583 
    iprot.readStructEnd()
23584 
 
23585 
  def write(self, oprot):
23586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23588 
      return
23589 
    oprot.writeStructBegin('getCancelledOrders_result')
23590 
    if self.success is not None:
23591 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23592 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23593 
      for iter544 in self.success:
23594 
        iter544.write(oprot)
4709 rajveer 23595 
      oprot.writeListEnd()
23596 
      oprot.writeFieldEnd()
23597 
    if self.ex is not None:
23598 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23599 
      self.ex.write(oprot)
23600 
      oprot.writeFieldEnd()
23601 
    oprot.writeFieldStop()
23602 
    oprot.writeStructEnd()
23603 
 
23604 
  def validate(self):
23605 
    return
23606 
 
23607 
 
23608 
  def __repr__(self):
23609 
    L = ['%s=%r' % (key, value)
23610 
      for key, value in self.__dict__.iteritems()]
23611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23612 
 
23613 
  def __eq__(self, other):
23614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23615 
 
23616 
  def __ne__(self, other):
23617 
    return not (self == other)
23618 
 
4600 varun.gupt 23619 
class saveBluedartSettlements_args:
23620 
  """
23621 
  Attributes:
23622 
   - mapAWBAndAmount
23623 
  """
23624 
 
23625 
  thrift_spec = (
23626 
    None, # 0
23627 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23628 
  )
23629 
 
23630 
  def __init__(self, mapAWBAndAmount=None,):
23631 
    self.mapAWBAndAmount = mapAWBAndAmount
23632 
 
23633 
  def read(self, iprot):
23634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23636 
      return
23637 
    iprot.readStructBegin()
23638 
    while True:
23639 
      (fname, ftype, fid) = iprot.readFieldBegin()
23640 
      if ftype == TType.STOP:
23641 
        break
23642 
      if fid == 1:
23643 
        if ftype == TType.MAP:
23644 
          self.mapAWBAndAmount = {}
6188 rajveer 23645 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23646 
          for _i549 in xrange(_size545):
23647 
            _key550 = iprot.readI64();
23648 
            _val551 = iprot.readDouble();
23649 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23650 
          iprot.readMapEnd()
23651 
        else:
23652 
          iprot.skip(ftype)
23653 
      else:
23654 
        iprot.skip(ftype)
23655 
      iprot.readFieldEnd()
23656 
    iprot.readStructEnd()
23657 
 
23658 
  def write(self, oprot):
23659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23661 
      return
23662 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23663 
    if self.mapAWBAndAmount is not None:
23664 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23665 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23666 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23667 
        oprot.writeI64(kiter552)
23668 
        oprot.writeDouble(viter553)
4600 varun.gupt 23669 
      oprot.writeMapEnd()
23670 
      oprot.writeFieldEnd()
23671 
    oprot.writeFieldStop()
23672 
    oprot.writeStructEnd()
23673 
 
23674 
  def validate(self):
23675 
    return
23676 
 
23677 
 
23678 
  def __repr__(self):
23679 
    L = ['%s=%r' % (key, value)
23680 
      for key, value in self.__dict__.iteritems()]
23681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23682 
 
23683 
  def __eq__(self, other):
23684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23685 
 
23686 
  def __ne__(self, other):
23687 
    return not (self == other)
23688 
 
23689 
class saveBluedartSettlements_result:
23690 
  """
23691 
  Attributes:
23692 
   - ex
23693 
  """
23694 
 
23695 
  thrift_spec = (
23696 
    None, # 0
23697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23698 
  )
23699 
 
23700 
  def __init__(self, ex=None,):
23701 
    self.ex = ex
23702 
 
23703 
  def read(self, iprot):
23704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23706 
      return
23707 
    iprot.readStructBegin()
23708 
    while True:
23709 
      (fname, ftype, fid) = iprot.readFieldBegin()
23710 
      if ftype == TType.STOP:
23711 
        break
23712 
      if fid == 1:
23713 
        if ftype == TType.STRUCT:
23714 
          self.ex = TransactionServiceException()
23715 
          self.ex.read(iprot)
23716 
        else:
23717 
          iprot.skip(ftype)
23718 
      else:
23719 
        iprot.skip(ftype)
23720 
      iprot.readFieldEnd()
23721 
    iprot.readStructEnd()
23722 
 
23723 
  def write(self, oprot):
23724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23726 
      return
23727 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23728 
    if self.ex is not None:
23729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23730 
      self.ex.write(oprot)
23731 
      oprot.writeFieldEnd()
23732 
    oprot.writeFieldStop()
23733 
    oprot.writeStructEnd()
23734 
 
23735 
  def validate(self):
23736 
    return
23737 
 
23738 
 
23739 
  def __repr__(self):
23740 
    L = ['%s=%r' % (key, value)
23741 
      for key, value in self.__dict__.iteritems()]
23742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23743 
 
23744 
  def __eq__(self, other):
23745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23746 
 
23747 
  def __ne__(self, other):
23748 
    return not (self == other)
23749 
 
23750 
class savePaymentSettlements_args:
23751 
  """
23752 
  Attributes:
23753 
   - settlementDate
23754 
   - paymentGatewayId
4905 varun.gupt 23755 
   - referenceId
4600 varun.gupt 23756 
   - serviceTax
23757 
   - otherCharges
23758 
   - netCollection
23759 
  """
23760 
 
23761 
  thrift_spec = (
23762 
    None, # 0
23763 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23764 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23765 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23766 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23767 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23768 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23769 
  )
23770 
 
4905 varun.gupt 23771 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23772 
    self.settlementDate = settlementDate
23773 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23774 
    self.referenceId = referenceId
4600 varun.gupt 23775 
    self.serviceTax = serviceTax
23776 
    self.otherCharges = otherCharges
23777 
    self.netCollection = netCollection
23778 
 
23779 
  def read(self, iprot):
23780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23782 
      return
23783 
    iprot.readStructBegin()
23784 
    while True:
23785 
      (fname, ftype, fid) = iprot.readFieldBegin()
23786 
      if ftype == TType.STOP:
23787 
        break
23788 
      if fid == 1:
23789 
        if ftype == TType.I64:
23790 
          self.settlementDate = iprot.readI64();
23791 
        else:
23792 
          iprot.skip(ftype)
23793 
      elif fid == 2:
23794 
        if ftype == TType.I64:
23795 
          self.paymentGatewayId = iprot.readI64();
23796 
        else:
23797 
          iprot.skip(ftype)
23798 
      elif fid == 3:
23799 
        if ftype == TType.I64:
4905 varun.gupt 23800 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23801 
        else:
23802 
          iprot.skip(ftype)
23803 
      elif fid == 4:
23804 
        if ftype == TType.DOUBLE:
23805 
          self.serviceTax = iprot.readDouble();
23806 
        else:
23807 
          iprot.skip(ftype)
23808 
      elif fid == 5:
23809 
        if ftype == TType.DOUBLE:
23810 
          self.otherCharges = iprot.readDouble();
23811 
        else:
23812 
          iprot.skip(ftype)
23813 
      elif fid == 6:
23814 
        if ftype == TType.DOUBLE:
23815 
          self.netCollection = iprot.readDouble();
23816 
        else:
23817 
          iprot.skip(ftype)
23818 
      else:
23819 
        iprot.skip(ftype)
23820 
      iprot.readFieldEnd()
23821 
    iprot.readStructEnd()
23822 
 
23823 
  def write(self, oprot):
23824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23826 
      return
23827 
    oprot.writeStructBegin('savePaymentSettlements_args')
23828 
    if self.settlementDate is not None:
23829 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23830 
      oprot.writeI64(self.settlementDate)
23831 
      oprot.writeFieldEnd()
23832 
    if self.paymentGatewayId is not None:
23833 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23834 
      oprot.writeI64(self.paymentGatewayId)
23835 
      oprot.writeFieldEnd()
4905 varun.gupt 23836 
    if self.referenceId is not None:
23837 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23838 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23839 
      oprot.writeFieldEnd()
23840 
    if self.serviceTax is not None:
23841 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23842 
      oprot.writeDouble(self.serviceTax)
23843 
      oprot.writeFieldEnd()
23844 
    if self.otherCharges is not None:
23845 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23846 
      oprot.writeDouble(self.otherCharges)
23847 
      oprot.writeFieldEnd()
23848 
    if self.netCollection is not None:
23849 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23850 
      oprot.writeDouble(self.netCollection)
23851 
      oprot.writeFieldEnd()
23852 
    oprot.writeFieldStop()
23853 
    oprot.writeStructEnd()
23854 
 
23855 
  def validate(self):
23856 
    return
23857 
 
23858 
 
23859 
  def __repr__(self):
23860 
    L = ['%s=%r' % (key, value)
23861 
      for key, value in self.__dict__.iteritems()]
23862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23863 
 
23864 
  def __eq__(self, other):
23865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23866 
 
23867 
  def __ne__(self, other):
23868 
    return not (self == other)
23869 
 
23870 
class savePaymentSettlements_result:
23871 
  """
23872 
  Attributes:
23873 
   - ex
23874 
  """
23875 
 
23876 
  thrift_spec = (
23877 
    None, # 0
23878 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23879 
  )
23880 
 
23881 
  def __init__(self, ex=None,):
23882 
    self.ex = ex
23883 
 
23884 
  def read(self, iprot):
23885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23887 
      return
23888 
    iprot.readStructBegin()
23889 
    while True:
23890 
      (fname, ftype, fid) = iprot.readFieldBegin()
23891 
      if ftype == TType.STOP:
23892 
        break
23893 
      if fid == 1:
23894 
        if ftype == TType.STRUCT:
23895 
          self.ex = TransactionServiceException()
23896 
          self.ex.read(iprot)
23897 
        else:
23898 
          iprot.skip(ftype)
23899 
      else:
23900 
        iprot.skip(ftype)
23901 
      iprot.readFieldEnd()
23902 
    iprot.readStructEnd()
23903 
 
23904 
  def write(self, oprot):
23905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23907 
      return
23908 
    oprot.writeStructBegin('savePaymentSettlements_result')
23909 
    if self.ex is not None:
23910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23911 
      self.ex.write(oprot)
23912 
      oprot.writeFieldEnd()
23913 
    oprot.writeFieldStop()
23914 
    oprot.writeStructEnd()
23915 
 
23916 
  def validate(self):
23917 
    return
23918 
 
23919 
 
23920 
  def __repr__(self):
23921 
    L = ['%s=%r' % (key, value)
23922 
      for key, value in self.__dict__.iteritems()]
23923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23924 
 
23925 
  def __eq__(self, other):
23926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23927 
 
23928 
  def __ne__(self, other):
23929 
    return not (self == other)
23930 
 
23931 
class saveEBSSettlementSummary_args:
23932 
  """
23933 
  Attributes:
23934 
   - settlementId
23935 
   - settlementDate
23936 
   - transactionDateFrom
23937 
   - transactionDateTo
23938 
   - amount
23939 
  """
23940 
 
23941 
  thrift_spec = (
23942 
    None, # 0
23943 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23944 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23945 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23946 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23947 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23948 
  )
23949 
 
23950 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23951 
    self.settlementId = settlementId
23952 
    self.settlementDate = settlementDate
23953 
    self.transactionDateFrom = transactionDateFrom
23954 
    self.transactionDateTo = transactionDateTo
23955 
    self.amount = amount
23956 
 
23957 
  def read(self, iprot):
23958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23960 
      return
23961 
    iprot.readStructBegin()
23962 
    while True:
23963 
      (fname, ftype, fid) = iprot.readFieldBegin()
23964 
      if ftype == TType.STOP:
23965 
        break
23966 
      if fid == 1:
23967 
        if ftype == TType.I64:
23968 
          self.settlementId = iprot.readI64();
23969 
        else:
23970 
          iprot.skip(ftype)
23971 
      elif fid == 2:
23972 
        if ftype == TType.I64:
23973 
          self.settlementDate = iprot.readI64();
23974 
        else:
23975 
          iprot.skip(ftype)
23976 
      elif fid == 3:
23977 
        if ftype == TType.I64:
23978 
          self.transactionDateFrom = iprot.readI64();
23979 
        else:
23980 
          iprot.skip(ftype)
23981 
      elif fid == 4:
23982 
        if ftype == TType.I64:
23983 
          self.transactionDateTo = iprot.readI64();
23984 
        else:
23985 
          iprot.skip(ftype)
23986 
      elif fid == 5:
23987 
        if ftype == TType.DOUBLE:
23988 
          self.amount = iprot.readDouble();
23989 
        else:
23990 
          iprot.skip(ftype)
23991 
      else:
23992 
        iprot.skip(ftype)
23993 
      iprot.readFieldEnd()
23994 
    iprot.readStructEnd()
23995 
 
23996 
  def write(self, oprot):
23997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23999 
      return
24000 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24001 
    if self.settlementId is not None:
24002 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24003 
      oprot.writeI64(self.settlementId)
24004 
      oprot.writeFieldEnd()
24005 
    if self.settlementDate is not None:
24006 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24007 
      oprot.writeI64(self.settlementDate)
24008 
      oprot.writeFieldEnd()
24009 
    if self.transactionDateFrom is not None:
24010 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24011 
      oprot.writeI64(self.transactionDateFrom)
24012 
      oprot.writeFieldEnd()
24013 
    if self.transactionDateTo is not None:
24014 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24015 
      oprot.writeI64(self.transactionDateTo)
24016 
      oprot.writeFieldEnd()
24017 
    if self.amount is not None:
24018 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24019 
      oprot.writeDouble(self.amount)
24020 
      oprot.writeFieldEnd()
24021 
    oprot.writeFieldStop()
24022 
    oprot.writeStructEnd()
24023 
 
24024 
  def validate(self):
24025 
    return
24026 
 
24027 
 
24028 
  def __repr__(self):
24029 
    L = ['%s=%r' % (key, value)
24030 
      for key, value in self.__dict__.iteritems()]
24031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24032 
 
24033 
  def __eq__(self, other):
24034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24035 
 
24036 
  def __ne__(self, other):
24037 
    return not (self == other)
24038 
 
24039 
class saveEBSSettlementSummary_result:
24040 
  """
24041 
  Attributes:
24042 
   - ex
24043 
  """
24044 
 
24045 
  thrift_spec = (
24046 
    None, # 0
24047 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24048 
  )
24049 
 
24050 
  def __init__(self, ex=None,):
24051 
    self.ex = ex
24052 
 
24053 
  def read(self, iprot):
24054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24056 
      return
24057 
    iprot.readStructBegin()
24058 
    while True:
24059 
      (fname, ftype, fid) = iprot.readFieldBegin()
24060 
      if ftype == TType.STOP:
24061 
        break
24062 
      if fid == 1:
24063 
        if ftype == TType.STRUCT:
24064 
          self.ex = TransactionServiceException()
24065 
          self.ex.read(iprot)
24066 
        else:
24067 
          iprot.skip(ftype)
24068 
      else:
24069 
        iprot.skip(ftype)
24070 
      iprot.readFieldEnd()
24071 
    iprot.readStructEnd()
24072 
 
24073 
  def write(self, oprot):
24074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24076 
      return
24077 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24078 
    if self.ex is not None:
24079 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24080 
      self.ex.write(oprot)
24081 
      oprot.writeFieldEnd()
24082 
    oprot.writeFieldStop()
24083 
    oprot.writeStructEnd()
24084 
 
24085 
  def validate(self):
24086 
    return
24087 
 
24088 
 
24089 
  def __repr__(self):
24090 
    L = ['%s=%r' % (key, value)
24091 
      for key, value in self.__dict__.iteritems()]
24092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24093 
 
24094 
  def __eq__(self, other):
24095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24096 
 
24097 
  def __ne__(self, other):
24098 
    return not (self == other)
24099 
 
5386 phani.kuma 24100 
class getSettlementForPrepaid_args:
4600 varun.gupt 24101 
  """
24102 
  Attributes:
5189 varun.gupt 24103 
   - referenceId
24104 
   - isRefund
4600 varun.gupt 24105 
  """
24106 
 
24107 
  thrift_spec = (
24108 
    None, # 0
5189 varun.gupt 24109 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24110 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24111 
  )
24112 
 
5386 phani.kuma 24113 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24114 
    self.referenceId = referenceId
24115 
    self.isRefund = isRefund
4600 varun.gupt 24116 
 
24117 
  def read(self, iprot):
24118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24120 
      return
24121 
    iprot.readStructBegin()
24122 
    while True:
24123 
      (fname, ftype, fid) = iprot.readFieldBegin()
24124 
      if ftype == TType.STOP:
24125 
        break
24126 
      if fid == 1:
24127 
        if ftype == TType.I64:
5189 varun.gupt 24128 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24129 
        else:
24130 
          iprot.skip(ftype)
5189 varun.gupt 24131 
      elif fid == 2:
24132 
        if ftype == TType.BOOL:
24133 
          self.isRefund = iprot.readBool();
24134 
        else:
24135 
          iprot.skip(ftype)
4600 varun.gupt 24136 
      else:
24137 
        iprot.skip(ftype)
24138 
      iprot.readFieldEnd()
24139 
    iprot.readStructEnd()
24140 
 
24141 
  def write(self, oprot):
24142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24144 
      return
5386 phani.kuma 24145 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24146 
    if self.referenceId is not None:
24147 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24148 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24149 
      oprot.writeFieldEnd()
5386 phani.kuma 24150 
    if self.isRefund is not None:
24151 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24152 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24153 
      oprot.writeFieldEnd()
5386 phani.kuma 24154 
    oprot.writeFieldStop()
24155 
    oprot.writeStructEnd()
24156 
 
24157 
  def validate(self):
24158 
    return
24159 
 
24160 
 
24161 
  def __repr__(self):
24162 
    L = ['%s=%r' % (key, value)
24163 
      for key, value in self.__dict__.iteritems()]
24164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24165 
 
24166 
  def __eq__(self, other):
24167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24168 
 
24169 
  def __ne__(self, other):
24170 
    return not (self == other)
24171 
 
24172 
class getSettlementForPrepaid_result:
24173 
  """
24174 
  Attributes:
24175 
   - success
24176 
   - ex
24177 
  """
24178 
 
24179 
  thrift_spec = (
24180 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24182 
  )
24183 
 
24184 
  def __init__(self, success=None, ex=None,):
24185 
    self.success = success
24186 
    self.ex = ex
24187 
 
24188 
  def read(self, iprot):
24189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24191 
      return
24192 
    iprot.readStructBegin()
24193 
    while True:
24194 
      (fname, ftype, fid) = iprot.readFieldBegin()
24195 
      if ftype == TType.STOP:
24196 
        break
24197 
      if fid == 0:
24198 
        if ftype == TType.STRUCT:
24199 
          self.success = PaymentSettlement()
24200 
          self.success.read(iprot)
24201 
        else:
24202 
          iprot.skip(ftype)
24203 
      elif fid == 1:
24204 
        if ftype == TType.STRUCT:
24205 
          self.ex = TransactionServiceException()
24206 
          self.ex.read(iprot)
24207 
        else:
24208 
          iprot.skip(ftype)
24209 
      else:
24210 
        iprot.skip(ftype)
24211 
      iprot.readFieldEnd()
24212 
    iprot.readStructEnd()
24213 
 
24214 
  def write(self, oprot):
24215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24217 
      return
24218 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24219 
    if self.success is not None:
24220 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24221 
      self.success.write(oprot)
24222 
      oprot.writeFieldEnd()
24223 
    if self.ex is not None:
24224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24225 
      self.ex.write(oprot)
24226 
      oprot.writeFieldEnd()
24227 
    oprot.writeFieldStop()
24228 
    oprot.writeStructEnd()
24229 
 
24230 
  def validate(self):
24231 
    return
24232 
 
24233 
 
24234 
  def __repr__(self):
24235 
    L = ['%s=%r' % (key, value)
24236 
      for key, value in self.__dict__.iteritems()]
24237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24238 
 
24239 
  def __eq__(self, other):
24240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24241 
 
24242 
  def __ne__(self, other):
24243 
    return not (self == other)
24244 
 
24245 
class getSettlementForCod_args:
24246 
  """
24247 
  Attributes:
24248 
   - orderId
24249 
   - isRefund
24250 
  """
24251 
 
24252 
  thrift_spec = (
24253 
    None, # 0
24254 
    (1, TType.I64, 'orderId', None, None, ), # 1
24255 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24256 
  )
24257 
 
24258 
  def __init__(self, orderId=None, isRefund=None,):
24259 
    self.orderId = orderId
24260 
    self.isRefund = isRefund
24261 
 
24262 
  def read(self, iprot):
24263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24265 
      return
24266 
    iprot.readStructBegin()
24267 
    while True:
24268 
      (fname, ftype, fid) = iprot.readFieldBegin()
24269 
      if ftype == TType.STOP:
24270 
        break
24271 
      if fid == 1:
24272 
        if ftype == TType.I64:
24273 
          self.orderId = iprot.readI64();
24274 
        else:
24275 
          iprot.skip(ftype)
24276 
      elif fid == 2:
24277 
        if ftype == TType.BOOL:
24278 
          self.isRefund = iprot.readBool();
24279 
        else:
24280 
          iprot.skip(ftype)
24281 
      else:
24282 
        iprot.skip(ftype)
24283 
      iprot.readFieldEnd()
24284 
    iprot.readStructEnd()
24285 
 
24286 
  def write(self, oprot):
24287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24289 
      return
24290 
    oprot.writeStructBegin('getSettlementForCod_args')
24291 
    if self.orderId is not None:
24292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24293 
      oprot.writeI64(self.orderId)
24294 
      oprot.writeFieldEnd()
5189 varun.gupt 24295 
    if self.isRefund is not None:
5386 phani.kuma 24296 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24297 
      oprot.writeBool(self.isRefund)
24298 
      oprot.writeFieldEnd()
4600 varun.gupt 24299 
    oprot.writeFieldStop()
24300 
    oprot.writeStructEnd()
24301 
 
24302 
  def validate(self):
24303 
    return
24304 
 
24305 
 
24306 
  def __repr__(self):
24307 
    L = ['%s=%r' % (key, value)
24308 
      for key, value in self.__dict__.iteritems()]
24309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24310 
 
24311 
  def __eq__(self, other):
24312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24313 
 
24314 
  def __ne__(self, other):
24315 
    return not (self == other)
24316 
 
5386 phani.kuma 24317 
class getSettlementForCod_result:
4600 varun.gupt 24318 
  """
24319 
  Attributes:
24320 
   - success
24321 
   - ex
24322 
  """
24323 
 
24324 
  thrift_spec = (
24325 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24327 
  )
24328 
 
24329 
  def __init__(self, success=None, ex=None,):
24330 
    self.success = success
24331 
    self.ex = ex
24332 
 
24333 
  def read(self, iprot):
24334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24336 
      return
24337 
    iprot.readStructBegin()
24338 
    while True:
24339 
      (fname, ftype, fid) = iprot.readFieldBegin()
24340 
      if ftype == TType.STOP:
24341 
        break
24342 
      if fid == 0:
24343 
        if ftype == TType.STRUCT:
24344 
          self.success = PaymentSettlement()
24345 
          self.success.read(iprot)
24346 
        else:
24347 
          iprot.skip(ftype)
24348 
      elif fid == 1:
24349 
        if ftype == TType.STRUCT:
24350 
          self.ex = TransactionServiceException()
24351 
          self.ex.read(iprot)
24352 
        else:
24353 
          iprot.skip(ftype)
24354 
      else:
24355 
        iprot.skip(ftype)
24356 
      iprot.readFieldEnd()
24357 
    iprot.readStructEnd()
24358 
 
24359 
  def write(self, oprot):
24360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24362 
      return
5386 phani.kuma 24363 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24364 
    if self.success is not None:
24365 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24366 
      self.success.write(oprot)
24367 
      oprot.writeFieldEnd()
24368 
    if self.ex is not None:
24369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24370 
      self.ex.write(oprot)
24371 
      oprot.writeFieldEnd()
24372 
    oprot.writeFieldStop()
24373 
    oprot.writeStructEnd()
24374 
 
24375 
  def validate(self):
24376 
    return
24377 
 
24378 
 
24379 
  def __repr__(self):
24380 
    L = ['%s=%r' % (key, value)
24381 
      for key, value in self.__dict__.iteritems()]
24382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24383 
 
24384 
  def __eq__(self, other):
24385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24386 
 
24387 
  def __ne__(self, other):
24388 
    return not (self == other)
24389 
 
24390 
class getEBSSettlementSummaries_args:
24391 
 
24392 
  thrift_spec = (
24393 
  )
24394 
 
24395 
  def read(self, iprot):
24396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24398 
      return
24399 
    iprot.readStructBegin()
24400 
    while True:
24401 
      (fname, ftype, fid) = iprot.readFieldBegin()
24402 
      if ftype == TType.STOP:
24403 
        break
24404 
      else:
24405 
        iprot.skip(ftype)
24406 
      iprot.readFieldEnd()
24407 
    iprot.readStructEnd()
24408 
 
24409 
  def write(self, oprot):
24410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24412 
      return
24413 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24414 
    oprot.writeFieldStop()
24415 
    oprot.writeStructEnd()
24416 
 
24417 
  def validate(self):
24418 
    return
24419 
 
24420 
 
24421 
  def __repr__(self):
24422 
    L = ['%s=%r' % (key, value)
24423 
      for key, value in self.__dict__.iteritems()]
24424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24425 
 
24426 
  def __eq__(self, other):
24427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24428 
 
24429 
  def __ne__(self, other):
24430 
    return not (self == other)
24431 
 
24432 
class getEBSSettlementSummaries_result:
24433 
  """
24434 
  Attributes:
24435 
   - success
24436 
   - ex
24437 
  """
24438 
 
24439 
  thrift_spec = (
24440 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24441 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24442 
  )
24443 
 
24444 
  def __init__(self, success=None, ex=None,):
24445 
    self.success = success
24446 
    self.ex = ex
24447 
 
24448 
  def read(self, iprot):
24449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24451 
      return
24452 
    iprot.readStructBegin()
24453 
    while True:
24454 
      (fname, ftype, fid) = iprot.readFieldBegin()
24455 
      if ftype == TType.STOP:
24456 
        break
24457 
      if fid == 0:
24458 
        if ftype == TType.MAP:
24459 
          self.success = {}
6188 rajveer 24460 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24461 
          for _i558 in xrange(_size554):
24462 
            _key559 = iprot.readI64();
24463 
            _val560 = iprot.readString();
24464 
            self.success[_key559] = _val560
4600 varun.gupt 24465 
          iprot.readMapEnd()
24466 
        else:
24467 
          iprot.skip(ftype)
24468 
      elif fid == 1:
24469 
        if ftype == TType.STRUCT:
24470 
          self.ex = TransactionServiceException()
24471 
          self.ex.read(iprot)
24472 
        else:
24473 
          iprot.skip(ftype)
24474 
      else:
24475 
        iprot.skip(ftype)
24476 
      iprot.readFieldEnd()
24477 
    iprot.readStructEnd()
24478 
 
24479 
  def write(self, oprot):
24480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24482 
      return
24483 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24484 
    if self.success is not None:
24485 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24486 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24487 
      for kiter561,viter562 in self.success.items():
24488 
        oprot.writeI64(kiter561)
24489 
        oprot.writeString(viter562)
4600 varun.gupt 24490 
      oprot.writeMapEnd()
24491 
      oprot.writeFieldEnd()
24492 
    if self.ex is not None:
24493 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24494 
      self.ex.write(oprot)
24495 
      oprot.writeFieldEnd()
24496 
    oprot.writeFieldStop()
24497 
    oprot.writeStructEnd()
24498 
 
24499 
  def validate(self):
24500 
    return
24501 
 
24502 
 
24503 
  def __repr__(self):
24504 
    L = ['%s=%r' % (key, value)
24505 
      for key, value in self.__dict__.iteritems()]
24506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24507 
 
24508 
  def __eq__(self, other):
24509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24510 
 
24511 
  def __ne__(self, other):
24512 
    return not (self == other)
24513 
 
24514 
class markEBSSettlementUploaded_args:
24515 
  """
24516 
  Attributes:
24517 
   - settlementId
24518 
  """
24519 
 
24520 
  thrift_spec = (
24521 
    None, # 0
24522 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24523 
  )
24524 
 
24525 
  def __init__(self, settlementId=None,):
24526 
    self.settlementId = settlementId
24527 
 
24528 
  def read(self, iprot):
24529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24531 
      return
24532 
    iprot.readStructBegin()
24533 
    while True:
24534 
      (fname, ftype, fid) = iprot.readFieldBegin()
24535 
      if ftype == TType.STOP:
24536 
        break
24537 
      if fid == 1:
24538 
        if ftype == TType.I64:
24539 
          self.settlementId = iprot.readI64();
24540 
        else:
24541 
          iprot.skip(ftype)
24542 
      else:
24543 
        iprot.skip(ftype)
24544 
      iprot.readFieldEnd()
24545 
    iprot.readStructEnd()
24546 
 
24547 
  def write(self, oprot):
24548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24550 
      return
24551 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24552 
    if self.settlementId is not None:
24553 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24554 
      oprot.writeI64(self.settlementId)
24555 
      oprot.writeFieldEnd()
24556 
    oprot.writeFieldStop()
24557 
    oprot.writeStructEnd()
24558 
 
24559 
  def validate(self):
24560 
    return
24561 
 
24562 
 
24563 
  def __repr__(self):
24564 
    L = ['%s=%r' % (key, value)
24565 
      for key, value in self.__dict__.iteritems()]
24566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24567 
 
24568 
  def __eq__(self, other):
24569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24570 
 
24571 
  def __ne__(self, other):
24572 
    return not (self == other)
24573 
 
24574 
class markEBSSettlementUploaded_result:
24575 
  """
24576 
  Attributes:
24577 
   - ex
24578 
  """
24579 
 
24580 
  thrift_spec = (
24581 
    None, # 0
24582 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24583 
  )
24584 
 
24585 
  def __init__(self, ex=None,):
24586 
    self.ex = ex
24587 
 
24588 
  def read(self, iprot):
24589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24591 
      return
24592 
    iprot.readStructBegin()
24593 
    while True:
24594 
      (fname, ftype, fid) = iprot.readFieldBegin()
24595 
      if ftype == TType.STOP:
24596 
        break
24597 
      if fid == 1:
24598 
        if ftype == TType.STRUCT:
24599 
          self.ex = TransactionServiceException()
24600 
          self.ex.read(iprot)
24601 
        else:
24602 
          iprot.skip(ftype)
24603 
      else:
24604 
        iprot.skip(ftype)
24605 
      iprot.readFieldEnd()
24606 
    iprot.readStructEnd()
24607 
 
24608 
  def write(self, oprot):
24609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24611 
      return
24612 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24613 
    if self.ex is not None:
24614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24615 
      self.ex.write(oprot)
24616 
      oprot.writeFieldEnd()
24617 
    oprot.writeFieldStop()
24618 
    oprot.writeStructEnd()
24619 
 
24620 
  def validate(self):
24621 
    return
24622 
 
24623 
 
24624 
  def __repr__(self):
24625 
    L = ['%s=%r' % (key, value)
24626 
      for key, value in self.__dict__.iteritems()]
24627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24628 
 
24629 
  def __eq__(self, other):
24630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24631 
 
24632 
  def __ne__(self, other):
24633 
    return not (self == other)
24634 
 
24635 
class getEBSSettlementDate_args:
24636 
  """
24637 
  Attributes:
24638 
   - settlementId
24639 
  """
24640 
 
24641 
  thrift_spec = (
24642 
    None, # 0
24643 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24644 
  )
24645 
 
24646 
  def __init__(self, settlementId=None,):
24647 
    self.settlementId = settlementId
24648 
 
24649 
  def read(self, iprot):
24650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24652 
      return
24653 
    iprot.readStructBegin()
24654 
    while True:
24655 
      (fname, ftype, fid) = iprot.readFieldBegin()
24656 
      if ftype == TType.STOP:
24657 
        break
24658 
      if fid == 1:
24659 
        if ftype == TType.I64:
24660 
          self.settlementId = iprot.readI64();
24661 
        else:
24662 
          iprot.skip(ftype)
24663 
      else:
24664 
        iprot.skip(ftype)
24665 
      iprot.readFieldEnd()
24666 
    iprot.readStructEnd()
24667 
 
24668 
  def write(self, oprot):
24669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24671 
      return
24672 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24673 
    if self.settlementId is not None:
24674 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24675 
      oprot.writeI64(self.settlementId)
24676 
      oprot.writeFieldEnd()
24677 
    oprot.writeFieldStop()
24678 
    oprot.writeStructEnd()
24679 
 
24680 
  def validate(self):
24681 
    return
24682 
 
24683 
 
24684 
  def __repr__(self):
24685 
    L = ['%s=%r' % (key, value)
24686 
      for key, value in self.__dict__.iteritems()]
24687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24688 
 
24689 
  def __eq__(self, other):
24690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24691 
 
24692 
  def __ne__(self, other):
24693 
    return not (self == other)
24694 
 
24695 
class getEBSSettlementDate_result:
24696 
  """
24697 
  Attributes:
24698 
   - success
24699 
   - ex
24700 
  """
24701 
 
24702 
  thrift_spec = (
24703 
    (0, TType.I64, 'success', None, None, ), # 0
24704 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24705 
  )
24706 
 
24707 
  def __init__(self, success=None, ex=None,):
24708 
    self.success = success
24709 
    self.ex = ex
24710 
 
24711 
  def read(self, iprot):
24712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24714 
      return
24715 
    iprot.readStructBegin()
24716 
    while True:
24717 
      (fname, ftype, fid) = iprot.readFieldBegin()
24718 
      if ftype == TType.STOP:
24719 
        break
24720 
      if fid == 0:
24721 
        if ftype == TType.I64:
24722 
          self.success = iprot.readI64();
24723 
        else:
24724 
          iprot.skip(ftype)
24725 
      elif fid == 1:
24726 
        if ftype == TType.STRUCT:
24727 
          self.ex = TransactionServiceException()
24728 
          self.ex.read(iprot)
24729 
        else:
24730 
          iprot.skip(ftype)
24731 
      else:
24732 
        iprot.skip(ftype)
24733 
      iprot.readFieldEnd()
24734 
    iprot.readStructEnd()
24735 
 
24736 
  def write(self, oprot):
24737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24739 
      return
24740 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24741 
    if self.success is not None:
24742 
      oprot.writeFieldBegin('success', TType.I64, 0)
24743 
      oprot.writeI64(self.success)
24744 
      oprot.writeFieldEnd()
24745 
    if self.ex is not None:
24746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24747 
      self.ex.write(oprot)
24748 
      oprot.writeFieldEnd()
24749 
    oprot.writeFieldStop()
24750 
    oprot.writeStructEnd()
24751 
 
24752 
  def validate(self):
24753 
    return
24754 
 
24755 
 
24756 
  def __repr__(self):
24757 
    L = ['%s=%r' % (key, value)
24758 
      for key, value in self.__dict__.iteritems()]
24759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24760 
 
24761 
  def __eq__(self, other):
24762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24763 
 
24764 
  def __ne__(self, other):
24765 
    return not (self == other)
4715 varun.gupt 24766 
 
24767 
class getSettlementsByDate_args:
24768 
  """
24769 
  Attributes:
24770 
   - settlementDateFrom
24771 
   - settlementDateTo
24772 
   - isRefund
24773 
  """
24774 
 
24775 
  thrift_spec = (
24776 
    None, # 0
24777 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24778 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24779 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24780 
  )
24781 
 
24782 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24783 
    self.settlementDateFrom = settlementDateFrom
24784 
    self.settlementDateTo = settlementDateTo
24785 
    self.isRefund = isRefund
24786 
 
24787 
  def read(self, iprot):
24788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24790 
      return
24791 
    iprot.readStructBegin()
24792 
    while True:
24793 
      (fname, ftype, fid) = iprot.readFieldBegin()
24794 
      if ftype == TType.STOP:
24795 
        break
24796 
      if fid == 1:
24797 
        if ftype == TType.I64:
24798 
          self.settlementDateFrom = iprot.readI64();
24799 
        else:
24800 
          iprot.skip(ftype)
24801 
      elif fid == 2:
24802 
        if ftype == TType.I64:
24803 
          self.settlementDateTo = iprot.readI64();
24804 
        else:
24805 
          iprot.skip(ftype)
24806 
      elif fid == 3:
24807 
        if ftype == TType.BOOL:
24808 
          self.isRefund = iprot.readBool();
24809 
        else:
24810 
          iprot.skip(ftype)
24811 
      else:
24812 
        iprot.skip(ftype)
24813 
      iprot.readFieldEnd()
24814 
    iprot.readStructEnd()
24815 
 
24816 
  def write(self, oprot):
24817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24819 
      return
24820 
    oprot.writeStructBegin('getSettlementsByDate_args')
24821 
    if self.settlementDateFrom is not None:
24822 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24823 
      oprot.writeI64(self.settlementDateFrom)
24824 
      oprot.writeFieldEnd()
24825 
    if self.settlementDateTo is not None:
24826 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24827 
      oprot.writeI64(self.settlementDateTo)
24828 
      oprot.writeFieldEnd()
24829 
    if self.isRefund is not None:
24830 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24831 
      oprot.writeBool(self.isRefund)
24832 
      oprot.writeFieldEnd()
24833 
    oprot.writeFieldStop()
24834 
    oprot.writeStructEnd()
24835 
 
24836 
  def validate(self):
24837 
    return
24838 
 
24839 
 
24840 
  def __repr__(self):
24841 
    L = ['%s=%r' % (key, value)
24842 
      for key, value in self.__dict__.iteritems()]
24843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24844 
 
24845 
  def __eq__(self, other):
24846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24847 
 
24848 
  def __ne__(self, other):
24849 
    return not (self == other)
24850 
 
24851 
class getSettlementsByDate_result:
24852 
  """
24853 
  Attributes:
24854 
   - success
24855 
   - ex
24856 
  """
24857 
 
24858 
  thrift_spec = (
24859 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24861 
  )
24862 
 
24863 
  def __init__(self, success=None, ex=None,):
24864 
    self.success = success
24865 
    self.ex = ex
24866 
 
24867 
  def read(self, iprot):
24868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24870 
      return
24871 
    iprot.readStructBegin()
24872 
    while True:
24873 
      (fname, ftype, fid) = iprot.readFieldBegin()
24874 
      if ftype == TType.STOP:
24875 
        break
24876 
      if fid == 0:
24877 
        if ftype == TType.LIST:
24878 
          self.success = []
6188 rajveer 24879 
          (_etype566, _size563) = iprot.readListBegin()
24880 
          for _i567 in xrange(_size563):
24881 
            _elem568 = PaymentSettlement()
24882 
            _elem568.read(iprot)
24883 
            self.success.append(_elem568)
4715 varun.gupt 24884 
          iprot.readListEnd()
24885 
        else:
24886 
          iprot.skip(ftype)
24887 
      elif fid == 1:
24888 
        if ftype == TType.STRUCT:
24889 
          self.ex = TransactionServiceException()
24890 
          self.ex.read(iprot)
24891 
        else:
24892 
          iprot.skip(ftype)
24893 
      else:
24894 
        iprot.skip(ftype)
24895 
      iprot.readFieldEnd()
24896 
    iprot.readStructEnd()
24897 
 
24898 
  def write(self, oprot):
24899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24901 
      return
24902 
    oprot.writeStructBegin('getSettlementsByDate_result')
24903 
    if self.success is not None:
24904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24906 
      for iter569 in self.success:
24907 
        iter569.write(oprot)
4715 varun.gupt 24908 
      oprot.writeListEnd()
24909 
      oprot.writeFieldEnd()
24910 
    if self.ex is not None:
24911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24912 
      self.ex.write(oprot)
24913 
      oprot.writeFieldEnd()
24914 
    oprot.writeFieldStop()
24915 
    oprot.writeStructEnd()
24916 
 
24917 
  def validate(self):
24918 
    return
24919 
 
24920 
 
24921 
  def __repr__(self):
24922 
    L = ['%s=%r' % (key, value)
24923 
      for key, value in self.__dict__.iteritems()]
24924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24925 
 
24926 
  def __eq__(self, other):
24927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24928 
 
24929 
  def __ne__(self, other):
24930 
    return not (self == other)
24931 
 
24932 
class getReshippedOrderIds_args:
24933 
  """
24934 
  Attributes:
24935 
   - orderIds
24936 
  """
24937 
 
24938 
  thrift_spec = (
24939 
    None, # 0
24940 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24941 
  )
24942 
 
24943 
  def __init__(self, orderIds=None,):
24944 
    self.orderIds = orderIds
24945 
 
24946 
  def read(self, iprot):
24947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24949 
      return
24950 
    iprot.readStructBegin()
24951 
    while True:
24952 
      (fname, ftype, fid) = iprot.readFieldBegin()
24953 
      if ftype == TType.STOP:
24954 
        break
24955 
      if fid == 1:
24956 
        if ftype == TType.LIST:
24957 
          self.orderIds = []
6188 rajveer 24958 
          (_etype573, _size570) = iprot.readListBegin()
24959 
          for _i574 in xrange(_size570):
24960 
            _elem575 = iprot.readI64();
24961 
            self.orderIds.append(_elem575)
4715 varun.gupt 24962 
          iprot.readListEnd()
24963 
        else:
24964 
          iprot.skip(ftype)
24965 
      else:
24966 
        iprot.skip(ftype)
24967 
      iprot.readFieldEnd()
24968 
    iprot.readStructEnd()
24969 
 
24970 
  def write(self, oprot):
24971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24973 
      return
24974 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24975 
    if self.orderIds is not None:
24976 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24977 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24978 
      for iter576 in self.orderIds:
24979 
        oprot.writeI64(iter576)
4715 varun.gupt 24980 
      oprot.writeListEnd()
24981 
      oprot.writeFieldEnd()
24982 
    oprot.writeFieldStop()
24983 
    oprot.writeStructEnd()
24984 
 
24985 
  def validate(self):
24986 
    return
24987 
 
24988 
 
24989 
  def __repr__(self):
24990 
    L = ['%s=%r' % (key, value)
24991 
      for key, value in self.__dict__.iteritems()]
24992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24993 
 
24994 
  def __eq__(self, other):
24995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24996 
 
24997 
  def __ne__(self, other):
24998 
    return not (self == other)
24999 
 
25000 
class getReshippedOrderIds_result:
25001 
  """
25002 
  Attributes:
25003 
   - success
25004 
   - ex
25005 
  """
25006 
 
25007 
  thrift_spec = (
25008 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25010 
  )
25011 
 
25012 
  def __init__(self, success=None, ex=None,):
25013 
    self.success = success
25014 
    self.ex = ex
25015 
 
25016 
  def read(self, iprot):
25017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25019 
      return
25020 
    iprot.readStructBegin()
25021 
    while True:
25022 
      (fname, ftype, fid) = iprot.readFieldBegin()
25023 
      if ftype == TType.STOP:
25024 
        break
25025 
      if fid == 0:
25026 
        if ftype == TType.LIST:
25027 
          self.success = []
6188 rajveer 25028 
          (_etype580, _size577) = iprot.readListBegin()
25029 
          for _i581 in xrange(_size577):
25030 
            _elem582 = iprot.readI64();
25031 
            self.success.append(_elem582)
4715 varun.gupt 25032 
          iprot.readListEnd()
25033 
        else:
25034 
          iprot.skip(ftype)
25035 
      elif fid == 1:
25036 
        if ftype == TType.STRUCT:
25037 
          self.ex = TransactionServiceException()
25038 
          self.ex.read(iprot)
25039 
        else:
25040 
          iprot.skip(ftype)
25041 
      else:
25042 
        iprot.skip(ftype)
25043 
      iprot.readFieldEnd()
25044 
    iprot.readStructEnd()
25045 
 
25046 
  def write(self, oprot):
25047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25049 
      return
25050 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25051 
    if self.success is not None:
25052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25053 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25054 
      for iter583 in self.success:
25055 
        oprot.writeI64(iter583)
4715 varun.gupt 25056 
      oprot.writeListEnd()
25057 
      oprot.writeFieldEnd()
25058 
    if self.ex is not None:
25059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25060 
      self.ex.write(oprot)
25061 
      oprot.writeFieldEnd()
25062 
    oprot.writeFieldStop()
25063 
    oprot.writeStructEnd()
25064 
 
25065 
  def validate(self):
25066 
    return
25067 
 
25068 
 
25069 
  def __repr__(self):
25070 
    L = ['%s=%r' % (key, value)
25071 
      for key, value in self.__dict__.iteritems()]
25072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25073 
 
25074 
  def __eq__(self, other):
25075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25076 
 
25077 
  def __ne__(self, other):
25078 
    return not (self == other)
4757 mandeep.dh 25079 
 
5481 phani.kuma 25080 
class getBilledOrders_args:
4875 varun.gupt 25081 
  """
25082 
  Attributes:
25083 
   - vendorId
5481 phani.kuma 25084 
   - onlyVendorNotPaid
25085 
   - billingDateFrom
25086 
   - billingDateTo
4875 varun.gupt 25087 
  """
25088 
 
25089 
  thrift_spec = (
25090 
    None, # 0
25091 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25092 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25093 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25094 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25095 
  )
25096 
 
5481 phani.kuma 25097 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25098 
    self.vendorId = vendorId
5481 phani.kuma 25099 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25100 
    self.billingDateFrom = billingDateFrom
25101 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25102 
 
25103 
  def read(self, iprot):
25104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25106 
      return
25107 
    iprot.readStructBegin()
25108 
    while True:
25109 
      (fname, ftype, fid) = iprot.readFieldBegin()
25110 
      if ftype == TType.STOP:
25111 
        break
25112 
      if fid == 1:
25113 
        if ftype == TType.I64:
25114 
          self.vendorId = iprot.readI64();
25115 
        else:
25116 
          iprot.skip(ftype)
5481 phani.kuma 25117 
      elif fid == 2:
25118 
        if ftype == TType.BOOL:
25119 
          self.onlyVendorNotPaid = iprot.readBool();
25120 
        else:
25121 
          iprot.skip(ftype)
25122 
      elif fid == 3:
25123 
        if ftype == TType.I64:
25124 
          self.billingDateFrom = iprot.readI64();
25125 
        else:
25126 
          iprot.skip(ftype)
25127 
      elif fid == 4:
25128 
        if ftype == TType.I64:
25129 
          self.billingDateTo = iprot.readI64();
25130 
        else:
25131 
          iprot.skip(ftype)
4875 varun.gupt 25132 
      else:
25133 
        iprot.skip(ftype)
25134 
      iprot.readFieldEnd()
25135 
    iprot.readStructEnd()
25136 
 
25137 
  def write(self, oprot):
25138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25140 
      return
5481 phani.kuma 25141 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25142 
    if self.vendorId is not None:
25143 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25144 
      oprot.writeI64(self.vendorId)
25145 
      oprot.writeFieldEnd()
5481 phani.kuma 25146 
    if self.onlyVendorNotPaid is not None:
25147 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25148 
      oprot.writeBool(self.onlyVendorNotPaid)
25149 
      oprot.writeFieldEnd()
25150 
    if self.billingDateFrom is not None:
25151 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25152 
      oprot.writeI64(self.billingDateFrom)
25153 
      oprot.writeFieldEnd()
25154 
    if self.billingDateTo is not None:
25155 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25156 
      oprot.writeI64(self.billingDateTo)
25157 
      oprot.writeFieldEnd()
4875 varun.gupt 25158 
    oprot.writeFieldStop()
25159 
    oprot.writeStructEnd()
25160 
 
25161 
  def validate(self):
25162 
    return
25163 
 
25164 
 
25165 
  def __repr__(self):
25166 
    L = ['%s=%r' % (key, value)
25167 
      for key, value in self.__dict__.iteritems()]
25168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25169 
 
25170 
  def __eq__(self, other):
25171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25172 
 
25173 
  def __ne__(self, other):
25174 
    return not (self == other)
25175 
 
5481 phani.kuma 25176 
class getBilledOrders_result:
4875 varun.gupt 25177 
  """
25178 
  Attributes:
25179 
   - success
25180 
   - ex
25181 
  """
25182 
 
25183 
  thrift_spec = (
25184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25186 
  )
25187 
 
25188 
  def __init__(self, success=None, ex=None,):
25189 
    self.success = success
25190 
    self.ex = ex
25191 
 
25192 
  def read(self, iprot):
25193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25195 
      return
25196 
    iprot.readStructBegin()
25197 
    while True:
25198 
      (fname, ftype, fid) = iprot.readFieldBegin()
25199 
      if ftype == TType.STOP:
25200 
        break
25201 
      if fid == 0:
25202 
        if ftype == TType.LIST:
25203 
          self.success = []
6188 rajveer 25204 
          (_etype587, _size584) = iprot.readListBegin()
25205 
          for _i588 in xrange(_size584):
25206 
            _elem589 = Order()
25207 
            _elem589.read(iprot)
25208 
            self.success.append(_elem589)
4875 varun.gupt 25209 
          iprot.readListEnd()
25210 
        else:
25211 
          iprot.skip(ftype)
25212 
      elif fid == 1:
25213 
        if ftype == TType.STRUCT:
25214 
          self.ex = TransactionServiceException()
25215 
          self.ex.read(iprot)
25216 
        else:
25217 
          iprot.skip(ftype)
25218 
      else:
25219 
        iprot.skip(ftype)
25220 
      iprot.readFieldEnd()
25221 
    iprot.readStructEnd()
25222 
 
25223 
  def write(self, oprot):
25224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25226 
      return
5481 phani.kuma 25227 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25228 
    if self.success is not None:
25229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25231 
      for iter590 in self.success:
25232 
        iter590.write(oprot)
4875 varun.gupt 25233 
      oprot.writeListEnd()
25234 
      oprot.writeFieldEnd()
25235 
    if self.ex is not None:
25236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25237 
      self.ex.write(oprot)
25238 
      oprot.writeFieldEnd()
25239 
    oprot.writeFieldStop()
25240 
    oprot.writeStructEnd()
25241 
 
25242 
  def validate(self):
25243 
    return
25244 
 
25245 
 
25246 
  def __repr__(self):
25247 
    L = ['%s=%r' % (key, value)
25248 
      for key, value in self.__dict__.iteritems()]
25249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25250 
 
25251 
  def __eq__(self, other):
25252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25253 
 
25254 
  def __ne__(self, other):
25255 
    return not (self == other)
5031 varun.gupt 25256 
 
25257 
class getStatusDistributionOfOrders_args:
25258 
  """
25259 
  Attributes:
25260 
   - startDate
25261 
   - endDate
25262 
  """
25263 
 
25264 
  thrift_spec = (
25265 
    None, # 0
25266 
    (1, TType.I64, 'startDate', None, None, ), # 1
25267 
    (2, TType.I64, 'endDate', None, None, ), # 2
25268 
  )
25269 
 
25270 
  def __init__(self, startDate=None, endDate=None,):
25271 
    self.startDate = startDate
25272 
    self.endDate = endDate
25273 
 
25274 
  def read(self, iprot):
25275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25277 
      return
25278 
    iprot.readStructBegin()
25279 
    while True:
25280 
      (fname, ftype, fid) = iprot.readFieldBegin()
25281 
      if ftype == TType.STOP:
25282 
        break
25283 
      if fid == 1:
25284 
        if ftype == TType.I64:
25285 
          self.startDate = iprot.readI64();
25286 
        else:
25287 
          iprot.skip(ftype)
25288 
      elif fid == 2:
25289 
        if ftype == TType.I64:
25290 
          self.endDate = iprot.readI64();
25291 
        else:
25292 
          iprot.skip(ftype)
25293 
      else:
25294 
        iprot.skip(ftype)
25295 
      iprot.readFieldEnd()
25296 
    iprot.readStructEnd()
25297 
 
25298 
  def write(self, oprot):
25299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25301 
      return
25302 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25303 
    if self.startDate is not None:
25304 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25305 
      oprot.writeI64(self.startDate)
25306 
      oprot.writeFieldEnd()
25307 
    if self.endDate is not None:
25308 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25309 
      oprot.writeI64(self.endDate)
25310 
      oprot.writeFieldEnd()
25311 
    oprot.writeFieldStop()
25312 
    oprot.writeStructEnd()
25313 
 
25314 
  def validate(self):
25315 
    return
25316 
 
25317 
 
25318 
  def __repr__(self):
25319 
    L = ['%s=%r' % (key, value)
25320 
      for key, value in self.__dict__.iteritems()]
25321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25322 
 
25323 
  def __eq__(self, other):
25324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25325 
 
25326 
  def __ne__(self, other):
25327 
    return not (self == other)
25328 
 
25329 
class getStatusDistributionOfOrders_result:
25330 
  """
25331 
  Attributes:
25332 
   - success
25333 
   - ex
25334 
  """
25335 
 
25336 
  thrift_spec = (
25337 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25339 
  )
25340 
 
25341 
  def __init__(self, success=None, ex=None,):
25342 
    self.success = success
25343 
    self.ex = ex
25344 
 
25345 
  def read(self, iprot):
25346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25348 
      return
25349 
    iprot.readStructBegin()
25350 
    while True:
25351 
      (fname, ftype, fid) = iprot.readFieldBegin()
25352 
      if ftype == TType.STOP:
25353 
        break
25354 
      if fid == 0:
25355 
        if ftype == TType.MAP:
25356 
          self.success = {}
6188 rajveer 25357 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25358 
          for _i595 in xrange(_size591):
25359 
            _key596 = iprot.readI64();
25360 
            _val597 = iprot.readI64();
25361 
            self.success[_key596] = _val597
5031 varun.gupt 25362 
          iprot.readMapEnd()
25363 
        else:
25364 
          iprot.skip(ftype)
25365 
      elif fid == 1:
25366 
        if ftype == TType.STRUCT:
25367 
          self.ex = TransactionServiceException()
25368 
          self.ex.read(iprot)
25369 
        else:
25370 
          iprot.skip(ftype)
25371 
      else:
25372 
        iprot.skip(ftype)
25373 
      iprot.readFieldEnd()
25374 
    iprot.readStructEnd()
25375 
 
25376 
  def write(self, oprot):
25377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25379 
      return
25380 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25381 
    if self.success is not None:
25382 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25383 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25384 
      for kiter598,viter599 in self.success.items():
25385 
        oprot.writeI64(kiter598)
25386 
        oprot.writeI64(viter599)
5031 varun.gupt 25387 
      oprot.writeMapEnd()
25388 
      oprot.writeFieldEnd()
25389 
    if self.ex is not None:
25390 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25391 
      self.ex.write(oprot)
25392 
      oprot.writeFieldEnd()
25393 
    oprot.writeFieldStop()
25394 
    oprot.writeStructEnd()
25395 
 
25396 
  def validate(self):
25397 
    return
25398 
 
25399 
 
25400 
  def __repr__(self):
25401 
    L = ['%s=%r' % (key, value)
25402 
      for key, value in self.__dict__.iteritems()]
25403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25404 
 
25405 
  def __eq__(self, other):
25406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25407 
 
25408 
  def __ne__(self, other):
25409 
    return not (self == other)
5067 varun.gupt 25410 
 
25411 
class getOrderIdsForStatus_args:
25412 
  """
25413 
  Attributes:
25414 
   - status
25415 
   - startDatetime
25416 
   - endDatetime
25417 
  """
25418 
 
25419 
  thrift_spec = (
25420 
    None, # 0
25421 
    (1, TType.I64, 'status', None, None, ), # 1
25422 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25423 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25424 
  )
25425 
 
25426 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25427 
    self.status = status
25428 
    self.startDatetime = startDatetime
25429 
    self.endDatetime = endDatetime
25430 
 
25431 
  def read(self, iprot):
25432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25434 
      return
25435 
    iprot.readStructBegin()
25436 
    while True:
25437 
      (fname, ftype, fid) = iprot.readFieldBegin()
25438 
      if ftype == TType.STOP:
25439 
        break
25440 
      if fid == 1:
25441 
        if ftype == TType.I64:
25442 
          self.status = iprot.readI64();
25443 
        else:
25444 
          iprot.skip(ftype)
25445 
      elif fid == 2:
25446 
        if ftype == TType.I64:
25447 
          self.startDatetime = iprot.readI64();
25448 
        else:
25449 
          iprot.skip(ftype)
25450 
      elif fid == 3:
25451 
        if ftype == TType.I64:
25452 
          self.endDatetime = iprot.readI64();
25453 
        else:
25454 
          iprot.skip(ftype)
25455 
      else:
25456 
        iprot.skip(ftype)
25457 
      iprot.readFieldEnd()
25458 
    iprot.readStructEnd()
25459 
 
25460 
  def write(self, oprot):
25461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25463 
      return
25464 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25465 
    if self.status is not None:
25466 
      oprot.writeFieldBegin('status', TType.I64, 1)
25467 
      oprot.writeI64(self.status)
25468 
      oprot.writeFieldEnd()
25469 
    if self.startDatetime is not None:
25470 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25471 
      oprot.writeI64(self.startDatetime)
25472 
      oprot.writeFieldEnd()
25473 
    if self.endDatetime is not None:
25474 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25475 
      oprot.writeI64(self.endDatetime)
25476 
      oprot.writeFieldEnd()
25477 
    oprot.writeFieldStop()
25478 
    oprot.writeStructEnd()
25479 
 
25480 
  def validate(self):
25481 
    return
25482 
 
25483 
 
25484 
  def __repr__(self):
25485 
    L = ['%s=%r' % (key, value)
25486 
      for key, value in self.__dict__.iteritems()]
25487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25488 
 
25489 
  def __eq__(self, other):
25490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25491 
 
25492 
  def __ne__(self, other):
25493 
    return not (self == other)
25494 
 
25495 
class getOrderIdsForStatus_result:
25496 
  """
25497 
  Attributes:
25498 
   - success
25499 
   - ex
25500 
  """
25501 
 
25502 
  thrift_spec = (
25503 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25505 
  )
25506 
 
25507 
  def __init__(self, success=None, ex=None,):
25508 
    self.success = success
25509 
    self.ex = ex
25510 
 
25511 
  def read(self, iprot):
25512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25514 
      return
25515 
    iprot.readStructBegin()
25516 
    while True:
25517 
      (fname, ftype, fid) = iprot.readFieldBegin()
25518 
      if ftype == TType.STOP:
25519 
        break
25520 
      if fid == 0:
25521 
        if ftype == TType.LIST:
25522 
          self.success = []
6188 rajveer 25523 
          (_etype603, _size600) = iprot.readListBegin()
25524 
          for _i604 in xrange(_size600):
25525 
            _elem605 = iprot.readI64();
25526 
            self.success.append(_elem605)
5067 varun.gupt 25527 
          iprot.readListEnd()
25528 
        else:
25529 
          iprot.skip(ftype)
25530 
      elif fid == 1:
25531 
        if ftype == TType.STRUCT:
25532 
          self.ex = TransactionServiceException()
25533 
          self.ex.read(iprot)
25534 
        else:
25535 
          iprot.skip(ftype)
25536 
      else:
25537 
        iprot.skip(ftype)
25538 
      iprot.readFieldEnd()
25539 
    iprot.readStructEnd()
25540 
 
25541 
  def write(self, oprot):
25542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25544 
      return
25545 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25546 
    if self.success is not None:
25547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25548 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25549 
      for iter606 in self.success:
25550 
        oprot.writeI64(iter606)
5067 varun.gupt 25551 
      oprot.writeListEnd()
25552 
      oprot.writeFieldEnd()
25553 
    if self.ex is not None:
25554 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25555 
      self.ex.write(oprot)
25556 
      oprot.writeFieldEnd()
25557 
    oprot.writeFieldStop()
25558 
    oprot.writeStructEnd()
25559 
 
25560 
  def validate(self):
25561 
    return
25562 
 
25563 
 
25564 
  def __repr__(self):
25565 
    L = ['%s=%r' % (key, value)
25566 
      for key, value in self.__dict__.iteritems()]
25567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25568 
 
25569 
  def __eq__(self, other):
25570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25571 
 
25572 
  def __ne__(self, other):
25573 
    return not (self == other)
5099 varun.gupt 25574 
 
5348 anupam.sin 25575 
class updateCODAgent_args:
25576 
  """
25577 
  Attributes:
25578 
   - agent
25579 
   - orderId
25580 
  """
25581 
 
25582 
  thrift_spec = (
25583 
    None, # 0
25584 
    (1, TType.STRING, 'agent', None, None, ), # 1
25585 
    (2, TType.I64, 'orderId', None, None, ), # 2
25586 
  )
25587 
 
25588 
  def __init__(self, agent=None, orderId=None,):
25589 
    self.agent = agent
25590 
    self.orderId = orderId
25591 
 
25592 
  def read(self, iprot):
25593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25595 
      return
25596 
    iprot.readStructBegin()
25597 
    while True:
25598 
      (fname, ftype, fid) = iprot.readFieldBegin()
25599 
      if ftype == TType.STOP:
25600 
        break
25601 
      if fid == 1:
25602 
        if ftype == TType.STRING:
25603 
          self.agent = iprot.readString();
25604 
        else:
25605 
          iprot.skip(ftype)
25606 
      elif fid == 2:
25607 
        if ftype == TType.I64:
25608 
          self.orderId = iprot.readI64();
25609 
        else:
25610 
          iprot.skip(ftype)
25611 
      else:
25612 
        iprot.skip(ftype)
25613 
      iprot.readFieldEnd()
25614 
    iprot.readStructEnd()
25615 
 
25616 
  def write(self, oprot):
25617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25619 
      return
25620 
    oprot.writeStructBegin('updateCODAgent_args')
25621 
    if self.agent is not None:
25622 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25623 
      oprot.writeString(self.agent)
25624 
      oprot.writeFieldEnd()
25625 
    if self.orderId is not None:
25626 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25627 
      oprot.writeI64(self.orderId)
25628 
      oprot.writeFieldEnd()
25629 
    oprot.writeFieldStop()
25630 
    oprot.writeStructEnd()
25631 
 
25632 
  def validate(self):
25633 
    return
25634 
 
25635 
 
25636 
  def __repr__(self):
25637 
    L = ['%s=%r' % (key, value)
25638 
      for key, value in self.__dict__.iteritems()]
25639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25640 
 
25641 
  def __eq__(self, other):
25642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25643 
 
25644 
  def __ne__(self, other):
25645 
    return not (self == other)
25646 
 
25647 
class updateCODAgent_result:
25648 
  """
25649 
  Attributes:
25650 
   - ex
25651 
  """
25652 
 
25653 
  thrift_spec = (
25654 
    None, # 0
25655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25656 
  )
25657 
 
25658 
  def __init__(self, ex=None,):
25659 
    self.ex = ex
25660 
 
25661 
  def read(self, iprot):
25662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25664 
      return
25665 
    iprot.readStructBegin()
25666 
    while True:
25667 
      (fname, ftype, fid) = iprot.readFieldBegin()
25668 
      if ftype == TType.STOP:
25669 
        break
25670 
      if fid == 1:
25671 
        if ftype == TType.STRUCT:
25672 
          self.ex = TransactionServiceException()
25673 
          self.ex.read(iprot)
25674 
        else:
25675 
          iprot.skip(ftype)
25676 
      else:
25677 
        iprot.skip(ftype)
25678 
      iprot.readFieldEnd()
25679 
    iprot.readStructEnd()
25680 
 
25681 
  def write(self, oprot):
25682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25684 
      return
25685 
    oprot.writeStructBegin('updateCODAgent_result')
25686 
    if self.ex is not None:
25687 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25688 
      self.ex.write(oprot)
25689 
      oprot.writeFieldEnd()
25690 
    oprot.writeFieldStop()
25691 
    oprot.writeStructEnd()
25692 
 
25693 
  def validate(self):
25694 
    return
25695 
 
25696 
 
25697 
  def __repr__(self):
25698 
    L = ['%s=%r' % (key, value)
25699 
      for key, value in self.__dict__.iteritems()]
25700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25701 
 
25702 
  def __eq__(self, other):
25703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25704 
 
25705 
  def __ne__(self, other):
25706 
    return not (self == other)
25707 
 
5099 varun.gupt 25708 
class updateOrderAsPaidToVendor_args:
25709 
  """
25710 
  Attributes:
25711 
   - orderId
25712 
  """
25713 
 
25714 
  thrift_spec = (
25715 
    None, # 0
25716 
    (1, TType.I64, 'orderId', None, None, ), # 1
25717 
  )
25718 
 
25719 
  def __init__(self, orderId=None,):
25720 
    self.orderId = orderId
25721 
 
25722 
  def read(self, iprot):
25723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25725 
      return
25726 
    iprot.readStructBegin()
25727 
    while True:
25728 
      (fname, ftype, fid) = iprot.readFieldBegin()
25729 
      if ftype == TType.STOP:
25730 
        break
25731 
      if fid == 1:
25732 
        if ftype == TType.I64:
25733 
          self.orderId = iprot.readI64();
25734 
        else:
25735 
          iprot.skip(ftype)
25736 
      else:
25737 
        iprot.skip(ftype)
25738 
      iprot.readFieldEnd()
25739 
    iprot.readStructEnd()
25740 
 
25741 
  def write(self, oprot):
25742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25744 
      return
25745 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25746 
    if self.orderId is not None:
25747 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25748 
      oprot.writeI64(self.orderId)
25749 
      oprot.writeFieldEnd()
25750 
    oprot.writeFieldStop()
25751 
    oprot.writeStructEnd()
25752 
 
25753 
  def validate(self):
25754 
    return
25755 
 
25756 
 
25757 
  def __repr__(self):
25758 
    L = ['%s=%r' % (key, value)
25759 
      for key, value in self.__dict__.iteritems()]
25760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25761 
 
25762 
  def __eq__(self, other):
25763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25764 
 
25765 
  def __ne__(self, other):
25766 
    return not (self == other)
25767 
 
25768 
class updateOrderAsPaidToVendor_result:
25769 
  """
25770 
  Attributes:
25771 
   - ex
25772 
  """
25773 
 
25774 
  thrift_spec = (
25775 
    None, # 0
25776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25777 
  )
25778 
 
25779 
  def __init__(self, ex=None,):
25780 
    self.ex = ex
25781 
 
25782 
  def read(self, iprot):
25783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25785 
      return
25786 
    iprot.readStructBegin()
25787 
    while True:
25788 
      (fname, ftype, fid) = iprot.readFieldBegin()
25789 
      if ftype == TType.STOP:
25790 
        break
25791 
      if fid == 1:
25792 
        if ftype == TType.STRUCT:
25793 
          self.ex = TransactionServiceException()
25794 
          self.ex.read(iprot)
25795 
        else:
25796 
          iprot.skip(ftype)
25797 
      else:
25798 
        iprot.skip(ftype)
25799 
      iprot.readFieldEnd()
25800 
    iprot.readStructEnd()
25801 
 
25802 
  def write(self, oprot):
25803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25805 
      return
25806 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25807 
    if self.ex is not None:
25808 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25809 
      self.ex.write(oprot)
25810 
      oprot.writeFieldEnd()
25811 
    oprot.writeFieldStop()
25812 
    oprot.writeStructEnd()
25813 
 
25814 
  def validate(self):
25815 
    return
25816 
 
25817 
 
25818 
  def __repr__(self):
25819 
    L = ['%s=%r' % (key, value)
25820 
      for key, value in self.__dict__.iteritems()]
25821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25822 
 
25823 
  def __eq__(self, other):
25824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25825 
 
25826 
  def __ne__(self, other):
25827 
    return not (self == other)
5208 varun.gupt 25828 
 
5386 phani.kuma 25829 
class updateOrderOnlyAsPaidToVendor_args:
25830 
  """
25831 
  Attributes:
25832 
   - orderId
25833 
  """
25834 
 
25835 
  thrift_spec = (
25836 
    None, # 0
25837 
    (1, TType.I64, 'orderId', None, None, ), # 1
25838 
  )
25839 
 
25840 
  def __init__(self, orderId=None,):
25841 
    self.orderId = orderId
25842 
 
25843 
  def read(self, iprot):
25844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25846 
      return
25847 
    iprot.readStructBegin()
25848 
    while True:
25849 
      (fname, ftype, fid) = iprot.readFieldBegin()
25850 
      if ftype == TType.STOP:
25851 
        break
25852 
      if fid == 1:
25853 
        if ftype == TType.I64:
25854 
          self.orderId = iprot.readI64();
25855 
        else:
25856 
          iprot.skip(ftype)
25857 
      else:
25858 
        iprot.skip(ftype)
25859 
      iprot.readFieldEnd()
25860 
    iprot.readStructEnd()
25861 
 
25862 
  def write(self, oprot):
25863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25865 
      return
25866 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25867 
    if self.orderId is not None:
25868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25869 
      oprot.writeI64(self.orderId)
25870 
      oprot.writeFieldEnd()
25871 
    oprot.writeFieldStop()
25872 
    oprot.writeStructEnd()
25873 
 
25874 
  def validate(self):
25875 
    return
25876 
 
25877 
 
25878 
  def __repr__(self):
25879 
    L = ['%s=%r' % (key, value)
25880 
      for key, value in self.__dict__.iteritems()]
25881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25882 
 
25883 
  def __eq__(self, other):
25884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25885 
 
25886 
  def __ne__(self, other):
25887 
    return not (self == other)
25888 
 
25889 
class updateOrderOnlyAsPaidToVendor_result:
25890 
  """
25891 
  Attributes:
25892 
   - ex
25893 
  """
25894 
 
25895 
  thrift_spec = (
25896 
    None, # 0
25897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25898 
  )
25899 
 
25900 
  def __init__(self, ex=None,):
25901 
    self.ex = ex
25902 
 
25903 
  def read(self, iprot):
25904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25906 
      return
25907 
    iprot.readStructBegin()
25908 
    while True:
25909 
      (fname, ftype, fid) = iprot.readFieldBegin()
25910 
      if ftype == TType.STOP:
25911 
        break
25912 
      if fid == 1:
25913 
        if ftype == TType.STRUCT:
25914 
          self.ex = TransactionServiceException()
25915 
          self.ex.read(iprot)
25916 
        else:
25917 
          iprot.skip(ftype)
25918 
      else:
25919 
        iprot.skip(ftype)
25920 
      iprot.readFieldEnd()
25921 
    iprot.readStructEnd()
25922 
 
25923 
  def write(self, oprot):
25924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25926 
      return
25927 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25928 
    if self.ex is not None:
25929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25930 
      self.ex.write(oprot)
25931 
      oprot.writeFieldEnd()
25932 
    oprot.writeFieldStop()
25933 
    oprot.writeStructEnd()
25934 
 
25935 
  def validate(self):
25936 
    return
25937 
 
25938 
 
25939 
  def __repr__(self):
25940 
    L = ['%s=%r' % (key, value)
25941 
      for key, value in self.__dict__.iteritems()]
25942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25943 
 
25944 
  def __eq__(self, other):
25945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25946 
 
25947 
  def __ne__(self, other):
25948 
    return not (self == other)
25949 
 
5208 varun.gupt 25950 
class getRefundedOrdersMarkedPaid_args:
25951 
 
25952 
  thrift_spec = (
25953 
  )
25954 
 
25955 
  def read(self, iprot):
25956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25958 
      return
25959 
    iprot.readStructBegin()
25960 
    while True:
25961 
      (fname, ftype, fid) = iprot.readFieldBegin()
25962 
      if ftype == TType.STOP:
25963 
        break
25964 
      else:
25965 
        iprot.skip(ftype)
25966 
      iprot.readFieldEnd()
25967 
    iprot.readStructEnd()
25968 
 
25969 
  def write(self, oprot):
25970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25972 
      return
25973 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25974 
    oprot.writeFieldStop()
25975 
    oprot.writeStructEnd()
25976 
 
25977 
  def validate(self):
25978 
    return
25979 
 
25980 
 
25981 
  def __repr__(self):
25982 
    L = ['%s=%r' % (key, value)
25983 
      for key, value in self.__dict__.iteritems()]
25984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25985 
 
25986 
  def __eq__(self, other):
25987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25988 
 
25989 
  def __ne__(self, other):
25990 
    return not (self == other)
25991 
 
25992 
class getRefundedOrdersMarkedPaid_result:
25993 
  """
25994 
  Attributes:
25995 
   - success
25996 
   - ex
25997 
  """
25998 
 
25999 
  thrift_spec = (
26000 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26001 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26002 
  )
26003 
 
26004 
  def __init__(self, success=None, ex=None,):
26005 
    self.success = success
26006 
    self.ex = ex
26007 
 
26008 
  def read(self, iprot):
26009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26011 
      return
26012 
    iprot.readStructBegin()
26013 
    while True:
26014 
      (fname, ftype, fid) = iprot.readFieldBegin()
26015 
      if ftype == TType.STOP:
26016 
        break
26017 
      if fid == 0:
26018 
        if ftype == TType.LIST:
26019 
          self.success = []
6188 rajveer 26020 
          (_etype610, _size607) = iprot.readListBegin()
26021 
          for _i611 in xrange(_size607):
26022 
            _elem612 = Order()
26023 
            _elem612.read(iprot)
26024 
            self.success.append(_elem612)
5208 varun.gupt 26025 
          iprot.readListEnd()
26026 
        else:
26027 
          iprot.skip(ftype)
26028 
      elif fid == 1:
26029 
        if ftype == TType.STRUCT:
26030 
          self.ex = TransactionServiceException()
26031 
          self.ex.read(iprot)
26032 
        else:
26033 
          iprot.skip(ftype)
26034 
      else:
26035 
        iprot.skip(ftype)
26036 
      iprot.readFieldEnd()
26037 
    iprot.readStructEnd()
26038 
 
26039 
  def write(self, oprot):
26040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26042 
      return
26043 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26044 
    if self.success is not None:
26045 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26046 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26047 
      for iter613 in self.success:
26048 
        iter613.write(oprot)
5208 varun.gupt 26049 
      oprot.writeListEnd()
26050 
      oprot.writeFieldEnd()
26051 
    if self.ex is not None:
26052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26053 
      self.ex.write(oprot)
26054 
      oprot.writeFieldEnd()
26055 
    oprot.writeFieldStop()
26056 
    oprot.writeStructEnd()
26057 
 
26058 
  def validate(self):
26059 
    return
26060 
 
26061 
 
26062 
  def __repr__(self):
26063 
    L = ['%s=%r' % (key, value)
26064 
      for key, value in self.__dict__.iteritems()]
26065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26066 
 
26067 
  def __eq__(self, other):
26068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26069 
 
26070 
  def __ne__(self, other):
26071 
    return not (self == other)
5447 anupam.sin 26072 
 
26073 
class getAllVerificationAgents_args:
26074 
  """
26075 
  Attributes:
26076 
   - minOrderId
26077 
   - maxOrderId
26078 
  """
26079 
 
26080 
  thrift_spec = (
26081 
    None, # 0
26082 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26083 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26084 
  )
26085 
 
26086 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26087 
    self.minOrderId = minOrderId
26088 
    self.maxOrderId = maxOrderId
26089 
 
26090 
  def read(self, iprot):
26091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26093 
      return
26094 
    iprot.readStructBegin()
26095 
    while True:
26096 
      (fname, ftype, fid) = iprot.readFieldBegin()
26097 
      if ftype == TType.STOP:
26098 
        break
26099 
      if fid == 1:
26100 
        if ftype == TType.I64:
26101 
          self.minOrderId = iprot.readI64();
26102 
        else:
26103 
          iprot.skip(ftype)
26104 
      elif fid == 2:
26105 
        if ftype == TType.I64:
26106 
          self.maxOrderId = iprot.readI64();
26107 
        else:
26108 
          iprot.skip(ftype)
26109 
      else:
26110 
        iprot.skip(ftype)
26111 
      iprot.readFieldEnd()
26112 
    iprot.readStructEnd()
26113 
 
26114 
  def write(self, oprot):
26115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26117 
      return
26118 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26119 
    if self.minOrderId is not None:
26120 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26121 
      oprot.writeI64(self.minOrderId)
26122 
      oprot.writeFieldEnd()
26123 
    if self.maxOrderId is not None:
26124 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26125 
      oprot.writeI64(self.maxOrderId)
26126 
      oprot.writeFieldEnd()
26127 
    oprot.writeFieldStop()
26128 
    oprot.writeStructEnd()
26129 
 
26130 
  def validate(self):
26131 
    return
26132 
 
26133 
 
26134 
  def __repr__(self):
26135 
    L = ['%s=%r' % (key, value)
26136 
      for key, value in self.__dict__.iteritems()]
26137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26138 
 
26139 
  def __eq__(self, other):
26140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26141 
 
26142 
  def __ne__(self, other):
26143 
    return not (self == other)
26144 
 
26145 
class getAllVerificationAgents_result:
26146 
  """
26147 
  Attributes:
26148 
   - success
26149 
  """
26150 
 
26151 
  thrift_spec = (
26152 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26153 
  )
26154 
 
26155 
  def __init__(self, success=None,):
26156 
    self.success = success
26157 
 
26158 
  def read(self, iprot):
26159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26161 
      return
26162 
    iprot.readStructBegin()
26163 
    while True:
26164 
      (fname, ftype, fid) = iprot.readFieldBegin()
26165 
      if ftype == TType.STOP:
26166 
        break
26167 
      if fid == 0:
26168 
        if ftype == TType.LIST:
26169 
          self.success = []
6188 rajveer 26170 
          (_etype617, _size614) = iprot.readListBegin()
26171 
          for _i618 in xrange(_size614):
26172 
            _elem619 = CODVerificationAgent()
26173 
            _elem619.read(iprot)
26174 
            self.success.append(_elem619)
5447 anupam.sin 26175 
          iprot.readListEnd()
26176 
        else:
26177 
          iprot.skip(ftype)
26178 
      else:
26179 
        iprot.skip(ftype)
26180 
      iprot.readFieldEnd()
26181 
    iprot.readStructEnd()
26182 
 
26183 
  def write(self, oprot):
26184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26186 
      return
26187 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26188 
    if self.success is not None:
26189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26191 
      for iter620 in self.success:
26192 
        iter620.write(oprot)
5447 anupam.sin 26193 
      oprot.writeListEnd()
26194 
      oprot.writeFieldEnd()
26195 
    oprot.writeFieldStop()
26196 
    oprot.writeStructEnd()
26197 
 
26198 
  def validate(self):
26199 
    return
26200 
 
26201 
 
26202 
  def __repr__(self):
26203 
    L = ['%s=%r' % (key, value)
26204 
      for key, value in self.__dict__.iteritems()]
26205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26206 
 
26207 
  def __eq__(self, other):
26208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26209 
 
26210 
  def __ne__(self, other):
26211 
    return not (self == other)
5527 anupam.sin 26212 
 
26213 
class getAllAttributesForOrderId_args:
26214 
  """
26215 
  Attributes:
26216 
   - orderId
26217 
  """
26218 
 
26219 
  thrift_spec = (
26220 
    None, # 0
26221 
    (1, TType.I64, 'orderId', None, None, ), # 1
26222 
  )
26223 
 
26224 
  def __init__(self, orderId=None,):
26225 
    self.orderId = orderId
26226 
 
26227 
  def read(self, iprot):
26228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26230 
      return
26231 
    iprot.readStructBegin()
26232 
    while True:
26233 
      (fname, ftype, fid) = iprot.readFieldBegin()
26234 
      if ftype == TType.STOP:
26235 
        break
26236 
      if fid == 1:
26237 
        if ftype == TType.I64:
26238 
          self.orderId = iprot.readI64();
26239 
        else:
26240 
          iprot.skip(ftype)
26241 
      else:
26242 
        iprot.skip(ftype)
26243 
      iprot.readFieldEnd()
26244 
    iprot.readStructEnd()
26245 
 
26246 
  def write(self, oprot):
26247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26249 
      return
26250 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26251 
    if self.orderId is not None:
26252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26253 
      oprot.writeI64(self.orderId)
26254 
      oprot.writeFieldEnd()
26255 
    oprot.writeFieldStop()
26256 
    oprot.writeStructEnd()
26257 
 
26258 
  def validate(self):
26259 
    return
26260 
 
26261 
 
26262 
  def __repr__(self):
26263 
    L = ['%s=%r' % (key, value)
26264 
      for key, value in self.__dict__.iteritems()]
26265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26266 
 
26267 
  def __eq__(self, other):
26268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26269 
 
26270 
  def __ne__(self, other):
26271 
    return not (self == other)
26272 
 
26273 
class getAllAttributesForOrderId_result:
26274 
  """
26275 
  Attributes:
26276 
   - success
26277 
  """
26278 
 
26279 
  thrift_spec = (
26280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26281 
  )
26282 
 
26283 
  def __init__(self, success=None,):
26284 
    self.success = success
26285 
 
26286 
  def read(self, iprot):
26287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26289 
      return
26290 
    iprot.readStructBegin()
26291 
    while True:
26292 
      (fname, ftype, fid) = iprot.readFieldBegin()
26293 
      if ftype == TType.STOP:
26294 
        break
26295 
      if fid == 0:
26296 
        if ftype == TType.LIST:
26297 
          self.success = []
6188 rajveer 26298 
          (_etype624, _size621) = iprot.readListBegin()
26299 
          for _i625 in xrange(_size621):
26300 
            _elem626 = Attribute()
26301 
            _elem626.read(iprot)
26302 
            self.success.append(_elem626)
5527 anupam.sin 26303 
          iprot.readListEnd()
26304 
        else:
26305 
          iprot.skip(ftype)
26306 
      else:
26307 
        iprot.skip(ftype)
26308 
      iprot.readFieldEnd()
26309 
    iprot.readStructEnd()
26310 
 
26311 
  def write(self, oprot):
26312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26314 
      return
26315 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26316 
    if self.success is not None:
26317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26319 
      for iter627 in self.success:
26320 
        iter627.write(oprot)
5527 anupam.sin 26321 
      oprot.writeListEnd()
26322 
      oprot.writeFieldEnd()
26323 
    oprot.writeFieldStop()
26324 
    oprot.writeStructEnd()
26325 
 
26326 
  def validate(self):
26327 
    return
26328 
 
26329 
 
26330 
  def __repr__(self):
26331 
    L = ['%s=%r' % (key, value)
26332 
      for key, value in self.__dict__.iteritems()]
26333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26334 
 
26335 
  def __eq__(self, other):
26336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26337 
 
26338 
  def __ne__(self, other):
26339 
    return not (self == other)
26340 
 
5676 rajveer 26341 
class setOrderAttributes_args:
26342 
  """
26343 
  Attributes:
26344 
   - orderId
26345 
   - attributes
26346 
  """
26347 
 
26348 
  thrift_spec = None
26349 
  def __init__(self, orderId=None, attributes=None,):
26350 
    self.orderId = orderId
26351 
    self.attributes = attributes
26352 
 
26353 
  def read(self, iprot):
26354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26356 
      return
26357 
    iprot.readStructBegin()
26358 
    while True:
26359 
      (fname, ftype, fid) = iprot.readFieldBegin()
26360 
      if ftype == TType.STOP:
26361 
        break
26362 
      if fid == 1:
26363 
        if ftype == TType.I64:
26364 
          self.orderId = iprot.readI64();
26365 
        else:
26366 
          iprot.skip(ftype)
26367 
      elif fid == -1:
26368 
        if ftype == TType.LIST:
26369 
          self.attributes = []
6188 rajveer 26370 
          (_etype631, _size628) = iprot.readListBegin()
26371 
          for _i632 in xrange(_size628):
26372 
            _elem633 = Attribute()
26373 
            _elem633.read(iprot)
26374 
            self.attributes.append(_elem633)
5676 rajveer 26375 
          iprot.readListEnd()
26376 
        else:
26377 
          iprot.skip(ftype)
26378 
      else:
26379 
        iprot.skip(ftype)
26380 
      iprot.readFieldEnd()
26381 
    iprot.readStructEnd()
26382 
 
26383 
  def write(self, oprot):
26384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26386 
      return
26387 
    oprot.writeStructBegin('setOrderAttributes_args')
26388 
    if self.attributes is not None:
26389 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26390 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26391 
      for iter634 in self.attributes:
26392 
        iter634.write(oprot)
5676 rajveer 26393 
      oprot.writeListEnd()
26394 
      oprot.writeFieldEnd()
26395 
    if self.orderId is not None:
26396 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26397 
      oprot.writeI64(self.orderId)
26398 
      oprot.writeFieldEnd()
26399 
    oprot.writeFieldStop()
26400 
    oprot.writeStructEnd()
26401 
 
26402 
  def validate(self):
26403 
    return
26404 
 
26405 
 
26406 
  def __repr__(self):
26407 
    L = ['%s=%r' % (key, value)
26408 
      for key, value in self.__dict__.iteritems()]
26409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26410 
 
26411 
  def __eq__(self, other):
26412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26413 
 
26414 
  def __ne__(self, other):
26415 
    return not (self == other)
26416 
 
26417 
class setOrderAttributes_result:
26418 
 
26419 
  thrift_spec = (
26420 
  )
26421 
 
26422 
  def read(self, iprot):
26423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26425 
      return
26426 
    iprot.readStructBegin()
26427 
    while True:
26428 
      (fname, ftype, fid) = iprot.readFieldBegin()
26429 
      if ftype == TType.STOP:
26430 
        break
26431 
      else:
26432 
        iprot.skip(ftype)
26433 
      iprot.readFieldEnd()
26434 
    iprot.readStructEnd()
26435 
 
26436 
  def write(self, oprot):
26437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26439 
      return
26440 
    oprot.writeStructBegin('setOrderAttributes_result')
26441 
    oprot.writeFieldStop()
26442 
    oprot.writeStructEnd()
26443 
 
26444 
  def validate(self):
26445 
    return
26446 
 
26447 
 
26448 
  def __repr__(self):
26449 
    L = ['%s=%r' % (key, value)
26450 
      for key, value in self.__dict__.iteritems()]
26451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26452 
 
26453 
  def __eq__(self, other):
26454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26455 
 
26456 
  def __ne__(self, other):
26457 
    return not (self == other)
26458 
 
5527 anupam.sin 26459 
class setOrderAttributeForTransaction_args:
26460 
  """
26461 
  Attributes:
26462 
   - transactionId
26463 
   - attribute
26464 
  """
26465 
 
26466 
  thrift_spec = None
26467 
  def __init__(self, transactionId=None, attribute=None,):
26468 
    self.transactionId = transactionId
26469 
    self.attribute = attribute
26470 
 
26471 
  def read(self, iprot):
26472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26474 
      return
26475 
    iprot.readStructBegin()
26476 
    while True:
26477 
      (fname, ftype, fid) = iprot.readFieldBegin()
26478 
      if ftype == TType.STOP:
26479 
        break
26480 
      if fid == 1:
26481 
        if ftype == TType.I64:
26482 
          self.transactionId = iprot.readI64();
26483 
        else:
26484 
          iprot.skip(ftype)
26485 
      elif fid == -1:
26486 
        if ftype == TType.STRUCT:
26487 
          self.attribute = Attribute()
26488 
          self.attribute.read(iprot)
26489 
        else:
26490 
          iprot.skip(ftype)
26491 
      else:
26492 
        iprot.skip(ftype)
26493 
      iprot.readFieldEnd()
26494 
    iprot.readStructEnd()
26495 
 
26496 
  def write(self, oprot):
26497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26499 
      return
26500 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26501 
    if self.attribute is not None:
26502 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26503 
      self.attribute.write(oprot)
26504 
      oprot.writeFieldEnd()
26505 
    if self.transactionId is not None:
26506 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26507 
      oprot.writeI64(self.transactionId)
26508 
      oprot.writeFieldEnd()
26509 
    oprot.writeFieldStop()
26510 
    oprot.writeStructEnd()
26511 
 
26512 
  def validate(self):
26513 
    return
26514 
 
26515 
 
26516 
  def __repr__(self):
26517 
    L = ['%s=%r' % (key, value)
26518 
      for key, value in self.__dict__.iteritems()]
26519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26520 
 
26521 
  def __eq__(self, other):
26522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26523 
 
26524 
  def __ne__(self, other):
26525 
    return not (self == other)
26526 
 
26527 
class setOrderAttributeForTransaction_result:
26528 
 
26529 
  thrift_spec = (
26530 
  )
26531 
 
26532 
  def read(self, iprot):
26533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26535 
      return
26536 
    iprot.readStructBegin()
26537 
    while True:
26538 
      (fname, ftype, fid) = iprot.readFieldBegin()
26539 
      if ftype == TType.STOP:
26540 
        break
26541 
      else:
26542 
        iprot.skip(ftype)
26543 
      iprot.readFieldEnd()
26544 
    iprot.readStructEnd()
26545 
 
26546 
  def write(self, oprot):
26547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26549 
      return
26550 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26551 
    oprot.writeFieldStop()
26552 
    oprot.writeStructEnd()
26553 
 
26554 
  def validate(self):
26555 
    return
26556 
 
26557 
 
26558 
  def __repr__(self):
26559 
    L = ['%s=%r' % (key, value)
26560 
      for key, value in self.__dict__.iteritems()]
26561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26562 
 
26563 
  def __eq__(self, other):
26564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26565 
 
26566 
  def __ne__(self, other):
26567 
    return not (self == other)
5553 rajveer 26568 
 
26569 
class getReceivePendingOrders_args:
26570 
  """
26571 
  Attributes:
26572 
   - storeId
26573 
  """
26574 
 
26575 
  thrift_spec = (
26576 
    None, # 0
26577 
    (1, TType.I64, 'storeId', None, None, ), # 1
26578 
  )
26579 
 
26580 
  def __init__(self, storeId=None,):
26581 
    self.storeId = storeId
26582 
 
26583 
  def read(self, iprot):
26584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26586 
      return
26587 
    iprot.readStructBegin()
26588 
    while True:
26589 
      (fname, ftype, fid) = iprot.readFieldBegin()
26590 
      if ftype == TType.STOP:
26591 
        break
26592 
      if fid == 1:
26593 
        if ftype == TType.I64:
26594 
          self.storeId = iprot.readI64();
26595 
        else:
26596 
          iprot.skip(ftype)
26597 
      else:
26598 
        iprot.skip(ftype)
26599 
      iprot.readFieldEnd()
26600 
    iprot.readStructEnd()
26601 
 
26602 
  def write(self, oprot):
26603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26605 
      return
26606 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26607 
    if self.storeId is not None:
26608 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26609 
      oprot.writeI64(self.storeId)
26610 
      oprot.writeFieldEnd()
26611 
    oprot.writeFieldStop()
26612 
    oprot.writeStructEnd()
26613 
 
26614 
  def validate(self):
26615 
    return
26616 
 
26617 
 
26618 
  def __repr__(self):
26619 
    L = ['%s=%r' % (key, value)
26620 
      for key, value in self.__dict__.iteritems()]
26621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26622 
 
26623 
  def __eq__(self, other):
26624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26625 
 
26626 
  def __ne__(self, other):
26627 
    return not (self == other)
26628 
 
26629 
class getReceivePendingOrders_result:
26630 
  """
26631 
  Attributes:
26632 
   - success
26633 
  """
26634 
 
26635 
  thrift_spec = (
26636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26637 
  )
26638 
 
26639 
  def __init__(self, success=None,):
26640 
    self.success = success
26641 
 
26642 
  def read(self, iprot):
26643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26645 
      return
26646 
    iprot.readStructBegin()
26647 
    while True:
26648 
      (fname, ftype, fid) = iprot.readFieldBegin()
26649 
      if ftype == TType.STOP:
26650 
        break
26651 
      if fid == 0:
26652 
        if ftype == TType.LIST:
26653 
          self.success = []
6188 rajveer 26654 
          (_etype638, _size635) = iprot.readListBegin()
26655 
          for _i639 in xrange(_size635):
26656 
            _elem640 = Order()
26657 
            _elem640.read(iprot)
26658 
            self.success.append(_elem640)
5553 rajveer 26659 
          iprot.readListEnd()
26660 
        else:
26661 
          iprot.skip(ftype)
26662 
      else:
26663 
        iprot.skip(ftype)
26664 
      iprot.readFieldEnd()
26665 
    iprot.readStructEnd()
26666 
 
26667 
  def write(self, oprot):
26668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26670 
      return
26671 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26672 
    if self.success is not None:
26673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26675 
      for iter641 in self.success:
26676 
        iter641.write(oprot)
5553 rajveer 26677 
      oprot.writeListEnd()
26678 
      oprot.writeFieldEnd()
26679 
    oprot.writeFieldStop()
26680 
    oprot.writeStructEnd()
26681 
 
26682 
  def validate(self):
26683 
    return
26684 
 
26685 
 
26686 
  def __repr__(self):
26687 
    L = ['%s=%r' % (key, value)
26688 
      for key, value in self.__dict__.iteritems()]
26689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26690 
 
26691 
  def __eq__(self, other):
26692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26693 
 
26694 
  def __ne__(self, other):
26695 
    return not (self == other)
26696 
 
26697 
class getReceivedAtStoreOrders_args:
26698 
  """
26699 
  Attributes:
26700 
   - storeId
26701 
  """
26702 
 
26703 
  thrift_spec = (
26704 
    None, # 0
26705 
    (1, TType.I64, 'storeId', None, None, ), # 1
26706 
  )
26707 
 
26708 
  def __init__(self, storeId=None,):
26709 
    self.storeId = storeId
26710 
 
26711 
  def read(self, iprot):
26712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26714 
      return
26715 
    iprot.readStructBegin()
26716 
    while True:
26717 
      (fname, ftype, fid) = iprot.readFieldBegin()
26718 
      if ftype == TType.STOP:
26719 
        break
26720 
      if fid == 1:
26721 
        if ftype == TType.I64:
26722 
          self.storeId = iprot.readI64();
26723 
        else:
26724 
          iprot.skip(ftype)
26725 
      else:
26726 
        iprot.skip(ftype)
26727 
      iprot.readFieldEnd()
26728 
    iprot.readStructEnd()
26729 
 
26730 
  def write(self, oprot):
26731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26733 
      return
26734 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26735 
    if self.storeId is not None:
26736 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26737 
      oprot.writeI64(self.storeId)
26738 
      oprot.writeFieldEnd()
26739 
    oprot.writeFieldStop()
26740 
    oprot.writeStructEnd()
26741 
 
26742 
  def validate(self):
26743 
    return
26744 
 
26745 
 
26746 
  def __repr__(self):
26747 
    L = ['%s=%r' % (key, value)
26748 
      for key, value in self.__dict__.iteritems()]
26749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26750 
 
26751 
  def __eq__(self, other):
26752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26753 
 
26754 
  def __ne__(self, other):
26755 
    return not (self == other)
26756 
 
26757 
class getReceivedAtStoreOrders_result:
26758 
  """
26759 
  Attributes:
26760 
   - success
26761 
  """
26762 
 
26763 
  thrift_spec = (
26764 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26765 
  )
26766 
 
26767 
  def __init__(self, success=None,):
26768 
    self.success = success
26769 
 
26770 
  def read(self, iprot):
26771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26773 
      return
26774 
    iprot.readStructBegin()
26775 
    while True:
26776 
      (fname, ftype, fid) = iprot.readFieldBegin()
26777 
      if ftype == TType.STOP:
26778 
        break
26779 
      if fid == 0:
26780 
        if ftype == TType.LIST:
26781 
          self.success = []
6188 rajveer 26782 
          (_etype645, _size642) = iprot.readListBegin()
26783 
          for _i646 in xrange(_size642):
26784 
            _elem647 = Order()
26785 
            _elem647.read(iprot)
26786 
            self.success.append(_elem647)
5553 rajveer 26787 
          iprot.readListEnd()
26788 
        else:
26789 
          iprot.skip(ftype)
26790 
      else:
26791 
        iprot.skip(ftype)
26792 
      iprot.readFieldEnd()
26793 
    iprot.readStructEnd()
26794 
 
26795 
  def write(self, oprot):
26796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26798 
      return
26799 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26800 
    if self.success is not None:
26801 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26802 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26803 
      for iter648 in self.success:
26804 
        iter648.write(oprot)
5553 rajveer 26805 
      oprot.writeListEnd()
26806 
      oprot.writeFieldEnd()
26807 
    oprot.writeFieldStop()
26808 
    oprot.writeStructEnd()
26809 
 
26810 
  def validate(self):
26811 
    return
26812 
 
26813 
 
26814 
  def __repr__(self):
26815 
    L = ['%s=%r' % (key, value)
26816 
      for key, value in self.__dict__.iteritems()]
26817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26818 
 
26819 
  def __eq__(self, other):
26820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26821 
 
26822 
  def __ne__(self, other):
26823 
    return not (self == other)
5593 mandeep.dh 26824 
 
5713 rajveer 26825 
class getOrdersCollectionAtStore_args:
26826 
  """
26827 
  Attributes:
26828 
   - storeId
26829 
   - fromDate
26830 
   - toDate
26831 
   - onlyCod
26832 
  """
26833 
 
26834 
  thrift_spec = (
26835 
    None, # 0
26836 
    (1, TType.I64, 'storeId', None, None, ), # 1
26837 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26838 
    (3, TType.I64, 'toDate', None, None, ), # 3
26839 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26840 
  )
26841 
 
26842 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26843 
    self.storeId = storeId
26844 
    self.fromDate = fromDate
26845 
    self.toDate = toDate
26846 
    self.onlyCod = onlyCod
26847 
 
26848 
  def read(self, iprot):
26849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26851 
      return
26852 
    iprot.readStructBegin()
26853 
    while True:
26854 
      (fname, ftype, fid) = iprot.readFieldBegin()
26855 
      if ftype == TType.STOP:
26856 
        break
26857 
      if fid == 1:
26858 
        if ftype == TType.I64:
26859 
          self.storeId = iprot.readI64();
26860 
        else:
26861 
          iprot.skip(ftype)
26862 
      elif fid == 2:
26863 
        if ftype == TType.I64:
26864 
          self.fromDate = iprot.readI64();
26865 
        else:
26866 
          iprot.skip(ftype)
26867 
      elif fid == 3:
26868 
        if ftype == TType.I64:
26869 
          self.toDate = iprot.readI64();
26870 
        else:
26871 
          iprot.skip(ftype)
26872 
      elif fid == 4:
26873 
        if ftype == TType.BOOL:
26874 
          self.onlyCod = iprot.readBool();
26875 
        else:
26876 
          iprot.skip(ftype)
26877 
      else:
26878 
        iprot.skip(ftype)
26879 
      iprot.readFieldEnd()
26880 
    iprot.readStructEnd()
26881 
 
26882 
  def write(self, oprot):
26883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26885 
      return
26886 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26887 
    if self.storeId is not None:
26888 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26889 
      oprot.writeI64(self.storeId)
26890 
      oprot.writeFieldEnd()
26891 
    if self.fromDate is not None:
26892 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26893 
      oprot.writeI64(self.fromDate)
26894 
      oprot.writeFieldEnd()
26895 
    if self.toDate is not None:
26896 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26897 
      oprot.writeI64(self.toDate)
26898 
      oprot.writeFieldEnd()
26899 
    if self.onlyCod is not None:
26900 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26901 
      oprot.writeBool(self.onlyCod)
26902 
      oprot.writeFieldEnd()
26903 
    oprot.writeFieldStop()
26904 
    oprot.writeStructEnd()
26905 
 
26906 
  def validate(self):
26907 
    return
26908 
 
26909 
 
26910 
  def __repr__(self):
26911 
    L = ['%s=%r' % (key, value)
26912 
      for key, value in self.__dict__.iteritems()]
26913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26914 
 
26915 
  def __eq__(self, other):
26916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26917 
 
26918 
  def __ne__(self, other):
26919 
    return not (self == other)
26920 
 
26921 
class getOrdersCollectionAtStore_result:
26922 
  """
26923 
  Attributes:
26924 
   - success
26925 
  """
26926 
 
26927 
  thrift_spec = (
26928 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26929 
  )
26930 
 
26931 
  def __init__(self, success=None,):
26932 
    self.success = success
26933 
 
26934 
  def read(self, iprot):
26935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26937 
      return
26938 
    iprot.readStructBegin()
26939 
    while True:
26940 
      (fname, ftype, fid) = iprot.readFieldBegin()
26941 
      if ftype == TType.STOP:
26942 
        break
26943 
      if fid == 0:
26944 
        if ftype == TType.LIST:
26945 
          self.success = []
6188 rajveer 26946 
          (_etype652, _size649) = iprot.readListBegin()
26947 
          for _i653 in xrange(_size649):
26948 
            _elem654 = Order()
26949 
            _elem654.read(iprot)
26950 
            self.success.append(_elem654)
5713 rajveer 26951 
          iprot.readListEnd()
26952 
        else:
26953 
          iprot.skip(ftype)
26954 
      else:
26955 
        iprot.skip(ftype)
26956 
      iprot.readFieldEnd()
26957 
    iprot.readStructEnd()
26958 
 
26959 
  def write(self, oprot):
26960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26962 
      return
26963 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26964 
    if self.success is not None:
26965 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26966 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26967 
      for iter655 in self.success:
26968 
        iter655.write(oprot)
5713 rajveer 26969 
      oprot.writeListEnd()
26970 
      oprot.writeFieldEnd()
26971 
    oprot.writeFieldStop()
26972 
    oprot.writeStructEnd()
26973 
 
26974 
  def validate(self):
26975 
    return
26976 
 
26977 
 
26978 
  def __repr__(self):
26979 
    L = ['%s=%r' % (key, value)
26980 
      for key, value in self.__dict__.iteritems()]
26981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26982 
 
26983 
  def __eq__(self, other):
26984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26985 
 
26986 
  def __ne__(self, other):
26987 
    return not (self == other)
26988 
 
5833 rajveer 26989 
class getOrderAttributeValue_args:
26990 
  """
26991 
  Attributes:
26992 
   - orderId
26993 
   - attributeName
26994 
  """
26995 
 
26996 
  thrift_spec = None
26997 
  def __init__(self, orderId=None, attributeName=None,):
26998 
    self.orderId = orderId
26999 
    self.attributeName = attributeName
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 
      if fid == 1:
27011 
        if ftype == TType.I64:
27012 
          self.orderId = iprot.readI64();
27013 
        else:
27014 
          iprot.skip(ftype)
27015 
      elif fid == -1:
27016 
        if ftype == TType.STRING:
27017 
          self.attributeName = iprot.readString();
27018 
        else:
27019 
          iprot.skip(ftype)
27020 
      else:
27021 
        iprot.skip(ftype)
27022 
      iprot.readFieldEnd()
27023 
    iprot.readStructEnd()
27024 
 
27025 
  def write(self, oprot):
27026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27028 
      return
27029 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27030 
    if self.attributeName is not None:
27031 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27032 
      oprot.writeString(self.attributeName)
27033 
      oprot.writeFieldEnd()
27034 
    if self.orderId is not None:
27035 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27036 
      oprot.writeI64(self.orderId)
27037 
      oprot.writeFieldEnd()
27038 
    oprot.writeFieldStop()
27039 
    oprot.writeStructEnd()
27040 
 
27041 
  def validate(self):
27042 
    return
27043 
 
27044 
 
27045 
  def __repr__(self):
27046 
    L = ['%s=%r' % (key, value)
27047 
      for key, value in self.__dict__.iteritems()]
27048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27049 
 
27050 
  def __eq__(self, other):
27051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27052 
 
27053 
  def __ne__(self, other):
27054 
    return not (self == other)
27055 
 
27056 
class getOrderAttributeValue_result:
27057 
  """
27058 
  Attributes:
27059 
   - success
27060 
  """
27061 
 
27062 
  thrift_spec = (
27063 
    (0, TType.STRING, 'success', None, None, ), # 0
27064 
  )
27065 
 
27066 
  def __init__(self, success=None,):
27067 
    self.success = success
27068 
 
27069 
  def read(self, iprot):
27070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27072 
      return
27073 
    iprot.readStructBegin()
27074 
    while True:
27075 
      (fname, ftype, fid) = iprot.readFieldBegin()
27076 
      if ftype == TType.STOP:
27077 
        break
27078 
      if fid == 0:
27079 
        if ftype == TType.STRING:
27080 
          self.success = iprot.readString();
27081 
        else:
27082 
          iprot.skip(ftype)
27083 
      else:
27084 
        iprot.skip(ftype)
27085 
      iprot.readFieldEnd()
27086 
    iprot.readStructEnd()
27087 
 
27088 
  def write(self, oprot):
27089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27091 
      return
27092 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27093 
    if self.success is not None:
27094 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27095 
      oprot.writeString(self.success)
27096 
      oprot.writeFieldEnd()
27097 
    oprot.writeFieldStop()
27098 
    oprot.writeStructEnd()
27099 
 
27100 
  def validate(self):
27101 
    return
27102 
 
27103 
 
27104 
  def __repr__(self):
27105 
    L = ['%s=%r' % (key, value)
27106 
      for key, value in self.__dict__.iteritems()]
27107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27108 
 
27109 
  def __eq__(self, other):
27110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27111 
 
27112 
  def __ne__(self, other):
27113 
    return not (self == other)
27114 
 
6019 rajveer 27115 
class changeJacketNumber_args:
27116 
  """
27117 
  Attributes:
27118 
   - orderId
27119 
   - jacketNumber
27120 
  """
27121 
 
27122 
  thrift_spec = (
27123 
    None, # 0
27124 
    (1, TType.I64, 'orderId', None, None, ), # 1
27125 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27126 
  )
27127 
 
27128 
  def __init__(self, orderId=None, jacketNumber=None,):
27129 
    self.orderId = orderId
27130 
    self.jacketNumber = jacketNumber
27131 
 
27132 
  def read(self, iprot):
27133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27135 
      return
27136 
    iprot.readStructBegin()
27137 
    while True:
27138 
      (fname, ftype, fid) = iprot.readFieldBegin()
27139 
      if ftype == TType.STOP:
27140 
        break
27141 
      if fid == 1:
27142 
        if ftype == TType.I64:
27143 
          self.orderId = iprot.readI64();
27144 
        else:
27145 
          iprot.skip(ftype)
27146 
      elif fid == 2:
27147 
        if ftype == TType.I64:
27148 
          self.jacketNumber = iprot.readI64();
27149 
        else:
27150 
          iprot.skip(ftype)
27151 
      else:
27152 
        iprot.skip(ftype)
27153 
      iprot.readFieldEnd()
27154 
    iprot.readStructEnd()
27155 
 
27156 
  def write(self, oprot):
27157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27159 
      return
27160 
    oprot.writeStructBegin('changeJacketNumber_args')
27161 
    if self.orderId is not None:
27162 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27163 
      oprot.writeI64(self.orderId)
27164 
      oprot.writeFieldEnd()
27165 
    if self.jacketNumber is not None:
27166 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27167 
      oprot.writeI64(self.jacketNumber)
27168 
      oprot.writeFieldEnd()
27169 
    oprot.writeFieldStop()
27170 
    oprot.writeStructEnd()
27171 
 
27172 
  def validate(self):
27173 
    return
27174 
 
27175 
 
27176 
  def __repr__(self):
27177 
    L = ['%s=%r' % (key, value)
27178 
      for key, value in self.__dict__.iteritems()]
27179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27180 
 
27181 
  def __eq__(self, other):
27182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27183 
 
27184 
  def __ne__(self, other):
27185 
    return not (self == other)
27186 
 
27187 
class changeJacketNumber_result:
27188 
  """
27189 
  Attributes:
27190 
   - success
27191 
  """
27192 
 
27193 
  thrift_spec = (
27194 
    (0, TType.BOOL, 'success', None, None, ), # 0
27195 
  )
27196 
 
27197 
  def __init__(self, success=None,):
27198 
    self.success = success
27199 
 
27200 
  def read(self, iprot):
27201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27203 
      return
27204 
    iprot.readStructBegin()
27205 
    while True:
27206 
      (fname, ftype, fid) = iprot.readFieldBegin()
27207 
      if ftype == TType.STOP:
27208 
        break
27209 
      if fid == 0:
27210 
        if ftype == TType.BOOL:
27211 
          self.success = iprot.readBool();
27212 
        else:
27213 
          iprot.skip(ftype)
27214 
      else:
27215 
        iprot.skip(ftype)
27216 
      iprot.readFieldEnd()
27217 
    iprot.readStructEnd()
27218 
 
27219 
  def write(self, oprot):
27220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27222 
      return
27223 
    oprot.writeStructBegin('changeJacketNumber_result')
27224 
    if self.success is not None:
27225 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27226 
      oprot.writeBool(self.success)
27227 
      oprot.writeFieldEnd()
27228 
    oprot.writeFieldStop()
27229 
    oprot.writeStructEnd()
27230 
 
27231 
  def validate(self):
27232 
    return
27233 
 
27234 
 
27235 
  def __repr__(self):
27236 
    L = ['%s=%r' % (key, value)
27237 
      for key, value in self.__dict__.iteritems()]
27238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27239 
 
27240 
  def __eq__(self, other):
27241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27242 
 
27243 
  def __ne__(self, other):
27244 
    return not (self == other)
27245 
 
27246 
class markOrderAsRtoInTransit_args:
27247 
  """
27248 
  Attributes:
27249 
   - orderId
27250 
  """
27251 
 
27252 
  thrift_spec = (
27253 
    None, # 0
27254 
    (1, TType.I64, 'orderId', None, None, ), # 1
27255 
  )
27256 
 
27257 
  def __init__(self, orderId=None,):
27258 
    self.orderId = orderId
27259 
 
27260 
  def read(self, iprot):
27261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27263 
      return
27264 
    iprot.readStructBegin()
27265 
    while True:
27266 
      (fname, ftype, fid) = iprot.readFieldBegin()
27267 
      if ftype == TType.STOP:
27268 
        break
27269 
      if fid == 1:
27270 
        if ftype == TType.I64:
27271 
          self.orderId = iprot.readI64();
27272 
        else:
27273 
          iprot.skip(ftype)
27274 
      else:
27275 
        iprot.skip(ftype)
27276 
      iprot.readFieldEnd()
27277 
    iprot.readStructEnd()
27278 
 
27279 
  def write(self, oprot):
27280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27282 
      return
27283 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27284 
    if self.orderId is not None:
27285 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27286 
      oprot.writeI64(self.orderId)
27287 
      oprot.writeFieldEnd()
27288 
    oprot.writeFieldStop()
27289 
    oprot.writeStructEnd()
27290 
 
27291 
  def validate(self):
27292 
    return
27293 
 
27294 
 
27295 
  def __repr__(self):
27296 
    L = ['%s=%r' % (key, value)
27297 
      for key, value in self.__dict__.iteritems()]
27298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27299 
 
27300 
  def __eq__(self, other):
27301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27302 
 
27303 
  def __ne__(self, other):
27304 
    return not (self == other)
27305 
 
27306 
class markOrderAsRtoInTransit_result:
27307 
  """
27308 
  Attributes:
27309 
   - success
27310 
  """
27311 
 
27312 
  thrift_spec = (
27313 
    (0, TType.BOOL, 'success', None, None, ), # 0
27314 
  )
27315 
 
27316 
  def __init__(self, success=None,):
27317 
    self.success = success
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 == 0:
27329 
        if ftype == TType.BOOL:
27330 
          self.success = iprot.readBool();
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('markOrderAsRtoInTransit_result')
27343 
    if self.success is not None:
27344 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27345 
      oprot.writeBool(self.success)
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 
 
5593 mandeep.dh 27365 
class acceptOrderForItem_args:
27366 
  """
27367 
  Attributes:
27368 
   - itemId
27369 
   - quantity
27370 
   - fulfilmentWarehouseId
27371 
   - billingWarehouseId
27372 
  """
27373 
 
27374 
  thrift_spec = (
27375 
    None, # 0
27376 
    (1, TType.I64, 'itemId', None, None, ), # 1
27377 
    (2, TType.I64, 'quantity', None, None, ), # 2
27378 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27379 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27380 
  )
27381 
 
27382 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27383 
    self.itemId = itemId
27384 
    self.quantity = quantity
27385 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27386 
    self.billingWarehouseId = billingWarehouseId
27387 
 
27388 
  def read(self, iprot):
27389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27391 
      return
27392 
    iprot.readStructBegin()
27393 
    while True:
27394 
      (fname, ftype, fid) = iprot.readFieldBegin()
27395 
      if ftype == TType.STOP:
27396 
        break
27397 
      if fid == 1:
27398 
        if ftype == TType.I64:
27399 
          self.itemId = iprot.readI64();
27400 
        else:
27401 
          iprot.skip(ftype)
27402 
      elif fid == 2:
27403 
        if ftype == TType.I64:
27404 
          self.quantity = iprot.readI64();
27405 
        else:
27406 
          iprot.skip(ftype)
27407 
      elif fid == 3:
27408 
        if ftype == TType.I64:
27409 
          self.fulfilmentWarehouseId = iprot.readI64();
27410 
        else:
27411 
          iprot.skip(ftype)
27412 
      elif fid == 4:
27413 
        if ftype == TType.I64:
27414 
          self.billingWarehouseId = iprot.readI64();
27415 
        else:
27416 
          iprot.skip(ftype)
27417 
      else:
27418 
        iprot.skip(ftype)
27419 
      iprot.readFieldEnd()
27420 
    iprot.readStructEnd()
27421 
 
27422 
  def write(self, oprot):
27423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27425 
      return
27426 
    oprot.writeStructBegin('acceptOrderForItem_args')
27427 
    if self.itemId is not None:
27428 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27429 
      oprot.writeI64(self.itemId)
27430 
      oprot.writeFieldEnd()
27431 
    if self.quantity is not None:
27432 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27433 
      oprot.writeI64(self.quantity)
27434 
      oprot.writeFieldEnd()
27435 
    if self.fulfilmentWarehouseId is not None:
27436 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27437 
      oprot.writeI64(self.fulfilmentWarehouseId)
27438 
      oprot.writeFieldEnd()
27439 
    if self.billingWarehouseId is not None:
27440 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27441 
      oprot.writeI64(self.billingWarehouseId)
27442 
      oprot.writeFieldEnd()
27443 
    oprot.writeFieldStop()
27444 
    oprot.writeStructEnd()
27445 
 
27446 
  def validate(self):
27447 
    return
27448 
 
27449 
 
27450 
  def __repr__(self):
27451 
    L = ['%s=%r' % (key, value)
27452 
      for key, value in self.__dict__.iteritems()]
27453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27454 
 
27455 
  def __eq__(self, other):
27456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27457 
 
27458 
  def __ne__(self, other):
27459 
    return not (self == other)
27460 
 
27461 
class acceptOrderForItem_result:
27462 
 
27463 
  thrift_spec = (
27464 
  )
27465 
 
27466 
  def read(self, iprot):
27467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27469 
      return
27470 
    iprot.readStructBegin()
27471 
    while True:
27472 
      (fname, ftype, fid) = iprot.readFieldBegin()
27473 
      if ftype == TType.STOP:
27474 
        break
27475 
      else:
27476 
        iprot.skip(ftype)
27477 
      iprot.readFieldEnd()
27478 
    iprot.readStructEnd()
27479 
 
27480 
  def write(self, oprot):
27481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27483 
      return
27484 
    oprot.writeStructBegin('acceptOrderForItem_result')
27485 
    oprot.writeFieldStop()
27486 
    oprot.writeStructEnd()
27487 
 
27488 
  def validate(self):
27489 
    return
27490 
 
27491 
 
27492 
  def __repr__(self):
27493 
    L = ['%s=%r' % (key, value)
27494 
      for key, value in self.__dict__.iteritems()]
27495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27496 
 
27497 
  def __eq__(self, other):
27498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27499 
 
27500 
  def __ne__(self, other):
27501 
    return not (self == other)
6000 mandeep.dh 27502 
 
27503 
class createRechargeOrder_args:
27504 
  """
27505 
  Attributes:
27506 
   - rechargeOrder
27507 
  """
27508 
 
27509 
  thrift_spec = (
27510 
    None, # 0
27511 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27512 
  )
27513 
 
27514 
  def __init__(self, rechargeOrder=None,):
27515 
    self.rechargeOrder = rechargeOrder
27516 
 
27517 
  def read(self, iprot):
27518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27520 
      return
27521 
    iprot.readStructBegin()
27522 
    while True:
27523 
      (fname, ftype, fid) = iprot.readFieldBegin()
27524 
      if ftype == TType.STOP:
27525 
        break
27526 
      if fid == 1:
27527 
        if ftype == TType.STRUCT:
27528 
          self.rechargeOrder = RechargeOrder()
27529 
          self.rechargeOrder.read(iprot)
27530 
        else:
27531 
          iprot.skip(ftype)
27532 
      else:
27533 
        iprot.skip(ftype)
27534 
      iprot.readFieldEnd()
27535 
    iprot.readStructEnd()
27536 
 
27537 
  def write(self, oprot):
27538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27540 
      return
27541 
    oprot.writeStructBegin('createRechargeOrder_args')
27542 
    if self.rechargeOrder is not None:
27543 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27544 
      self.rechargeOrder.write(oprot)
27545 
      oprot.writeFieldEnd()
27546 
    oprot.writeFieldStop()
27547 
    oprot.writeStructEnd()
27548 
 
27549 
  def validate(self):
27550 
    return
27551 
 
27552 
 
27553 
  def __repr__(self):
27554 
    L = ['%s=%r' % (key, value)
27555 
      for key, value in self.__dict__.iteritems()]
27556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27557 
 
27558 
  def __eq__(self, other):
27559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27560 
 
27561 
  def __ne__(self, other):
27562 
    return not (self == other)
27563 
 
27564 
class createRechargeOrder_result:
27565 
  """
27566 
  Attributes:
27567 
   - success
27568 
   - ex
27569 
  """
27570 
 
27571 
  thrift_spec = (
27572 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27574 
  )
27575 
 
27576 
  def __init__(self, success=None, ex=None,):
27577 
    self.success = success
27578 
    self.ex = ex
27579 
 
27580 
  def read(self, iprot):
27581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27583 
      return
27584 
    iprot.readStructBegin()
27585 
    while True:
27586 
      (fname, ftype, fid) = iprot.readFieldBegin()
27587 
      if ftype == TType.STOP:
27588 
        break
27589 
      if fid == 0:
27590 
        if ftype == TType.STRUCT:
27591 
          self.success = RechargeOrder()
27592 
          self.success.read(iprot)
27593 
        else:
27594 
          iprot.skip(ftype)
27595 
      elif fid == 1:
27596 
        if ftype == TType.STRUCT:
27597 
          self.ex = TransactionServiceException()
27598 
          self.ex.read(iprot)
27599 
        else:
27600 
          iprot.skip(ftype)
27601 
      else:
27602 
        iprot.skip(ftype)
27603 
      iprot.readFieldEnd()
27604 
    iprot.readStructEnd()
27605 
 
27606 
  def write(self, oprot):
27607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27609 
      return
27610 
    oprot.writeStructBegin('createRechargeOrder_result')
27611 
    if self.success is not None:
27612 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27613 
      self.success.write(oprot)
27614 
      oprot.writeFieldEnd()
27615 
    if self.ex is not None:
27616 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27617 
      self.ex.write(oprot)
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 
 
6031 rajveer 27637 
class getRechargeOrder_args:
27638 
  """
27639 
  Attributes:
27640 
   - rechargeRrderId
27641 
  """
27642 
 
27643 
  thrift_spec = (
27644 
    None, # 0
27645 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27646 
  )
27647 
 
27648 
  def __init__(self, rechargeRrderId=None,):
27649 
    self.rechargeRrderId = rechargeRrderId
27650 
 
27651 
  def read(self, iprot):
27652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27654 
      return
27655 
    iprot.readStructBegin()
27656 
    while True:
27657 
      (fname, ftype, fid) = iprot.readFieldBegin()
27658 
      if ftype == TType.STOP:
27659 
        break
27660 
      if fid == 1:
27661 
        if ftype == TType.I64:
27662 
          self.rechargeRrderId = iprot.readI64();
27663 
        else:
27664 
          iprot.skip(ftype)
27665 
      else:
27666 
        iprot.skip(ftype)
27667 
      iprot.readFieldEnd()
27668 
    iprot.readStructEnd()
27669 
 
27670 
  def write(self, oprot):
27671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27673 
      return
27674 
    oprot.writeStructBegin('getRechargeOrder_args')
27675 
    if self.rechargeRrderId is not None:
27676 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27677 
      oprot.writeI64(self.rechargeRrderId)
27678 
      oprot.writeFieldEnd()
27679 
    oprot.writeFieldStop()
27680 
    oprot.writeStructEnd()
27681 
 
27682 
  def validate(self):
27683 
    return
27684 
 
27685 
 
27686 
  def __repr__(self):
27687 
    L = ['%s=%r' % (key, value)
27688 
      for key, value in self.__dict__.iteritems()]
27689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27690 
 
27691 
  def __eq__(self, other):
27692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27693 
 
27694 
  def __ne__(self, other):
27695 
    return not (self == other)
27696 
 
27697 
class getRechargeOrder_result:
27698 
  """
27699 
  Attributes:
27700 
   - success
27701 
   - ex
27702 
  """
27703 
 
27704 
  thrift_spec = (
27705 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27707 
  )
27708 
 
27709 
  def __init__(self, success=None, ex=None,):
27710 
    self.success = success
27711 
    self.ex = ex
27712 
 
27713 
  def read(self, iprot):
27714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27716 
      return
27717 
    iprot.readStructBegin()
27718 
    while True:
27719 
      (fname, ftype, fid) = iprot.readFieldBegin()
27720 
      if ftype == TType.STOP:
27721 
        break
27722 
      if fid == 0:
27723 
        if ftype == TType.STRUCT:
27724 
          self.success = RechargeOrder()
27725 
          self.success.read(iprot)
27726 
        else:
27727 
          iprot.skip(ftype)
27728 
      elif fid == 1:
27729 
        if ftype == TType.STRUCT:
27730 
          self.ex = TransactionServiceException()
27731 
          self.ex.read(iprot)
27732 
        else:
27733 
          iprot.skip(ftype)
27734 
      else:
27735 
        iprot.skip(ftype)
27736 
      iprot.readFieldEnd()
27737 
    iprot.readStructEnd()
27738 
 
27739 
  def write(self, oprot):
27740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27742 
      return
27743 
    oprot.writeStructBegin('getRechargeOrder_result')
27744 
    if self.success is not None:
27745 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27746 
      self.success.write(oprot)
27747 
      oprot.writeFieldEnd()
27748 
    if self.ex is not None:
27749 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27750 
      self.ex.write(oprot)
27751 
      oprot.writeFieldEnd()
27752 
    oprot.writeFieldStop()
27753 
    oprot.writeStructEnd()
27754 
 
27755 
  def validate(self):
27756 
    return
27757 
 
27758 
 
27759 
  def __repr__(self):
27760 
    L = ['%s=%r' % (key, value)
27761 
      for key, value in self.__dict__.iteritems()]
27762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27763 
 
27764 
  def __eq__(self, other):
27765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27766 
 
27767 
  def __ne__(self, other):
27768 
    return not (self == other)
27769 
 
27770 
class getRechargeOrders_args:
27771 
  """
27772 
  Attributes:
27773 
   - userId
27774 
  """
27775 
 
27776 
  thrift_spec = (
27777 
    None, # 0
27778 
    (1, TType.I64, 'userId', None, None, ), # 1
27779 
  )
27780 
 
27781 
  def __init__(self, userId=None,):
27782 
    self.userId = userId
27783 
 
27784 
  def read(self, iprot):
27785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27787 
      return
27788 
    iprot.readStructBegin()
27789 
    while True:
27790 
      (fname, ftype, fid) = iprot.readFieldBegin()
27791 
      if ftype == TType.STOP:
27792 
        break
27793 
      if fid == 1:
27794 
        if ftype == TType.I64:
27795 
          self.userId = iprot.readI64();
27796 
        else:
27797 
          iprot.skip(ftype)
27798 
      else:
27799 
        iprot.skip(ftype)
27800 
      iprot.readFieldEnd()
27801 
    iprot.readStructEnd()
27802 
 
27803 
  def write(self, oprot):
27804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27806 
      return
27807 
    oprot.writeStructBegin('getRechargeOrders_args')
27808 
    if self.userId is not None:
27809 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27810 
      oprot.writeI64(self.userId)
27811 
      oprot.writeFieldEnd()
27812 
    oprot.writeFieldStop()
27813 
    oprot.writeStructEnd()
27814 
 
27815 
  def validate(self):
27816 
    return
27817 
 
27818 
 
27819 
  def __repr__(self):
27820 
    L = ['%s=%r' % (key, value)
27821 
      for key, value in self.__dict__.iteritems()]
27822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27823 
 
27824 
  def __eq__(self, other):
27825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27826 
 
27827 
  def __ne__(self, other):
27828 
    return not (self == other)
27829 
 
27830 
class getRechargeOrders_result:
27831 
  """
27832 
  Attributes:
27833 
   - success
27834 
  """
27835 
 
27836 
  thrift_spec = (
27837 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27838 
  )
27839 
 
27840 
  def __init__(self, success=None,):
27841 
    self.success = success
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 == 0:
27853 
        if ftype == TType.LIST:
27854 
          self.success = []
6188 rajveer 27855 
          (_etype659, _size656) = iprot.readListBegin()
27856 
          for _i660 in xrange(_size656):
27857 
            _elem661 = RechargeOrder()
27858 
            _elem661.read(iprot)
27859 
            self.success.append(_elem661)
6031 rajveer 27860 
          iprot.readListEnd()
27861 
        else:
27862 
          iprot.skip(ftype)
27863 
      else:
27864 
        iprot.skip(ftype)
27865 
      iprot.readFieldEnd()
27866 
    iprot.readStructEnd()
27867 
 
27868 
  def write(self, oprot):
27869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27871 
      return
27872 
    oprot.writeStructBegin('getRechargeOrders_result')
27873 
    if self.success is not None:
27874 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27875 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27876 
      for iter662 in self.success:
27877 
        iter662.write(oprot)
6031 rajveer 27878 
      oprot.writeListEnd()
27879 
      oprot.writeFieldEnd()
27880 
    oprot.writeFieldStop()
27881 
    oprot.writeStructEnd()
27882 
 
27883 
  def validate(self):
27884 
    return
27885 
 
27886 
 
27887 
  def __repr__(self):
27888 
    L = ['%s=%r' % (key, value)
27889 
      for key, value in self.__dict__.iteritems()]
27890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27891 
 
27892 
  def __eq__(self, other):
27893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27894 
 
27895 
  def __ne__(self, other):
27896 
    return not (self == other)
27897 
 
6000 mandeep.dh 27898 
class updateRechargeOrderStatus_args:
27899 
  """
27900 
  Attributes:
27901 
   - rechargeOrderId
27902 
   - rechargeOrderStatus
27903 
  """
27904 
 
27905 
  thrift_spec = (
27906 
    None, # 0
27907 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27908 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27909 
  )
27910 
 
27911 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27912 
    self.rechargeOrderId = rechargeOrderId
27913 
    self.rechargeOrderStatus = rechargeOrderStatus
27914 
 
27915 
  def read(self, iprot):
27916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27918 
      return
27919 
    iprot.readStructBegin()
27920 
    while True:
27921 
      (fname, ftype, fid) = iprot.readFieldBegin()
27922 
      if ftype == TType.STOP:
27923 
        break
27924 
      if fid == 1:
27925 
        if ftype == TType.I64:
27926 
          self.rechargeOrderId = iprot.readI64();
27927 
        else:
27928 
          iprot.skip(ftype)
27929 
      elif fid == 2:
27930 
        if ftype == TType.I32:
27931 
          self.rechargeOrderStatus = iprot.readI32();
27932 
        else:
27933 
          iprot.skip(ftype)
27934 
      else:
27935 
        iprot.skip(ftype)
27936 
      iprot.readFieldEnd()
27937 
    iprot.readStructEnd()
27938 
 
27939 
  def write(self, oprot):
27940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27942 
      return
27943 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27944 
    if self.rechargeOrderId is not None:
27945 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27946 
      oprot.writeI64(self.rechargeOrderId)
27947 
      oprot.writeFieldEnd()
27948 
    if self.rechargeOrderStatus is not None:
27949 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27950 
      oprot.writeI32(self.rechargeOrderStatus)
27951 
      oprot.writeFieldEnd()
27952 
    oprot.writeFieldStop()
27953 
    oprot.writeStructEnd()
27954 
 
27955 
  def validate(self):
27956 
    return
27957 
 
27958 
 
27959 
  def __repr__(self):
27960 
    L = ['%s=%r' % (key, value)
27961 
      for key, value in self.__dict__.iteritems()]
27962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27963 
 
27964 
  def __eq__(self, other):
27965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27966 
 
27967 
  def __ne__(self, other):
27968 
    return not (self == other)
27969 
 
27970 
class updateRechargeOrderStatus_result:
27971 
  """
27972 
  Attributes:
6031 rajveer 27973 
   - success
6000 mandeep.dh 27974 
   - ex
27975 
  """
27976 
 
27977 
  thrift_spec = (
6031 rajveer 27978 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27980 
  )
27981 
 
6031 rajveer 27982 
  def __init__(self, success=None, ex=None,):
27983 
    self.success = success
6000 mandeep.dh 27984 
    self.ex = ex
27985 
 
27986 
  def read(self, iprot):
27987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27989 
      return
27990 
    iprot.readStructBegin()
27991 
    while True:
27992 
      (fname, ftype, fid) = iprot.readFieldBegin()
27993 
      if ftype == TType.STOP:
27994 
        break
6031 rajveer 27995 
      if fid == 0:
27996 
        if ftype == TType.BOOL:
27997 
          self.success = iprot.readBool();
27998 
        else:
27999 
          iprot.skip(ftype)
28000 
      elif fid == 1:
6000 mandeep.dh 28001 
        if ftype == TType.STRUCT:
28002 
          self.ex = TransactionServiceException()
28003 
          self.ex.read(iprot)
28004 
        else:
28005 
          iprot.skip(ftype)
28006 
      else:
28007 
        iprot.skip(ftype)
28008 
      iprot.readFieldEnd()
28009 
    iprot.readStructEnd()
28010 
 
28011 
  def write(self, oprot):
28012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28014 
      return
28015 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28016 
    if self.success is not None:
28017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28018 
      oprot.writeBool(self.success)
28019 
      oprot.writeFieldEnd()
6000 mandeep.dh 28020 
    if self.ex is not None:
28021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28022 
      self.ex.write(oprot)
28023 
      oprot.writeFieldEnd()
28024 
    oprot.writeFieldStop()
28025 
    oprot.writeStructEnd()
28026 
 
28027 
  def validate(self):
28028 
    return
28029 
 
28030 
 
28031 
  def __repr__(self):
28032 
    L = ['%s=%r' % (key, value)
28033 
      for key, value in self.__dict__.iteritems()]
28034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28035 
 
28036 
  def __eq__(self, other):
28037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28038 
 
28039 
  def __ne__(self, other):
28040 
    return not (self == other)
28041 
 
28042 
class activateRechargeTxn_args:
28043 
  """
28044 
  Attributes:
6031 rajveer 28045 
   - rechargeOrderId
6000 mandeep.dh 28046 
  """
28047 
 
28048 
  thrift_spec = (
28049 
    None, # 0
6031 rajveer 28050 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28051 
  )
28052 
 
6031 rajveer 28053 
  def __init__(self, rechargeOrderId=None,):
28054 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28055 
 
28056 
  def read(self, iprot):
28057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28059 
      return
28060 
    iprot.readStructBegin()
28061 
    while True:
28062 
      (fname, ftype, fid) = iprot.readFieldBegin()
28063 
      if ftype == TType.STOP:
28064 
        break
28065 
      if fid == 1:
6031 rajveer 28066 
        if ftype == TType.I64:
28067 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28068 
        else:
28069 
          iprot.skip(ftype)
28070 
      else:
28071 
        iprot.skip(ftype)
28072 
      iprot.readFieldEnd()
28073 
    iprot.readStructEnd()
28074 
 
28075 
  def write(self, oprot):
28076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28078 
      return
28079 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28080 
    if self.rechargeOrderId is not None:
28081 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28082 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28083 
      oprot.writeFieldEnd()
28084 
    oprot.writeFieldStop()
28085 
    oprot.writeStructEnd()
28086 
 
28087 
  def validate(self):
28088 
    return
28089 
 
28090 
 
28091 
  def __repr__(self):
28092 
    L = ['%s=%r' % (key, value)
28093 
      for key, value in self.__dict__.iteritems()]
28094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28095 
 
28096 
  def __eq__(self, other):
28097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28098 
 
28099 
  def __ne__(self, other):
28100 
    return not (self == other)
28101 
 
28102 
class activateRechargeTxn_result:
28103 
  """
28104 
  Attributes:
28105 
   - success
28106 
   - ex
28107 
  """
28108 
 
28109 
  thrift_spec = (
6031 rajveer 28110 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28112 
  )
28113 
 
28114 
  def __init__(self, success=None, ex=None,):
28115 
    self.success = success
28116 
    self.ex = ex
28117 
 
28118 
  def read(self, iprot):
28119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28121 
      return
28122 
    iprot.readStructBegin()
28123 
    while True:
28124 
      (fname, ftype, fid) = iprot.readFieldBegin()
28125 
      if ftype == TType.STOP:
28126 
        break
28127 
      if fid == 0:
6031 rajveer 28128 
        if ftype == TType.BOOL:
28129 
          self.success = iprot.readBool();
6000 mandeep.dh 28130 
        else:
28131 
          iprot.skip(ftype)
28132 
      elif fid == 1:
28133 
        if ftype == TType.STRUCT:
28134 
          self.ex = TransactionServiceException()
28135 
          self.ex.read(iprot)
28136 
        else:
28137 
          iprot.skip(ftype)
28138 
      else:
28139 
        iprot.skip(ftype)
28140 
      iprot.readFieldEnd()
28141 
    iprot.readStructEnd()
28142 
 
28143 
  def write(self, oprot):
28144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28146 
      return
28147 
    oprot.writeStructBegin('activateRechargeTxn_result')
28148 
    if self.success is not None:
6031 rajveer 28149 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28150 
      oprot.writeBool(self.success)
6000 mandeep.dh 28151 
      oprot.writeFieldEnd()
28152 
    if self.ex is not None:
28153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28154 
      self.ex.write(oprot)
28155 
      oprot.writeFieldEnd()
28156 
    oprot.writeFieldStop()
28157 
    oprot.writeStructEnd()
28158 
 
28159 
  def validate(self):
28160 
    return
28161 
 
28162 
 
28163 
  def __repr__(self):
28164 
    L = ['%s=%r' % (key, value)
28165 
      for key, value in self.__dict__.iteritems()]
28166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28167 
 
28168 
  def __eq__(self, other):
28169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28170 
 
28171 
  def __ne__(self, other):
28172 
    return not (self == other)
28173 
 
6031 rajveer 28174 
class getUserWallet_args:
6000 mandeep.dh 28175 
  """
28176 
  Attributes:
6031 rajveer 28177 
   - userId
6000 mandeep.dh 28178 
  """
28179 
 
28180 
  thrift_spec = (
28181 
    None, # 0
6031 rajveer 28182 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28183 
  )
28184 
 
6031 rajveer 28185 
  def __init__(self, userId=None,):
28186 
    self.userId = userId
6000 mandeep.dh 28187 
 
28188 
  def read(self, iprot):
28189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28191 
      return
28192 
    iprot.readStructBegin()
28193 
    while True:
28194 
      (fname, ftype, fid) = iprot.readFieldBegin()
28195 
      if ftype == TType.STOP:
28196 
        break
28197 
      if fid == 1:
28198 
        if ftype == TType.I64:
6031 rajveer 28199 
          self.userId = iprot.readI64();
6000 mandeep.dh 28200 
        else:
28201 
          iprot.skip(ftype)
28202 
      else:
28203 
        iprot.skip(ftype)
28204 
      iprot.readFieldEnd()
28205 
    iprot.readStructEnd()
28206 
 
28207 
  def write(self, oprot):
28208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28210 
      return
6031 rajveer 28211 
    oprot.writeStructBegin('getUserWallet_args')
28212 
    if self.userId is not None:
28213 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28214 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28215 
      oprot.writeFieldEnd()
28216 
    oprot.writeFieldStop()
28217 
    oprot.writeStructEnd()
28218 
 
28219 
  def validate(self):
28220 
    return
28221 
 
28222 
 
28223 
  def __repr__(self):
28224 
    L = ['%s=%r' % (key, value)
28225 
      for key, value in self.__dict__.iteritems()]
28226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28227 
 
28228 
  def __eq__(self, other):
28229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28230 
 
28231 
  def __ne__(self, other):
28232 
    return not (self == other)
28233 
 
6031 rajveer 28234 
class getUserWallet_result:
6000 mandeep.dh 28235 
  """
28236 
  Attributes:
28237 
   - success
28238 
  """
28239 
 
28240 
  thrift_spec = (
6031 rajveer 28241 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28242 
  )
28243 
 
28244 
  def __init__(self, success=None,):
28245 
    self.success = success
28246 
 
28247 
  def read(self, iprot):
28248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28250 
      return
28251 
    iprot.readStructBegin()
28252 
    while True:
28253 
      (fname, ftype, fid) = iprot.readFieldBegin()
28254 
      if ftype == TType.STOP:
28255 
        break
28256 
      if fid == 0:
6031 rajveer 28257 
        if ftype == TType.STRUCT:
28258 
          self.success = UserWallet()
28259 
          self.success.read(iprot)
6000 mandeep.dh 28260 
        else:
28261 
          iprot.skip(ftype)
28262 
      else:
28263 
        iprot.skip(ftype)
28264 
      iprot.readFieldEnd()
28265 
    iprot.readStructEnd()
28266 
 
28267 
  def write(self, oprot):
28268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28270 
      return
6031 rajveer 28271 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28272 
    if self.success is not None:
6031 rajveer 28273 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28274 
      self.success.write(oprot)
6000 mandeep.dh 28275 
      oprot.writeFieldEnd()
28276 
    oprot.writeFieldStop()
28277 
    oprot.writeStructEnd()
28278 
 
28279 
  def validate(self):
28280 
    return
28281 
 
28282 
 
28283 
  def __repr__(self):
28284 
    L = ['%s=%r' % (key, value)
28285 
      for key, value in self.__dict__.iteritems()]
28286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28287 
 
28288 
  def __eq__(self, other):
28289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28290 
 
28291 
  def __ne__(self, other):
28292 
    return not (self == other)
28293 
 
6031 rajveer 28294 
class getUserWalletHistory_args:
6000 mandeep.dh 28295 
  """
28296 
  Attributes:
6031 rajveer 28297 
   - userId
6000 mandeep.dh 28298 
  """
28299 
 
28300 
  thrift_spec = (
28301 
    None, # 0
6031 rajveer 28302 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28303 
  )
28304 
 
6031 rajveer 28305 
  def __init__(self, userId=None,):
28306 
    self.userId = userId
6000 mandeep.dh 28307 
 
28308 
  def read(self, iprot):
28309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28311 
      return
28312 
    iprot.readStructBegin()
28313 
    while True:
28314 
      (fname, ftype, fid) = iprot.readFieldBegin()
28315 
      if ftype == TType.STOP:
28316 
        break
28317 
      if fid == 1:
28318 
        if ftype == TType.I64:
6031 rajveer 28319 
          self.userId = iprot.readI64();
6000 mandeep.dh 28320 
        else:
28321 
          iprot.skip(ftype)
28322 
      else:
28323 
        iprot.skip(ftype)
28324 
      iprot.readFieldEnd()
28325 
    iprot.readStructEnd()
28326 
 
28327 
  def write(self, oprot):
28328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28330 
      return
6031 rajveer 28331 
    oprot.writeStructBegin('getUserWalletHistory_args')
28332 
    if self.userId is not None:
28333 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28334 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28335 
      oprot.writeFieldEnd()
28336 
    oprot.writeFieldStop()
28337 
    oprot.writeStructEnd()
28338 
 
28339 
  def validate(self):
28340 
    return
28341 
 
28342 
 
28343 
  def __repr__(self):
28344 
    L = ['%s=%r' % (key, value)
28345 
      for key, value in self.__dict__.iteritems()]
28346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28347 
 
28348 
  def __eq__(self, other):
28349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28350 
 
28351 
  def __ne__(self, other):
28352 
    return not (self == other)
28353 
 
6031 rajveer 28354 
class getUserWalletHistory_result:
6000 mandeep.dh 28355 
  """
28356 
  Attributes:
28357 
   - success
28358 
  """
28359 
 
28360 
  thrift_spec = (
6031 rajveer 28361 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28362 
  )
28363 
 
28364 
  def __init__(self, success=None,):
28365 
    self.success = success
28366 
 
28367 
  def read(self, iprot):
28368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28370 
      return
28371 
    iprot.readStructBegin()
28372 
    while True:
28373 
      (fname, ftype, fid) = iprot.readFieldBegin()
28374 
      if ftype == TType.STOP:
28375 
        break
28376 
      if fid == 0:
28377 
        if ftype == TType.LIST:
28378 
          self.success = []
6188 rajveer 28379 
          (_etype666, _size663) = iprot.readListBegin()
28380 
          for _i667 in xrange(_size663):
28381 
            _elem668 = UserWalletHistory()
28382 
            _elem668.read(iprot)
28383 
            self.success.append(_elem668)
6000 mandeep.dh 28384 
          iprot.readListEnd()
28385 
        else:
28386 
          iprot.skip(ftype)
28387 
      else:
28388 
        iprot.skip(ftype)
28389 
      iprot.readFieldEnd()
28390 
    iprot.readStructEnd()
28391 
 
28392 
  def write(self, oprot):
28393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28395 
      return
6031 rajveer 28396 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28397 
    if self.success is not None:
28398 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28399 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28400 
      for iter669 in self.success:
28401 
        iter669.write(oprot)
6000 mandeep.dh 28402 
      oprot.writeListEnd()
28403 
      oprot.writeFieldEnd()
28404 
    oprot.writeFieldStop()
28405 
    oprot.writeStructEnd()
28406 
 
28407 
  def validate(self):
28408 
    return
28409 
 
28410 
 
28411 
  def __repr__(self):
28412 
    L = ['%s=%r' % (key, value)
28413 
      for key, value in self.__dict__.iteritems()]
28414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28415 
 
28416 
  def __eq__(self, other):
28417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28418 
 
28419 
  def __ne__(self, other):
28420 
    return not (self == other)
6048 rajveer 28421 
 
6050 anupam.sin 28422 
class getRechargeOrdersForTransaction_args:
28423 
  """
28424 
  Attributes:
28425 
   - txnId
28426 
  """
28427 
 
28428 
  thrift_spec = (
28429 
    None, # 0
28430 
    (1, TType.I64, 'txnId', None, None, ), # 1
28431 
  )
28432 
 
28433 
  def __init__(self, txnId=None,):
28434 
    self.txnId = txnId
28435 
 
28436 
  def read(self, iprot):
28437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28439 
      return
28440 
    iprot.readStructBegin()
28441 
    while True:
28442 
      (fname, ftype, fid) = iprot.readFieldBegin()
28443 
      if ftype == TType.STOP:
28444 
        break
28445 
      if fid == 1:
28446 
        if ftype == TType.I64:
28447 
          self.txnId = iprot.readI64();
28448 
        else:
28449 
          iprot.skip(ftype)
28450 
      else:
28451 
        iprot.skip(ftype)
28452 
      iprot.readFieldEnd()
28453 
    iprot.readStructEnd()
28454 
 
28455 
  def write(self, oprot):
28456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28458 
      return
28459 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28460 
    if self.txnId is not None:
28461 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28462 
      oprot.writeI64(self.txnId)
28463 
      oprot.writeFieldEnd()
28464 
    oprot.writeFieldStop()
28465 
    oprot.writeStructEnd()
28466 
 
28467 
  def validate(self):
28468 
    return
28469 
 
28470 
 
28471 
  def __repr__(self):
28472 
    L = ['%s=%r' % (key, value)
28473 
      for key, value in self.__dict__.iteritems()]
28474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28475 
 
28476 
  def __eq__(self, other):
28477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28478 
 
28479 
  def __ne__(self, other):
28480 
    return not (self == other)
28481 
 
28482 
class getRechargeOrdersForTransaction_result:
28483 
  """
28484 
  Attributes:
28485 
   - success
28486 
   - ex
28487 
  """
28488 
 
28489 
  thrift_spec = (
28490 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28492 
  )
28493 
 
28494 
  def __init__(self, success=None, ex=None,):
28495 
    self.success = success
28496 
    self.ex = ex
28497 
 
28498 
  def read(self, iprot):
28499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28501 
      return
28502 
    iprot.readStructBegin()
28503 
    while True:
28504 
      (fname, ftype, fid) = iprot.readFieldBegin()
28505 
      if ftype == TType.STOP:
28506 
        break
28507 
      if fid == 0:
28508 
        if ftype == TType.STRUCT:
28509 
          self.success = RechargeOrder()
28510 
          self.success.read(iprot)
28511 
        else:
28512 
          iprot.skip(ftype)
28513 
      elif fid == 1:
28514 
        if ftype == TType.STRUCT:
28515 
          self.ex = TransactionServiceException()
28516 
          self.ex.read(iprot)
28517 
        else:
28518 
          iprot.skip(ftype)
28519 
      else:
28520 
        iprot.skip(ftype)
28521 
      iprot.readFieldEnd()
28522 
    iprot.readStructEnd()
28523 
 
28524 
  def write(self, oprot):
28525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28527 
      return
28528 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28529 
    if self.success is not None:
28530 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28531 
      self.success.write(oprot)
28532 
      oprot.writeFieldEnd()
28533 
    if self.ex is not None:
28534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28535 
      self.ex.write(oprot)
28536 
      oprot.writeFieldEnd()
28537 
    oprot.writeFieldStop()
28538 
    oprot.writeStructEnd()
28539 
 
28540 
  def validate(self):
28541 
    return
28542 
 
28543 
 
28544 
  def __repr__(self):
28545 
    L = ['%s=%r' % (key, value)
28546 
      for key, value in self.__dict__.iteritems()]
28547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28548 
 
28549 
  def __eq__(self, other):
28550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28551 
 
28552 
  def __ne__(self, other):
28553 
    return not (self == other)
28554 
 
6048 rajveer 28555 
class getServiceProviders_args:
28556 
  """
28557 
  Attributes:
28558 
   - rechargeType
6206 rajveer 28559 
   - onlyActive
6048 rajveer 28560 
  """
28561 
 
28562 
  thrift_spec = (
28563 
    None, # 0
28564 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28565 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28566 
  )
28567 
 
6206 rajveer 28568 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28569 
    self.rechargeType = rechargeType
6206 rajveer 28570 
    self.onlyActive = onlyActive
6048 rajveer 28571 
 
28572 
  def read(self, iprot):
28573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28575 
      return
28576 
    iprot.readStructBegin()
28577 
    while True:
28578 
      (fname, ftype, fid) = iprot.readFieldBegin()
28579 
      if ftype == TType.STOP:
28580 
        break
28581 
      if fid == 1:
28582 
        if ftype == TType.I32:
28583 
          self.rechargeType = iprot.readI32();
28584 
        else:
28585 
          iprot.skip(ftype)
6206 rajveer 28586 
      elif fid == 2:
28587 
        if ftype == TType.BOOL:
28588 
          self.onlyActive = iprot.readBool();
28589 
        else:
28590 
          iprot.skip(ftype)
6048 rajveer 28591 
      else:
28592 
        iprot.skip(ftype)
28593 
      iprot.readFieldEnd()
28594 
    iprot.readStructEnd()
28595 
 
28596 
  def write(self, oprot):
28597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28599 
      return
28600 
    oprot.writeStructBegin('getServiceProviders_args')
28601 
    if self.rechargeType is not None:
28602 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28603 
      oprot.writeI32(self.rechargeType)
28604 
      oprot.writeFieldEnd()
6206 rajveer 28605 
    if self.onlyActive is not None:
28606 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28607 
      oprot.writeBool(self.onlyActive)
28608 
      oprot.writeFieldEnd()
6048 rajveer 28609 
    oprot.writeFieldStop()
28610 
    oprot.writeStructEnd()
28611 
 
28612 
  def validate(self):
28613 
    return
28614 
 
28615 
 
28616 
  def __repr__(self):
28617 
    L = ['%s=%r' % (key, value)
28618 
      for key, value in self.__dict__.iteritems()]
28619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28620 
 
28621 
  def __eq__(self, other):
28622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28623 
 
28624 
  def __ne__(self, other):
28625 
    return not (self == other)
28626 
 
28627 
class getServiceProviders_result:
28628 
  """
28629 
  Attributes:
28630 
   - success
28631 
  """
28632 
 
28633 
  thrift_spec = (
28634 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28635 
  )
28636 
 
28637 
  def __init__(self, success=None,):
28638 
    self.success = success
28639 
 
28640 
  def read(self, iprot):
28641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28643 
      return
28644 
    iprot.readStructBegin()
28645 
    while True:
28646 
      (fname, ftype, fid) = iprot.readFieldBegin()
28647 
      if ftype == TType.STOP:
28648 
        break
28649 
      if fid == 0:
28650 
        if ftype == TType.MAP:
28651 
          self.success = {}
6188 rajveer 28652 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28653 
          for _i674 in xrange(_size670):
28654 
            _key675 = iprot.readI64();
28655 
            _val676 = iprot.readString();
28656 
            self.success[_key675] = _val676
6048 rajveer 28657 
          iprot.readMapEnd()
28658 
        else:
28659 
          iprot.skip(ftype)
28660 
      else:
28661 
        iprot.skip(ftype)
28662 
      iprot.readFieldEnd()
28663 
    iprot.readStructEnd()
28664 
 
28665 
  def write(self, oprot):
28666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28668 
      return
28669 
    oprot.writeStructBegin('getServiceProviders_result')
28670 
    if self.success is not None:
28671 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28672 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28673 
      for kiter677,viter678 in self.success.items():
28674 
        oprot.writeI64(kiter677)
28675 
        oprot.writeString(viter678)
6048 rajveer 28676 
      oprot.writeMapEnd()
28677 
      oprot.writeFieldEnd()
28678 
    oprot.writeFieldStop()
28679 
    oprot.writeStructEnd()
28680 
 
28681 
  def validate(self):
28682 
    return
28683 
 
28684 
 
28685 
  def __repr__(self):
28686 
    L = ['%s=%r' % (key, value)
28687 
      for key, value in self.__dict__.iteritems()]
28688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28689 
 
28690 
  def __eq__(self, other):
28691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28692 
 
28693 
  def __ne__(self, other):
28694 
    return not (self == other)
28695 
 
28696 
class getServiceProviderForDevice_args:
28697 
  """
28698 
  Attributes:
6049 rajveer 28699 
   - rechargeType
6048 rajveer 28700 
   - deviceNumber
28701 
  """
28702 
 
28703 
  thrift_spec = (
28704 
    None, # 0
6049 rajveer 28705 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28706 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28707 
  )
28708 
 
6049 rajveer 28709 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28710 
    self.rechargeType = rechargeType
6048 rajveer 28711 
    self.deviceNumber = deviceNumber
28712 
 
28713 
  def read(self, iprot):
28714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28716 
      return
28717 
    iprot.readStructBegin()
28718 
    while True:
28719 
      (fname, ftype, fid) = iprot.readFieldBegin()
28720 
      if ftype == TType.STOP:
28721 
        break
28722 
      if fid == 1:
6049 rajveer 28723 
        if ftype == TType.I32:
28724 
          self.rechargeType = iprot.readI32();
28725 
        else:
28726 
          iprot.skip(ftype)
28727 
      elif fid == 2:
6048 rajveer 28728 
        if ftype == TType.STRING:
28729 
          self.deviceNumber = iprot.readString();
28730 
        else:
28731 
          iprot.skip(ftype)
28732 
      else:
28733 
        iprot.skip(ftype)
28734 
      iprot.readFieldEnd()
28735 
    iprot.readStructEnd()
28736 
 
28737 
  def write(self, oprot):
28738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28740 
      return
28741 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28742 
    if self.rechargeType is not None:
28743 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28744 
      oprot.writeI32(self.rechargeType)
28745 
      oprot.writeFieldEnd()
6048 rajveer 28746 
    if self.deviceNumber is not None:
6049 rajveer 28747 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28748 
      oprot.writeString(self.deviceNumber)
28749 
      oprot.writeFieldEnd()
28750 
    oprot.writeFieldStop()
28751 
    oprot.writeStructEnd()
28752 
 
28753 
  def validate(self):
28754 
    return
28755 
 
28756 
 
28757 
  def __repr__(self):
28758 
    L = ['%s=%r' % (key, value)
28759 
      for key, value in self.__dict__.iteritems()]
28760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28761 
 
28762 
  def __eq__(self, other):
28763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28764 
 
28765 
  def __ne__(self, other):
28766 
    return not (self == other)
28767 
 
28768 
class getServiceProviderForDevice_result:
28769 
  """
28770 
  Attributes:
28771 
   - success
28772 
  """
28773 
 
28774 
  thrift_spec = (
6289 anupam.sin 28775 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28776 
  )
28777 
 
28778 
  def __init__(self, success=None,):
28779 
    self.success = success
28780 
 
28781 
  def read(self, iprot):
28782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28784 
      return
28785 
    iprot.readStructBegin()
28786 
    while True:
28787 
      (fname, ftype, fid) = iprot.readFieldBegin()
28788 
      if ftype == TType.STOP:
28789 
        break
28790 
      if fid == 0:
6289 anupam.sin 28791 
        if ftype == TType.STRUCT:
28792 
          self.success = DeviceNumberInfo()
28793 
          self.success.read(iprot)
6048 rajveer 28794 
        else:
28795 
          iprot.skip(ftype)
28796 
      else:
28797 
        iprot.skip(ftype)
28798 
      iprot.readFieldEnd()
28799 
    iprot.readStructEnd()
28800 
 
28801 
  def write(self, oprot):
28802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28804 
      return
28805 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28806 
    if self.success is not None:
6289 anupam.sin 28807 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28808 
      self.success.write(oprot)
6048 rajveer 28809 
      oprot.writeFieldEnd()
28810 
    oprot.writeFieldStop()
28811 
    oprot.writeStructEnd()
28812 
 
28813 
  def validate(self):
28814 
    return
28815 
 
28816 
 
28817 
  def __repr__(self):
28818 
    L = ['%s=%r' % (key, value)
28819 
      for key, value in self.__dict__.iteritems()]
28820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28821 
 
28822 
  def __eq__(self, other):
28823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28824 
 
28825 
  def __ne__(self, other):
28826 
    return not (self == other)
6094 rajveer 28827 
 
6269 rajveer 28828 
class validateRecharge_args:
28829 
  """
28830 
  Attributes:
28831 
   - rechargeType
28832 
   - deviceNumber
6307 anupam.sin 28833 
   - userSelectedProviderId
6591 anupam.sin 28834 
   - clientAddress
6269 rajveer 28835 
  """
28836 
 
28837 
  thrift_spec = (
28838 
    None, # 0
28839 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28840 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28841 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28842 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28843 
  )
28844 
 
6591 anupam.sin 28845 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28846 
    self.rechargeType = rechargeType
28847 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28848 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28849 
    self.clientAddress = clientAddress
6269 rajveer 28850 
 
28851 
  def read(self, iprot):
28852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28854 
      return
28855 
    iprot.readStructBegin()
28856 
    while True:
28857 
      (fname, ftype, fid) = iprot.readFieldBegin()
28858 
      if ftype == TType.STOP:
28859 
        break
28860 
      if fid == 1:
28861 
        if ftype == TType.I32:
28862 
          self.rechargeType = iprot.readI32();
28863 
        else:
28864 
          iprot.skip(ftype)
28865 
      elif fid == 2:
28866 
        if ftype == TType.STRING:
28867 
          self.deviceNumber = iprot.readString();
28868 
        else:
28869 
          iprot.skip(ftype)
6307 anupam.sin 28870 
      elif fid == 3:
28871 
        if ftype == TType.I64:
28872 
          self.userSelectedProviderId = iprot.readI64();
28873 
        else:
28874 
          iprot.skip(ftype)
6591 anupam.sin 28875 
      elif fid == 4:
28876 
        if ftype == TType.STRING:
28877 
          self.clientAddress = iprot.readString();
28878 
        else:
28879 
          iprot.skip(ftype)
6269 rajveer 28880 
      else:
28881 
        iprot.skip(ftype)
28882 
      iprot.readFieldEnd()
28883 
    iprot.readStructEnd()
28884 
 
28885 
  def write(self, oprot):
28886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28888 
      return
28889 
    oprot.writeStructBegin('validateRecharge_args')
28890 
    if self.rechargeType is not None:
28891 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28892 
      oprot.writeI32(self.rechargeType)
28893 
      oprot.writeFieldEnd()
28894 
    if self.deviceNumber is not None:
28895 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28896 
      oprot.writeString(self.deviceNumber)
28897 
      oprot.writeFieldEnd()
6307 anupam.sin 28898 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28899 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28900 
      oprot.writeI64(self.userSelectedProviderId)
28901 
      oprot.writeFieldEnd()
6591 anupam.sin 28902 
    if self.clientAddress is not None:
28903 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28904 
      oprot.writeString(self.clientAddress)
28905 
      oprot.writeFieldEnd()
6269 rajveer 28906 
    oprot.writeFieldStop()
28907 
    oprot.writeStructEnd()
28908 
 
28909 
  def validate(self):
28910 
    return
28911 
 
28912 
 
28913 
  def __repr__(self):
28914 
    L = ['%s=%r' % (key, value)
28915 
      for key, value in self.__dict__.iteritems()]
28916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28917 
 
28918 
  def __eq__(self, other):
28919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28920 
 
28921 
  def __ne__(self, other):
28922 
    return not (self == other)
28923 
 
28924 
class validateRecharge_result:
28925 
  """
28926 
  Attributes:
28927 
   - success
28928 
  """
28929 
 
28930 
  thrift_spec = (
28931 
    (0, TType.STRING, 'success', None, None, ), # 0
28932 
  )
28933 
 
28934 
  def __init__(self, success=None,):
28935 
    self.success = success
28936 
 
28937 
  def read(self, iprot):
28938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28940 
      return
28941 
    iprot.readStructBegin()
28942 
    while True:
28943 
      (fname, ftype, fid) = iprot.readFieldBegin()
28944 
      if ftype == TType.STOP:
28945 
        break
28946 
      if fid == 0:
28947 
        if ftype == TType.STRING:
28948 
          self.success = iprot.readString();
28949 
        else:
28950 
          iprot.skip(ftype)
28951 
      else:
28952 
        iprot.skip(ftype)
28953 
      iprot.readFieldEnd()
28954 
    iprot.readStructEnd()
28955 
 
28956 
  def write(self, oprot):
28957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28959 
      return
28960 
    oprot.writeStructBegin('validateRecharge_result')
28961 
    if self.success is not None:
28962 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28963 
      oprot.writeString(self.success)
28964 
      oprot.writeFieldEnd()
28965 
    oprot.writeFieldStop()
28966 
    oprot.writeStructEnd()
28967 
 
28968 
  def validate(self):
28969 
    return
28970 
 
28971 
 
28972 
  def __repr__(self):
28973 
    L = ['%s=%r' % (key, value)
28974 
      for key, value in self.__dict__.iteritems()]
28975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28976 
 
28977 
  def __eq__(self, other):
28978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28979 
 
28980 
  def __ne__(self, other):
28981 
    return not (self == other)
28982 
 
6094 rajveer 28983 
class getRechargeOrdersForDevice_args:
28984 
  """
28985 
  Attributes:
28986 
   - deviceNumber
28987 
  """
28988 
 
28989 
  thrift_spec = (
28990 
    None, # 0
28991 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28992 
  )
28993 
 
28994 
  def __init__(self, deviceNumber=None,):
28995 
    self.deviceNumber = deviceNumber
28996 
 
28997 
  def read(self, iprot):
28998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29000 
      return
29001 
    iprot.readStructBegin()
29002 
    while True:
29003 
      (fname, ftype, fid) = iprot.readFieldBegin()
29004 
      if ftype == TType.STOP:
29005 
        break
29006 
      if fid == 1:
29007 
        if ftype == TType.STRING:
29008 
          self.deviceNumber = iprot.readString();
29009 
        else:
29010 
          iprot.skip(ftype)
29011 
      else:
29012 
        iprot.skip(ftype)
29013 
      iprot.readFieldEnd()
29014 
    iprot.readStructEnd()
29015 
 
29016 
  def write(self, oprot):
29017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29019 
      return
29020 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29021 
    if self.deviceNumber is not None:
29022 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29023 
      oprot.writeString(self.deviceNumber)
29024 
      oprot.writeFieldEnd()
29025 
    oprot.writeFieldStop()
29026 
    oprot.writeStructEnd()
29027 
 
29028 
  def validate(self):
29029 
    return
29030 
 
29031 
 
29032 
  def __repr__(self):
29033 
    L = ['%s=%r' % (key, value)
29034 
      for key, value in self.__dict__.iteritems()]
29035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29036 
 
29037 
  def __eq__(self, other):
29038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29039 
 
29040 
  def __ne__(self, other):
29041 
    return not (self == other)
29042 
 
29043 
class getRechargeOrdersForDevice_result:
29044 
  """
29045 
  Attributes:
29046 
   - success
29047 
  """
29048 
 
29049 
  thrift_spec = (
29050 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29051 
  )
29052 
 
29053 
  def __init__(self, success=None,):
29054 
    self.success = success
29055 
 
29056 
  def read(self, iprot):
29057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29059 
      return
29060 
    iprot.readStructBegin()
29061 
    while True:
29062 
      (fname, ftype, fid) = iprot.readFieldBegin()
29063 
      if ftype == TType.STOP:
29064 
        break
29065 
      if fid == 0:
29066 
        if ftype == TType.LIST:
29067 
          self.success = []
6188 rajveer 29068 
          (_etype682, _size679) = iprot.readListBegin()
29069 
          for _i683 in xrange(_size679):
29070 
            _elem684 = RechargeOrder()
29071 
            _elem684.read(iprot)
29072 
            self.success.append(_elem684)
6094 rajveer 29073 
          iprot.readListEnd()
29074 
        else:
29075 
          iprot.skip(ftype)
29076 
      else:
29077 
        iprot.skip(ftype)
29078 
      iprot.readFieldEnd()
29079 
    iprot.readStructEnd()
29080 
 
29081 
  def write(self, oprot):
29082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29084 
      return
29085 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29086 
    if self.success is not None:
29087 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29088 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29089 
      for iter685 in self.success:
29090 
        iter685.write(oprot)
6094 rajveer 29091 
      oprot.writeListEnd()
29092 
      oprot.writeFieldEnd()
29093 
    oprot.writeFieldStop()
29094 
    oprot.writeStructEnd()
29095 
 
29096 
  def validate(self):
29097 
    return
29098 
 
29099 
 
29100 
  def __repr__(self):
29101 
    L = ['%s=%r' % (key, value)
29102 
      for key, value in self.__dict__.iteritems()]
29103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29104 
 
29105 
  def __eq__(self, other):
29106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29107 
 
29108 
  def __ne__(self, other):
29109 
    return not (self == other)
29110 
 
29111 
class addAmountToWallet_args:
29112 
  """
29113 
  Attributes:
29114 
   - userId
29115 
   - orderId
29116 
   - amount
29117 
  """
29118 
 
29119 
  thrift_spec = (
29120 
    None, # 0
29121 
    (1, TType.I64, 'userId', None, None, ), # 1
29122 
    (2, TType.I64, 'orderId', None, None, ), # 2
29123 
    (3, TType.I64, 'amount', None, None, ), # 3
29124 
  )
29125 
 
29126 
  def __init__(self, userId=None, orderId=None, amount=None,):
29127 
    self.userId = userId
29128 
    self.orderId = orderId
29129 
    self.amount = amount
29130 
 
29131 
  def read(self, iprot):
29132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29134 
      return
29135 
    iprot.readStructBegin()
29136 
    while True:
29137 
      (fname, ftype, fid) = iprot.readFieldBegin()
29138 
      if ftype == TType.STOP:
29139 
        break
29140 
      if fid == 1:
29141 
        if ftype == TType.I64:
29142 
          self.userId = iprot.readI64();
29143 
        else:
29144 
          iprot.skip(ftype)
29145 
      elif fid == 2:
29146 
        if ftype == TType.I64:
29147 
          self.orderId = iprot.readI64();
29148 
        else:
29149 
          iprot.skip(ftype)
29150 
      elif fid == 3:
29151 
        if ftype == TType.I64:
29152 
          self.amount = iprot.readI64();
29153 
        else:
29154 
          iprot.skip(ftype)
29155 
      else:
29156 
        iprot.skip(ftype)
29157 
      iprot.readFieldEnd()
29158 
    iprot.readStructEnd()
29159 
 
29160 
  def write(self, oprot):
29161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29163 
      return
29164 
    oprot.writeStructBegin('addAmountToWallet_args')
29165 
    if self.userId is not None:
29166 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29167 
      oprot.writeI64(self.userId)
29168 
      oprot.writeFieldEnd()
29169 
    if self.orderId is not None:
29170 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29171 
      oprot.writeI64(self.orderId)
29172 
      oprot.writeFieldEnd()
29173 
    if self.amount is not None:
29174 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29175 
      oprot.writeI64(self.amount)
29176 
      oprot.writeFieldEnd()
29177 
    oprot.writeFieldStop()
29178 
    oprot.writeStructEnd()
29179 
 
29180 
  def validate(self):
29181 
    return
29182 
 
29183 
 
29184 
  def __repr__(self):
29185 
    L = ['%s=%r' % (key, value)
29186 
      for key, value in self.__dict__.iteritems()]
29187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29188 
 
29189 
  def __eq__(self, other):
29190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29191 
 
29192 
  def __ne__(self, other):
29193 
    return not (self == other)
29194 
 
29195 
class addAmountToWallet_result:
29196 
 
29197 
  thrift_spec = (
29198 
  )
29199 
 
29200 
  def read(self, iprot):
29201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29203 
      return
29204 
    iprot.readStructBegin()
29205 
    while True:
29206 
      (fname, ftype, fid) = iprot.readFieldBegin()
29207 
      if ftype == TType.STOP:
29208 
        break
29209 
      else:
29210 
        iprot.skip(ftype)
29211 
      iprot.readFieldEnd()
29212 
    iprot.readStructEnd()
29213 
 
29214 
  def write(self, oprot):
29215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29217 
      return
29218 
    oprot.writeStructBegin('addAmountToWallet_result')
29219 
    oprot.writeFieldStop()
29220 
    oprot.writeStructEnd()
29221 
 
29222 
  def validate(self):
29223 
    return
29224 
 
29225 
 
29226 
  def __repr__(self):
29227 
    L = ['%s=%r' % (key, value)
29228 
      for key, value in self.__dict__.iteritems()]
29229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29230 
 
29231 
  def __eq__(self, other):
29232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29233 
 
29234 
  def __ne__(self, other):
29235 
    return not (self == other)
6154 rajveer 29236 
 
6188 rajveer 29237 
class getRechargeStatistics_args:
29238 
 
29239 
  thrift_spec = (
29240 
  )
29241 
 
29242 
  def read(self, iprot):
29243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29245 
      return
29246 
    iprot.readStructBegin()
29247 
    while True:
29248 
      (fname, ftype, fid) = iprot.readFieldBegin()
29249 
      if ftype == TType.STOP:
29250 
        break
29251 
      else:
29252 
        iprot.skip(ftype)
29253 
      iprot.readFieldEnd()
29254 
    iprot.readStructEnd()
29255 
 
29256 
  def write(self, oprot):
29257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29259 
      return
29260 
    oprot.writeStructBegin('getRechargeStatistics_args')
29261 
    oprot.writeFieldStop()
29262 
    oprot.writeStructEnd()
29263 
 
29264 
  def validate(self):
29265 
    return
29266 
 
29267 
 
29268 
  def __repr__(self):
29269 
    L = ['%s=%r' % (key, value)
29270 
      for key, value in self.__dict__.iteritems()]
29271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29272 
 
29273 
  def __eq__(self, other):
29274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29275 
 
29276 
  def __ne__(self, other):
29277 
    return not (self == other)
29278 
 
29279 
class getRechargeStatistics_result:
29280 
  """
29281 
  Attributes:
29282 
   - success
29283 
  """
29284 
 
29285 
  thrift_spec = (
29286 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29287 
  )
29288 
 
29289 
  def __init__(self, success=None,):
29290 
    self.success = success
29291 
 
29292 
  def read(self, iprot):
29293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29295 
      return
29296 
    iprot.readStructBegin()
29297 
    while True:
29298 
      (fname, ftype, fid) = iprot.readFieldBegin()
29299 
      if ftype == TType.STOP:
29300 
        break
29301 
      if fid == 0:
29302 
        if ftype == TType.STRUCT:
29303 
          self.success = RechargeStatistics()
29304 
          self.success.read(iprot)
29305 
        else:
29306 
          iprot.skip(ftype)
29307 
      else:
29308 
        iprot.skip(ftype)
29309 
      iprot.readFieldEnd()
29310 
    iprot.readStructEnd()
29311 
 
29312 
  def write(self, oprot):
29313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29315 
      return
29316 
    oprot.writeStructBegin('getRechargeStatistics_result')
29317 
    if self.success is not None:
29318 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29319 
      self.success.write(oprot)
29320 
      oprot.writeFieldEnd()
29321 
    oprot.writeFieldStop()
29322 
    oprot.writeStructEnd()
29323 
 
29324 
  def validate(self):
29325 
    return
29326 
 
29327 
 
29328 
  def __repr__(self):
29329 
    L = ['%s=%r' % (key, value)
29330 
      for key, value in self.__dict__.iteritems()]
29331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29332 
 
29333 
  def __eq__(self, other):
29334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29335 
 
29336 
  def __ne__(self, other):
29337 
    return not (self == other)
29338 
 
6154 rajveer 29339 
class getRechargeOrdersForStatus_args:
29340 
  """
29341 
  Attributes:
29342 
   - status
29343 
  """
29344 
 
29345 
  thrift_spec = (
29346 
    None, # 0
29347 
    (1, TType.I64, 'status', None, None, ), # 1
29348 
  )
29349 
 
29350 
  def __init__(self, status=None,):
29351 
    self.status = status
29352 
 
29353 
  def read(self, iprot):
29354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29356 
      return
29357 
    iprot.readStructBegin()
29358 
    while True:
29359 
      (fname, ftype, fid) = iprot.readFieldBegin()
29360 
      if ftype == TType.STOP:
29361 
        break
29362 
      if fid == 1:
29363 
        if ftype == TType.I64:
29364 
          self.status = iprot.readI64();
29365 
        else:
29366 
          iprot.skip(ftype)
29367 
      else:
29368 
        iprot.skip(ftype)
29369 
      iprot.readFieldEnd()
29370 
    iprot.readStructEnd()
29371 
 
29372 
  def write(self, oprot):
29373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29375 
      return
29376 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29377 
    if self.status is not None:
29378 
      oprot.writeFieldBegin('status', TType.I64, 1)
29379 
      oprot.writeI64(self.status)
29380 
      oprot.writeFieldEnd()
29381 
    oprot.writeFieldStop()
29382 
    oprot.writeStructEnd()
29383 
 
29384 
  def validate(self):
29385 
    return
29386 
 
29387 
 
29388 
  def __repr__(self):
29389 
    L = ['%s=%r' % (key, value)
29390 
      for key, value in self.__dict__.iteritems()]
29391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29392 
 
29393 
  def __eq__(self, other):
29394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29395 
 
29396 
  def __ne__(self, other):
29397 
    return not (self == other)
29398 
 
29399 
class getRechargeOrdersForStatus_result:
29400 
  """
29401 
  Attributes:
29402 
   - success
29403 
  """
29404 
 
29405 
  thrift_spec = (
29406 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29407 
  )
29408 
 
29409 
  def __init__(self, success=None,):
29410 
    self.success = success
29411 
 
29412 
  def read(self, iprot):
29413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29415 
      return
29416 
    iprot.readStructBegin()
29417 
    while True:
29418 
      (fname, ftype, fid) = iprot.readFieldBegin()
29419 
      if ftype == TType.STOP:
29420 
        break
29421 
      if fid == 0:
29422 
        if ftype == TType.LIST:
29423 
          self.success = []
6188 rajveer 29424 
          (_etype689, _size686) = iprot.readListBegin()
29425 
          for _i690 in xrange(_size686):
29426 
            _elem691 = RechargeOrder()
29427 
            _elem691.read(iprot)
29428 
            self.success.append(_elem691)
6154 rajveer 29429 
          iprot.readListEnd()
29430 
        else:
29431 
          iprot.skip(ftype)
29432 
      else:
29433 
        iprot.skip(ftype)
29434 
      iprot.readFieldEnd()
29435 
    iprot.readStructEnd()
29436 
 
29437 
  def write(self, oprot):
29438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29440 
      return
29441 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29442 
    if self.success is not None:
29443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29444 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29445 
      for iter692 in self.success:
29446 
        iter692.write(oprot)
6154 rajveer 29447 
      oprot.writeListEnd()
29448 
      oprot.writeFieldEnd()
29449 
    oprot.writeFieldStop()
29450 
    oprot.writeStructEnd()
29451 
 
29452 
  def validate(self):
29453 
    return
29454 
 
29455 
 
29456 
  def __repr__(self):
29457 
    L = ['%s=%r' % (key, value)
29458 
      for key, value in self.__dict__.iteritems()]
29459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29460 
 
29461 
  def __eq__(self, other):
29462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29463 
 
29464 
  def __ne__(self, other):
29465 
    return not (self == other)
6159 rajveer 29466 
 
29467 
class getPlansForOperator_args:
29468 
  """
29469 
  Attributes:
29470 
   - operatorId
29471 
  """
29472 
 
29473 
  thrift_spec = (
29474 
    None, # 0
29475 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29476 
  )
29477 
 
29478 
  def __init__(self, operatorId=None,):
29479 
    self.operatorId = operatorId
29480 
 
29481 
  def read(self, iprot):
29482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29484 
      return
29485 
    iprot.readStructBegin()
29486 
    while True:
29487 
      (fname, ftype, fid) = iprot.readFieldBegin()
29488 
      if ftype == TType.STOP:
29489 
        break
29490 
      if fid == 1:
29491 
        if ftype == TType.I64:
29492 
          self.operatorId = iprot.readI64();
29493 
        else:
29494 
          iprot.skip(ftype)
29495 
      else:
29496 
        iprot.skip(ftype)
29497 
      iprot.readFieldEnd()
29498 
    iprot.readStructEnd()
29499 
 
29500 
  def write(self, oprot):
29501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29503 
      return
29504 
    oprot.writeStructBegin('getPlansForOperator_args')
29505 
    if self.operatorId is not None:
29506 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29507 
      oprot.writeI64(self.operatorId)
29508 
      oprot.writeFieldEnd()
29509 
    oprot.writeFieldStop()
29510 
    oprot.writeStructEnd()
29511 
 
29512 
  def validate(self):
29513 
    return
29514 
 
29515 
 
29516 
  def __repr__(self):
29517 
    L = ['%s=%r' % (key, value)
29518 
      for key, value in self.__dict__.iteritems()]
29519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29520 
 
29521 
  def __eq__(self, other):
29522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29523 
 
29524 
  def __ne__(self, other):
29525 
    return not (self == other)
29526 
 
29527 
class getPlansForOperator_result:
29528 
  """
29529 
  Attributes:
29530 
   - success
29531 
  """
29532 
 
29533 
  thrift_spec = (
29534 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29535 
  )
29536 
 
29537 
  def __init__(self, success=None,):
29538 
    self.success = success
29539 
 
29540 
  def read(self, iprot):
29541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29543 
      return
29544 
    iprot.readStructBegin()
29545 
    while True:
29546 
      (fname, ftype, fid) = iprot.readFieldBegin()
29547 
      if ftype == TType.STOP:
29548 
        break
29549 
      if fid == 0:
29550 
        if ftype == TType.LIST:
29551 
          self.success = []
6188 rajveer 29552 
          (_etype696, _size693) = iprot.readListBegin()
29553 
          for _i697 in xrange(_size693):
29554 
            _elem698 = RechargePlan()
29555 
            _elem698.read(iprot)
29556 
            self.success.append(_elem698)
6159 rajveer 29557 
          iprot.readListEnd()
29558 
        else:
29559 
          iprot.skip(ftype)
29560 
      else:
29561 
        iprot.skip(ftype)
29562 
      iprot.readFieldEnd()
29563 
    iprot.readStructEnd()
29564 
 
29565 
  def write(self, oprot):
29566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29568 
      return
29569 
    oprot.writeStructBegin('getPlansForOperator_result')
29570 
    if self.success is not None:
29571 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29572 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29573 
      for iter699 in self.success:
29574 
        iter699.write(oprot)
6159 rajveer 29575 
      oprot.writeListEnd()
29576 
      oprot.writeFieldEnd()
29577 
    oprot.writeFieldStop()
29578 
    oprot.writeStructEnd()
29579 
 
29580 
  def validate(self):
29581 
    return
29582 
 
29583 
 
29584 
  def __repr__(self):
29585 
    L = ['%s=%r' % (key, value)
29586 
      for key, value in self.__dict__.iteritems()]
29587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29588 
 
29589 
  def __eq__(self, other):
29590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29591 
 
29592 
  def __ne__(self, other):
29593 
    return not (self == other)
6289 anupam.sin 29594 
 
29595 
class getRechargeDenominations_args:
29596 
  """
29597 
  Attributes:
29598 
   - operatorId
6307 anupam.sin 29599 
   - circleCode
6289 anupam.sin 29600 
   - denominationType
29601 
  """
29602 
 
29603 
  thrift_spec = (
29604 
    None, # 0
29605 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29606 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29607 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29608 
  )
29609 
 
6307 anupam.sin 29610 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29611 
    self.operatorId = operatorId
6307 anupam.sin 29612 
    self.circleCode = circleCode
6289 anupam.sin 29613 
    self.denominationType = denominationType
29614 
 
29615 
  def read(self, iprot):
29616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29618 
      return
29619 
    iprot.readStructBegin()
29620 
    while True:
29621 
      (fname, ftype, fid) = iprot.readFieldBegin()
29622 
      if ftype == TType.STOP:
29623 
        break
29624 
      if fid == 1:
29625 
        if ftype == TType.I64:
29626 
          self.operatorId = iprot.readI64();
29627 
        else:
29628 
          iprot.skip(ftype)
29629 
      elif fid == 2:
29630 
        if ftype == TType.STRING:
6307 anupam.sin 29631 
          self.circleCode = iprot.readString();
6289 anupam.sin 29632 
        else:
29633 
          iprot.skip(ftype)
29634 
      elif fid == 3:
29635 
        if ftype == TType.I32:
29636 
          self.denominationType = iprot.readI32();
29637 
        else:
29638 
          iprot.skip(ftype)
29639 
      else:
29640 
        iprot.skip(ftype)
29641 
      iprot.readFieldEnd()
29642 
    iprot.readStructEnd()
29643 
 
29644 
  def write(self, oprot):
29645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29647 
      return
29648 
    oprot.writeStructBegin('getRechargeDenominations_args')
29649 
    if self.operatorId is not None:
29650 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29651 
      oprot.writeI64(self.operatorId)
29652 
      oprot.writeFieldEnd()
6307 anupam.sin 29653 
    if self.circleCode is not None:
29654 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29655 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29656 
      oprot.writeFieldEnd()
29657 
    if self.denominationType is not None:
29658 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29659 
      oprot.writeI32(self.denominationType)
29660 
      oprot.writeFieldEnd()
29661 
    oprot.writeFieldStop()
29662 
    oprot.writeStructEnd()
29663 
 
29664 
  def validate(self):
29665 
    return
29666 
 
29667 
 
29668 
  def __repr__(self):
29669 
    L = ['%s=%r' % (key, value)
29670 
      for key, value in self.__dict__.iteritems()]
29671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29672 
 
29673 
  def __eq__(self, other):
29674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29675 
 
29676 
  def __ne__(self, other):
29677 
    return not (self == other)
29678 
 
29679 
class getRechargeDenominations_result:
29680 
  """
29681 
  Attributes:
29682 
   - success
29683 
   - ex
29684 
  """
29685 
 
29686 
  thrift_spec = (
29687 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29689 
  )
29690 
 
29691 
  def __init__(self, success=None, ex=None,):
29692 
    self.success = success
29693 
    self.ex = ex
29694 
 
29695 
  def read(self, iprot):
29696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29698 
      return
29699 
    iprot.readStructBegin()
29700 
    while True:
29701 
      (fname, ftype, fid) = iprot.readFieldBegin()
29702 
      if ftype == TType.STOP:
29703 
        break
29704 
      if fid == 0:
29705 
        if ftype == TType.LIST:
29706 
          self.success = []
29707 
          (_etype703, _size700) = iprot.readListBegin()
29708 
          for _i704 in xrange(_size700):
29709 
            _elem705 = RechargeDenomination()
29710 
            _elem705.read(iprot)
29711 
            self.success.append(_elem705)
29712 
          iprot.readListEnd()
29713 
        else:
29714 
          iprot.skip(ftype)
29715 
      elif fid == 1:
29716 
        if ftype == TType.STRUCT:
29717 
          self.ex = TransactionServiceException()
29718 
          self.ex.read(iprot)
29719 
        else:
29720 
          iprot.skip(ftype)
29721 
      else:
29722 
        iprot.skip(ftype)
29723 
      iprot.readFieldEnd()
29724 
    iprot.readStructEnd()
29725 
 
29726 
  def write(self, oprot):
29727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29729 
      return
29730 
    oprot.writeStructBegin('getRechargeDenominations_result')
29731 
    if self.success is not None:
29732 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29733 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29734 
      for iter706 in self.success:
29735 
        iter706.write(oprot)
29736 
      oprot.writeListEnd()
29737 
      oprot.writeFieldEnd()
29738 
    if self.ex is not None:
29739 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29740 
      self.ex.write(oprot)
29741 
      oprot.writeFieldEnd()
29742 
    oprot.writeFieldStop()
29743 
    oprot.writeStructEnd()
29744 
 
29745 
  def validate(self):
29746 
    return
29747 
 
29748 
 
29749 
  def __repr__(self):
29750 
    L = ['%s=%r' % (key, value)
29751 
      for key, value in self.__dict__.iteritems()]
29752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29753 
 
29754 
  def __eq__(self, other):
29755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29756 
 
29757 
  def __ne__(self, other):
29758 
    return not (self == other)
6371 rajveer 29759 
 
29760 
class updateAvailabilityStatus_args:
29761 
  """
29762 
  Attributes:
29763 
   - operatorId
29764 
   - circleId
29765 
   - isAvailable
29766 
  """
29767 
 
29768 
  thrift_spec = (
29769 
    None, # 0
29770 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29771 
    (2, TType.I64, 'circleId', None, None, ), # 2
29772 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29773 
  )
29774 
 
29775 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29776 
    self.operatorId = operatorId
29777 
    self.circleId = circleId
29778 
    self.isAvailable = isAvailable
29779 
 
29780 
  def read(self, iprot):
29781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29783 
      return
29784 
    iprot.readStructBegin()
29785 
    while True:
29786 
      (fname, ftype, fid) = iprot.readFieldBegin()
29787 
      if ftype == TType.STOP:
29788 
        break
29789 
      if fid == 1:
29790 
        if ftype == TType.I64:
29791 
          self.operatorId = iprot.readI64();
29792 
        else:
29793 
          iprot.skip(ftype)
29794 
      elif fid == 2:
29795 
        if ftype == TType.I64:
29796 
          self.circleId = iprot.readI64();
29797 
        else:
29798 
          iprot.skip(ftype)
29799 
      elif fid == 3:
29800 
        if ftype == TType.BOOL:
29801 
          self.isAvailable = iprot.readBool();
29802 
        else:
29803 
          iprot.skip(ftype)
29804 
      else:
29805 
        iprot.skip(ftype)
29806 
      iprot.readFieldEnd()
29807 
    iprot.readStructEnd()
29808 
 
29809 
  def write(self, oprot):
29810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29812 
      return
29813 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29814 
    if self.operatorId is not None:
29815 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29816 
      oprot.writeI64(self.operatorId)
29817 
      oprot.writeFieldEnd()
29818 
    if self.circleId is not None:
29819 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29820 
      oprot.writeI64(self.circleId)
29821 
      oprot.writeFieldEnd()
29822 
    if self.isAvailable is not None:
29823 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29824 
      oprot.writeBool(self.isAvailable)
29825 
      oprot.writeFieldEnd()
29826 
    oprot.writeFieldStop()
29827 
    oprot.writeStructEnd()
29828 
 
29829 
  def validate(self):
29830 
    return
29831 
 
29832 
 
29833 
  def __repr__(self):
29834 
    L = ['%s=%r' % (key, value)
29835 
      for key, value in self.__dict__.iteritems()]
29836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29837 
 
29838 
  def __eq__(self, other):
29839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29840 
 
29841 
  def __ne__(self, other):
29842 
    return not (self == other)
29843 
 
29844 
class updateAvailabilityStatus_result:
29845 
 
29846 
  thrift_spec = (
29847 
  )
29848 
 
29849 
  def read(self, iprot):
29850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29852 
      return
29853 
    iprot.readStructBegin()
29854 
    while True:
29855 
      (fname, ftype, fid) = iprot.readFieldBegin()
29856 
      if ftype == TType.STOP:
29857 
        break
29858 
      else:
29859 
        iprot.skip(ftype)
29860 
      iprot.readFieldEnd()
29861 
    iprot.readStructEnd()
29862 
 
29863 
  def write(self, oprot):
29864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29866 
      return
29867 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29868 
    oprot.writeFieldStop()
29869 
    oprot.writeStructEnd()
29870 
 
29871 
  def validate(self):
29872 
    return
29873 
 
29874 
 
29875 
  def __repr__(self):
29876 
    L = ['%s=%r' % (key, value)
29877 
      for key, value in self.__dict__.iteritems()]
29878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29879 
 
29880 
  def __eq__(self, other):
29881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29882 
 
29883 
  def __ne__(self, other):
29884 
    return not (self == other)
6389 rajveer 29885 
 
29886 
class getAvailableEmiSchemes_args:
29887 
 
29888 
  thrift_spec = (
29889 
  )
29890 
 
29891 
  def read(self, iprot):
29892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29894 
      return
29895 
    iprot.readStructBegin()
29896 
    while True:
29897 
      (fname, ftype, fid) = iprot.readFieldBegin()
29898 
      if ftype == TType.STOP:
29899 
        break
29900 
      else:
29901 
        iprot.skip(ftype)
29902 
      iprot.readFieldEnd()
29903 
    iprot.readStructEnd()
29904 
 
29905 
  def write(self, oprot):
29906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29908 
      return
29909 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29910 
    oprot.writeFieldStop()
29911 
    oprot.writeStructEnd()
29912 
 
29913 
  def validate(self):
29914 
    return
29915 
 
29916 
 
29917 
  def __repr__(self):
29918 
    L = ['%s=%r' % (key, value)
29919 
      for key, value in self.__dict__.iteritems()]
29920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29921 
 
29922 
  def __eq__(self, other):
29923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29924 
 
29925 
  def __ne__(self, other):
29926 
    return not (self == other)
29927 
 
29928 
class getAvailableEmiSchemes_result:
29929 
  """
29930 
  Attributes:
29931 
   - success
29932 
  """
29933 
 
29934 
  thrift_spec = (
29935 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29936 
  )
29937 
 
29938 
  def __init__(self, success=None,):
29939 
    self.success = success
29940 
 
29941 
  def read(self, iprot):
29942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29944 
      return
29945 
    iprot.readStructBegin()
29946 
    while True:
29947 
      (fname, ftype, fid) = iprot.readFieldBegin()
29948 
      if ftype == TType.STOP:
29949 
        break
29950 
      if fid == 0:
29951 
        if ftype == TType.LIST:
29952 
          self.success = []
29953 
          (_etype710, _size707) = iprot.readListBegin()
29954 
          for _i711 in xrange(_size707):
29955 
            _elem712 = EmiScheme()
29956 
            _elem712.read(iprot)
29957 
            self.success.append(_elem712)
29958 
          iprot.readListEnd()
29959 
        else:
29960 
          iprot.skip(ftype)
29961 
      else:
29962 
        iprot.skip(ftype)
29963 
      iprot.readFieldEnd()
29964 
    iprot.readStructEnd()
29965 
 
29966 
  def write(self, oprot):
29967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29969 
      return
29970 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29971 
    if self.success is not None:
29972 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29973 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29974 
      for iter713 in self.success:
29975 
        iter713.write(oprot)
29976 
      oprot.writeListEnd()
29977 
      oprot.writeFieldEnd()
29978 
    oprot.writeFieldStop()
29979 
    oprot.writeStructEnd()
29980 
 
29981 
  def validate(self):
29982 
    return
29983 
 
29984 
 
29985 
  def __repr__(self):
29986 
    L = ['%s=%r' % (key, value)
29987 
      for key, value in self.__dict__.iteritems()]
29988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29989 
 
29990 
  def __eq__(self, other):
29991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29992 
 
29993 
  def __ne__(self, other):
29994 
    return not (self == other)
29995 
 
29996 
class getMiscCharges_args:
29997 
  """
29998 
  Attributes:
29999 
   - transactionId
30000 
  """
30001 
 
30002 
  thrift_spec = (
30003 
    None, # 0
30004 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30005 
  )
30006 
 
30007 
  def __init__(self, transactionId=None,):
30008 
    self.transactionId = transactionId
30009 
 
30010 
  def read(self, iprot):
30011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30013 
      return
30014 
    iprot.readStructBegin()
30015 
    while True:
30016 
      (fname, ftype, fid) = iprot.readFieldBegin()
30017 
      if ftype == TType.STOP:
30018 
        break
30019 
      if fid == 1:
30020 
        if ftype == TType.I64:
30021 
          self.transactionId = iprot.readI64();
30022 
        else:
30023 
          iprot.skip(ftype)
30024 
      else:
30025 
        iprot.skip(ftype)
30026 
      iprot.readFieldEnd()
30027 
    iprot.readStructEnd()
30028 
 
30029 
  def write(self, oprot):
30030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30032 
      return
30033 
    oprot.writeStructBegin('getMiscCharges_args')
30034 
    if self.transactionId is not None:
30035 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30036 
      oprot.writeI64(self.transactionId)
30037 
      oprot.writeFieldEnd()
30038 
    oprot.writeFieldStop()
30039 
    oprot.writeStructEnd()
30040 
 
30041 
  def validate(self):
30042 
    return
30043 
 
30044 
 
30045 
  def __repr__(self):
30046 
    L = ['%s=%r' % (key, value)
30047 
      for key, value in self.__dict__.iteritems()]
30048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30049 
 
30050 
  def __eq__(self, other):
30051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30052 
 
30053 
  def __ne__(self, other):
30054 
    return not (self == other)
30055 
 
30056 
class getMiscCharges_result:
30057 
  """
30058 
  Attributes:
30059 
   - success
30060 
  """
30061 
 
30062 
  thrift_spec = (
6412 rajveer 30063 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30064 
  )
30065 
 
30066 
  def __init__(self, success=None,):
30067 
    self.success = success
30068 
 
30069 
  def read(self, iprot):
30070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30072 
      return
30073 
    iprot.readStructBegin()
30074 
    while True:
30075 
      (fname, ftype, fid) = iprot.readFieldBegin()
30076 
      if ftype == TType.STOP:
30077 
        break
30078 
      if fid == 0:
30079 
        if ftype == TType.MAP:
30080 
          self.success = {}
30081 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30082 
          for _i718 in xrange(_size714):
30083 
            _key719 = iprot.readI64();
6412 rajveer 30084 
            _val720 = iprot.readDouble();
6389 rajveer 30085 
            self.success[_key719] = _val720
30086 
          iprot.readMapEnd()
30087 
        else:
30088 
          iprot.skip(ftype)
30089 
      else:
30090 
        iprot.skip(ftype)
30091 
      iprot.readFieldEnd()
30092 
    iprot.readStructEnd()
30093 
 
30094 
  def write(self, oprot):
30095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30097 
      return
30098 
    oprot.writeStructBegin('getMiscCharges_result')
30099 
    if self.success is not None:
30100 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30101 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30102 
      for kiter721,viter722 in self.success.items():
30103 
        oprot.writeI64(kiter721)
6412 rajveer 30104 
        oprot.writeDouble(viter722)
6389 rajveer 30105 
      oprot.writeMapEnd()
30106 
      oprot.writeFieldEnd()
30107 
    oprot.writeFieldStop()
30108 
    oprot.writeStructEnd()
30109 
 
30110 
  def validate(self):
30111 
    return
30112 
 
30113 
 
30114 
  def __repr__(self):
30115 
    L = ['%s=%r' % (key, value)
30116 
      for key, value in self.__dict__.iteritems()]
30117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30118 
 
30119 
  def __eq__(self, other):
30120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30121 
 
30122 
  def __ne__(self, other):
30123 
    return not (self == other)
6507 anupam.sin 30124 
 
30125 
class refundRechargeOrder_args:
30126 
  """
30127 
  Attributes:
30128 
   - rechargeOrderId
30129 
  """
30130 
 
30131 
  thrift_spec = (
30132 
    None, # 0
30133 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30134 
  )
30135 
 
30136 
  def __init__(self, rechargeOrderId=None,):
30137 
    self.rechargeOrderId = rechargeOrderId
30138 
 
30139 
  def read(self, iprot):
30140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30142 
      return
30143 
    iprot.readStructBegin()
30144 
    while True:
30145 
      (fname, ftype, fid) = iprot.readFieldBegin()
30146 
      if ftype == TType.STOP:
30147 
        break
30148 
      if fid == 1:
30149 
        if ftype == TType.I64:
30150 
          self.rechargeOrderId = iprot.readI64();
30151 
        else:
30152 
          iprot.skip(ftype)
30153 
      else:
30154 
        iprot.skip(ftype)
30155 
      iprot.readFieldEnd()
30156 
    iprot.readStructEnd()
30157 
 
30158 
  def write(self, oprot):
30159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30161 
      return
30162 
    oprot.writeStructBegin('refundRechargeOrder_args')
30163 
    if self.rechargeOrderId is not None:
30164 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30165 
      oprot.writeI64(self.rechargeOrderId)
30166 
      oprot.writeFieldEnd()
30167 
    oprot.writeFieldStop()
30168 
    oprot.writeStructEnd()
30169 
 
30170 
  def validate(self):
30171 
    return
30172 
 
30173 
 
30174 
  def __repr__(self):
30175 
    L = ['%s=%r' % (key, value)
30176 
      for key, value in self.__dict__.iteritems()]
30177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30178 
 
30179 
  def __eq__(self, other):
30180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30181 
 
30182 
  def __ne__(self, other):
30183 
    return not (self == other)
30184 
 
30185 
class refundRechargeOrder_result:
30186 
  """
30187 
  Attributes:
30188 
   - success
30189 
   - ex
30190 
  """
30191 
 
30192 
  thrift_spec = (
30193 
    (0, TType.BOOL, 'success', None, None, ), # 0
30194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30195 
  )
30196 
 
30197 
  def __init__(self, success=None, ex=None,):
30198 
    self.success = success
30199 
    self.ex = ex
30200 
 
30201 
  def read(self, iprot):
30202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30204 
      return
30205 
    iprot.readStructBegin()
30206 
    while True:
30207 
      (fname, ftype, fid) = iprot.readFieldBegin()
30208 
      if ftype == TType.STOP:
30209 
        break
30210 
      if fid == 0:
30211 
        if ftype == TType.BOOL:
30212 
          self.success = iprot.readBool();
30213 
        else:
30214 
          iprot.skip(ftype)
30215 
      elif fid == 1:
30216 
        if ftype == TType.STRUCT:
30217 
          self.ex = TransactionServiceException()
30218 
          self.ex.read(iprot)
30219 
        else:
30220 
          iprot.skip(ftype)
30221 
      else:
30222 
        iprot.skip(ftype)
30223 
      iprot.readFieldEnd()
30224 
    iprot.readStructEnd()
30225 
 
30226 
  def write(self, oprot):
30227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30229 
      return
30230 
    oprot.writeStructBegin('refundRechargeOrder_result')
30231 
    if self.success is not None:
30232 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30233 
      oprot.writeBool(self.success)
30234 
      oprot.writeFieldEnd()
30235 
    if self.ex is not None:
30236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30237 
      self.ex.write(oprot)
30238 
      oprot.writeFieldEnd()
30239 
    oprot.writeFieldStop()
30240 
    oprot.writeStructEnd()
30241 
 
30242 
  def validate(self):
30243 
    return
30244 
 
30245 
 
30246 
  def __repr__(self):
30247 
    L = ['%s=%r' % (key, value)
30248 
      for key, value in self.__dict__.iteritems()]
30249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30250 
 
30251 
  def __eq__(self, other):
30252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30253 
 
30254 
  def __ne__(self, other):
30255 
    return not (self == other)
6821 amar.kumar 30256 
 
30257 
class getPhysicalOrders_args:
30258 
  """
30259 
  Attributes:
30260 
   - fromDate
30261 
   - toDate
30262 
  """
30263 
 
30264 
  thrift_spec = (
30265 
    None, # 0
30266 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30267 
    (2, TType.I64, 'toDate', None, None, ), # 2
30268 
  )
30269 
 
30270 
  def __init__(self, fromDate=None, toDate=None,):
30271 
    self.fromDate = fromDate
30272 
    self.toDate = toDate
30273 
 
30274 
  def read(self, iprot):
30275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30277 
      return
30278 
    iprot.readStructBegin()
30279 
    while True:
30280 
      (fname, ftype, fid) = iprot.readFieldBegin()
30281 
      if ftype == TType.STOP:
30282 
        break
30283 
      if fid == 1:
30284 
        if ftype == TType.I64:
30285 
          self.fromDate = iprot.readI64();
30286 
        else:
30287 
          iprot.skip(ftype)
30288 
      elif fid == 2:
30289 
        if ftype == TType.I64:
30290 
          self.toDate = iprot.readI64();
30291 
        else:
30292 
          iprot.skip(ftype)
30293 
      else:
30294 
        iprot.skip(ftype)
30295 
      iprot.readFieldEnd()
30296 
    iprot.readStructEnd()
30297 
 
30298 
  def write(self, oprot):
30299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30301 
      return
30302 
    oprot.writeStructBegin('getPhysicalOrders_args')
30303 
    if self.fromDate is not None:
30304 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30305 
      oprot.writeI64(self.fromDate)
30306 
      oprot.writeFieldEnd()
30307 
    if self.toDate is not None:
30308 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30309 
      oprot.writeI64(self.toDate)
30310 
      oprot.writeFieldEnd()
30311 
    oprot.writeFieldStop()
30312 
    oprot.writeStructEnd()
30313 
 
30314 
  def validate(self):
30315 
    return
30316 
 
30317 
 
30318 
  def __repr__(self):
30319 
    L = ['%s=%r' % (key, value)
30320 
      for key, value in self.__dict__.iteritems()]
30321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30322 
 
30323 
  def __eq__(self, other):
30324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30325 
 
30326 
  def __ne__(self, other):
30327 
    return not (self == other)
30328 
 
30329 
class getPhysicalOrders_result:
30330 
  """
30331 
  Attributes:
30332 
   - success
30333 
  """
30334 
 
30335 
  thrift_spec = (
30336 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30337 
  )
30338 
 
30339 
  def __init__(self, success=None,):
30340 
    self.success = success
30341 
 
30342 
  def read(self, iprot):
30343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30345 
      return
30346 
    iprot.readStructBegin()
30347 
    while True:
30348 
      (fname, ftype, fid) = iprot.readFieldBegin()
30349 
      if ftype == TType.STOP:
30350 
        break
30351 
      if fid == 0:
30352 
        if ftype == TType.LIST:
30353 
          self.success = []
30354 
          (_etype726, _size723) = iprot.readListBegin()
30355 
          for _i727 in xrange(_size723):
30356 
            _elem728 = Order()
30357 
            _elem728.read(iprot)
30358 
            self.success.append(_elem728)
30359 
          iprot.readListEnd()
30360 
        else:
30361 
          iprot.skip(ftype)
30362 
      else:
30363 
        iprot.skip(ftype)
30364 
      iprot.readFieldEnd()
30365 
    iprot.readStructEnd()
30366 
 
30367 
  def write(self, oprot):
30368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30370 
      return
30371 
    oprot.writeStructBegin('getPhysicalOrders_result')
30372 
    if self.success is not None:
30373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30375 
      for iter729 in self.success:
30376 
        iter729.write(oprot)
30377 
      oprot.writeListEnd()
30378 
      oprot.writeFieldEnd()
30379 
    oprot.writeFieldStop()
30380 
    oprot.writeStructEnd()
30381 
 
30382 
  def validate(self):
30383 
    return
30384 
 
30385 
 
30386 
  def __repr__(self):
30387 
    L = ['%s=%r' % (key, value)
30388 
      for key, value in self.__dict__.iteritems()]
30389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30390 
 
30391 
  def __eq__(self, other):
30392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30393 
 
30394 
  def __ne__(self, other):
30395 
    return not (self == other)
6906 rajveer 30396 
 
30397 
class getDocument_args:
30398 
  """
30399 
  Attributes:
30400 
   - docType
30401 
   - docSource
30402 
  """
30403 
 
30404 
  thrift_spec = (
30405 
    None, # 0
30406 
    (1, TType.I64, 'docType', None, None, ), # 1
30407 
    (2, TType.I64, 'docSource', None, None, ), # 2
30408 
  )
30409 
 
30410 
  def __init__(self, docType=None, docSource=None,):
30411 
    self.docType = docType
30412 
    self.docSource = docSource
30413 
 
30414 
  def read(self, iprot):
30415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30417 
      return
30418 
    iprot.readStructBegin()
30419 
    while True:
30420 
      (fname, ftype, fid) = iprot.readFieldBegin()
30421 
      if ftype == TType.STOP:
30422 
        break
30423 
      if fid == 1:
30424 
        if ftype == TType.I64:
30425 
          self.docType = iprot.readI64();
30426 
        else:
30427 
          iprot.skip(ftype)
30428 
      elif fid == 2:
30429 
        if ftype == TType.I64:
30430 
          self.docSource = iprot.readI64();
30431 
        else:
30432 
          iprot.skip(ftype)
30433 
      else:
30434 
        iprot.skip(ftype)
30435 
      iprot.readFieldEnd()
30436 
    iprot.readStructEnd()
30437 
 
30438 
  def write(self, oprot):
30439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30441 
      return
30442 
    oprot.writeStructBegin('getDocument_args')
30443 
    if self.docType is not None:
30444 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30445 
      oprot.writeI64(self.docType)
30446 
      oprot.writeFieldEnd()
30447 
    if self.docSource is not None:
30448 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30449 
      oprot.writeI64(self.docSource)
30450 
      oprot.writeFieldEnd()
30451 
    oprot.writeFieldStop()
30452 
    oprot.writeStructEnd()
30453 
 
30454 
  def validate(self):
30455 
    return
30456 
 
30457 
 
30458 
  def __repr__(self):
30459 
    L = ['%s=%r' % (key, value)
30460 
      for key, value in self.__dict__.iteritems()]
30461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30462 
 
30463 
  def __eq__(self, other):
30464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30465 
 
30466 
  def __ne__(self, other):
30467 
    return not (self == other)
30468 
 
30469 
class getDocument_result:
30470 
  """
30471 
  Attributes:
30472 
   - success
30473 
  """
30474 
 
30475 
  thrift_spec = (
30476 
    (0, TType.STRING, 'success', None, None, ), # 0
30477 
  )
30478 
 
30479 
  def __init__(self, success=None,):
30480 
    self.success = success
30481 
 
30482 
  def read(self, iprot):
30483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30485 
      return
30486 
    iprot.readStructBegin()
30487 
    while True:
30488 
      (fname, ftype, fid) = iprot.readFieldBegin()
30489 
      if ftype == TType.STOP:
30490 
        break
30491 
      if fid == 0:
30492 
        if ftype == TType.STRING:
30493 
          self.success = iprot.readString();
30494 
        else:
30495 
          iprot.skip(ftype)
30496 
      else:
30497 
        iprot.skip(ftype)
30498 
      iprot.readFieldEnd()
30499 
    iprot.readStructEnd()
30500 
 
30501 
  def write(self, oprot):
30502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30504 
      return
30505 
    oprot.writeStructBegin('getDocument_result')
30506 
    if self.success is not None:
30507 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30508 
      oprot.writeString(self.success)
30509 
      oprot.writeFieldEnd()
30510 
    oprot.writeFieldStop()
30511 
    oprot.writeStructEnd()
30512 
 
30513 
  def validate(self):
30514 
    return
30515 
 
30516 
 
30517 
  def __repr__(self):
30518 
    L = ['%s=%r' % (key, value)
30519 
      for key, value in self.__dict__.iteritems()]
30520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30521 
 
30522 
  def __eq__(self, other):
30523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30524 
 
30525 
  def __ne__(self, other):
30526 
    return not (self == other)
6985 anupam.sin 30527 
 
30528 
class changeShippingAddress_args:
30529 
  """
30530 
  Attributes:
30531 
   - orderId
30532 
   - line1
30533 
   - line2
30534 
   - city
30535 
   - state
30536 
   - pin
30537 
  """
30538 
 
30539 
  thrift_spec = (
30540 
    None, # 0
30541 
    (1, TType.I64, 'orderId', None, None, ), # 1
30542 
    (2, TType.STRING, 'line1', None, None, ), # 2
30543 
    (3, TType.STRING, 'line2', None, None, ), # 3
30544 
    (4, TType.STRING, 'city', None, None, ), # 4
30545 
    (5, TType.STRING, 'state', None, None, ), # 5
30546 
    (6, TType.STRING, 'pin', None, None, ), # 6
30547 
  )
30548 
 
30549 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30550 
    self.orderId = orderId
30551 
    self.line1 = line1
30552 
    self.line2 = line2
30553 
    self.city = city
30554 
    self.state = state
30555 
    self.pin = pin
30556 
 
30557 
  def read(self, iprot):
30558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30560 
      return
30561 
    iprot.readStructBegin()
30562 
    while True:
30563 
      (fname, ftype, fid) = iprot.readFieldBegin()
30564 
      if ftype == TType.STOP:
30565 
        break
30566 
      if fid == 1:
30567 
        if ftype == TType.I64:
30568 
          self.orderId = iprot.readI64();
30569 
        else:
30570 
          iprot.skip(ftype)
30571 
      elif fid == 2:
30572 
        if ftype == TType.STRING:
30573 
          self.line1 = iprot.readString();
30574 
        else:
30575 
          iprot.skip(ftype)
30576 
      elif fid == 3:
30577 
        if ftype == TType.STRING:
30578 
          self.line2 = iprot.readString();
30579 
        else:
30580 
          iprot.skip(ftype)
30581 
      elif fid == 4:
30582 
        if ftype == TType.STRING:
30583 
          self.city = iprot.readString();
30584 
        else:
30585 
          iprot.skip(ftype)
30586 
      elif fid == 5:
30587 
        if ftype == TType.STRING:
30588 
          self.state = iprot.readString();
30589 
        else:
30590 
          iprot.skip(ftype)
30591 
      elif fid == 6:
30592 
        if ftype == TType.STRING:
30593 
          self.pin = iprot.readString();
30594 
        else:
30595 
          iprot.skip(ftype)
30596 
      else:
30597 
        iprot.skip(ftype)
30598 
      iprot.readFieldEnd()
30599 
    iprot.readStructEnd()
30600 
 
30601 
  def write(self, oprot):
30602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30604 
      return
30605 
    oprot.writeStructBegin('changeShippingAddress_args')
30606 
    if self.orderId is not None:
30607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30608 
      oprot.writeI64(self.orderId)
30609 
      oprot.writeFieldEnd()
30610 
    if self.line1 is not None:
30611 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30612 
      oprot.writeString(self.line1)
30613 
      oprot.writeFieldEnd()
30614 
    if self.line2 is not None:
30615 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30616 
      oprot.writeString(self.line2)
30617 
      oprot.writeFieldEnd()
30618 
    if self.city is not None:
30619 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30620 
      oprot.writeString(self.city)
30621 
      oprot.writeFieldEnd()
30622 
    if self.state is not None:
30623 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30624 
      oprot.writeString(self.state)
30625 
      oprot.writeFieldEnd()
30626 
    if self.pin is not None:
30627 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30628 
      oprot.writeString(self.pin)
30629 
      oprot.writeFieldEnd()
30630 
    oprot.writeFieldStop()
30631 
    oprot.writeStructEnd()
30632 
 
30633 
  def validate(self):
30634 
    return
30635 
 
30636 
 
30637 
  def __repr__(self):
30638 
    L = ['%s=%r' % (key, value)
30639 
      for key, value in self.__dict__.iteritems()]
30640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30641 
 
30642 
  def __eq__(self, other):
30643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30644 
 
30645 
  def __ne__(self, other):
30646 
    return not (self == other)
30647 
 
30648 
class changeShippingAddress_result:
30649 
  """
30650 
  Attributes:
30651 
   - success
30652 
  """
30653 
 
30654 
  thrift_spec = (
30655 
    (0, TType.BOOL, 'success', None, None, ), # 0
30656 
  )
30657 
 
30658 
  def __init__(self, success=None,):
30659 
    self.success = success
30660 
 
30661 
  def read(self, iprot):
30662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30664 
      return
30665 
    iprot.readStructBegin()
30666 
    while True:
30667 
      (fname, ftype, fid) = iprot.readFieldBegin()
30668 
      if ftype == TType.STOP:
30669 
        break
30670 
      if fid == 0:
30671 
        if ftype == TType.BOOL:
30672 
          self.success = iprot.readBool();
30673 
        else:
30674 
          iprot.skip(ftype)
30675 
      else:
30676 
        iprot.skip(ftype)
30677 
      iprot.readFieldEnd()
30678 
    iprot.readStructEnd()
30679 
 
30680 
  def write(self, oprot):
30681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30683 
      return
30684 
    oprot.writeStructBegin('changeShippingAddress_result')
30685 
    if self.success is not None:
30686 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30687 
      oprot.writeBool(self.success)
30688 
      oprot.writeFieldEnd()
30689 
    oprot.writeFieldStop()
30690 
    oprot.writeStructEnd()
30691 
 
30692 
  def validate(self):
30693 
    return
30694 
 
30695 
 
30696 
  def __repr__(self):
30697 
    L = ['%s=%r' % (key, value)
30698 
      for key, value in self.__dict__.iteritems()]
30699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30700 
 
30701 
  def __eq__(self, other):
30702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30703 
 
30704 
  def __ne__(self, other):
30705 
    return not (self == other)
6988 rajveer 30706 
 
30707 
class retrieveInvoice_args:
30708 
  """
30709 
  Attributes:
30710 
   - orderId
7075 rajveer 30711 
   - userId
6988 rajveer 30712 
  """
30713 
 
30714 
  thrift_spec = (
30715 
    None, # 0
30716 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30717 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30718 
  )
30719 
 
7075 rajveer 30720 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30721 
    self.orderId = orderId
7075 rajveer 30722 
    self.userId = userId
6988 rajveer 30723 
 
30724 
  def read(self, iprot):
30725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30727 
      return
30728 
    iprot.readStructBegin()
30729 
    while True:
30730 
      (fname, ftype, fid) = iprot.readFieldBegin()
30731 
      if ftype == TType.STOP:
30732 
        break
30733 
      if fid == 1:
30734 
        if ftype == TType.I64:
30735 
          self.orderId = iprot.readI64();
30736 
        else:
30737 
          iprot.skip(ftype)
7075 rajveer 30738 
      elif fid == 2:
30739 
        if ftype == TType.I64:
30740 
          self.userId = iprot.readI64();
30741 
        else:
30742 
          iprot.skip(ftype)
6988 rajveer 30743 
      else:
30744 
        iprot.skip(ftype)
30745 
      iprot.readFieldEnd()
30746 
    iprot.readStructEnd()
30747 
 
30748 
  def write(self, oprot):
30749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30751 
      return
30752 
    oprot.writeStructBegin('retrieveInvoice_args')
30753 
    if self.orderId is not None:
30754 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30755 
      oprot.writeI64(self.orderId)
30756 
      oprot.writeFieldEnd()
7075 rajveer 30757 
    if self.userId is not None:
30758 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30759 
      oprot.writeI64(self.userId)
30760 
      oprot.writeFieldEnd()
6988 rajveer 30761 
    oprot.writeFieldStop()
30762 
    oprot.writeStructEnd()
30763 
 
30764 
  def validate(self):
30765 
    return
30766 
 
30767 
 
30768 
  def __repr__(self):
30769 
    L = ['%s=%r' % (key, value)
30770 
      for key, value in self.__dict__.iteritems()]
30771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30772 
 
30773 
  def __eq__(self, other):
30774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30775 
 
30776 
  def __ne__(self, other):
30777 
    return not (self == other)
30778 
 
30779 
class retrieveInvoice_result:
30780 
  """
30781 
  Attributes:
30782 
   - success
30783 
  """
30784 
 
30785 
  thrift_spec = (
30786 
    (0, TType.STRING, 'success', None, None, ), # 0
30787 
  )
30788 
 
30789 
  def __init__(self, success=None,):
30790 
    self.success = success
30791 
 
30792 
  def read(self, iprot):
30793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30795 
      return
30796 
    iprot.readStructBegin()
30797 
    while True:
30798 
      (fname, ftype, fid) = iprot.readFieldBegin()
30799 
      if ftype == TType.STOP:
30800 
        break
30801 
      if fid == 0:
30802 
        if ftype == TType.STRING:
30803 
          self.success = iprot.readString();
30804 
        else:
30805 
          iprot.skip(ftype)
30806 
      else:
30807 
        iprot.skip(ftype)
30808 
      iprot.readFieldEnd()
30809 
    iprot.readStructEnd()
30810 
 
30811 
  def write(self, oprot):
30812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30814 
      return
30815 
    oprot.writeStructBegin('retrieveInvoice_result')
30816 
    if self.success is not None:
30817 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30818 
      oprot.writeString(self.success)
30819 
      oprot.writeFieldEnd()
30820 
    oprot.writeFieldStop()
30821 
    oprot.writeStructEnd()
30822 
 
30823 
  def validate(self):
30824 
    return
30825 
 
30826 
 
30827 
  def __repr__(self):
30828 
    L = ['%s=%r' % (key, value)
30829 
      for key, value in self.__dict__.iteritems()]
30830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30831 
 
30832 
  def __eq__(self, other):
30833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30834 
 
30835 
  def __ne__(self, other):
30836 
    return not (self == other)
7026 rajveer 30837 
 
30838 
class receiveUpdatesForRedExpress_args:
30839 
  """
30840 
  Attributes:
30841 
   - awbNumber
30842 
  """
30843 
 
30844 
  thrift_spec = (
30845 
    None, # 0
30846 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30847 
  )
30848 
 
30849 
  def __init__(self, awbNumber=None,):
30850 
    self.awbNumber = awbNumber
30851 
 
30852 
  def read(self, iprot):
30853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30855 
      return
30856 
    iprot.readStructBegin()
30857 
    while True:
30858 
      (fname, ftype, fid) = iprot.readFieldBegin()
30859 
      if ftype == TType.STOP:
30860 
        break
30861 
      if fid == 1:
30862 
        if ftype == TType.STRING:
30863 
          self.awbNumber = iprot.readString();
30864 
        else:
30865 
          iprot.skip(ftype)
30866 
      else:
30867 
        iprot.skip(ftype)
30868 
      iprot.readFieldEnd()
30869 
    iprot.readStructEnd()
30870 
 
30871 
  def write(self, oprot):
30872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30874 
      return
30875 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30876 
    if self.awbNumber is not None:
30877 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30878 
      oprot.writeString(self.awbNumber)
30879 
      oprot.writeFieldEnd()
30880 
    oprot.writeFieldStop()
30881 
    oprot.writeStructEnd()
30882 
 
30883 
  def validate(self):
30884 
    return
30885 
 
30886 
 
30887 
  def __repr__(self):
30888 
    L = ['%s=%r' % (key, value)
30889 
      for key, value in self.__dict__.iteritems()]
30890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30891 
 
30892 
  def __eq__(self, other):
30893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30894 
 
30895 
  def __ne__(self, other):
30896 
    return not (self == other)
30897 
 
30898 
class receiveUpdatesForRedExpress_result:
30899 
  """
30900 
  Attributes:
30901 
   - success
30902 
  """
30903 
 
30904 
  thrift_spec = (
30905 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30906 
  )
30907 
 
30908 
  def __init__(self, success=None,):
30909 
    self.success = success
30910 
 
30911 
  def read(self, iprot):
30912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30914 
      return
30915 
    iprot.readStructBegin()
30916 
    while True:
30917 
      (fname, ftype, fid) = iprot.readFieldBegin()
30918 
      if ftype == TType.STOP:
30919 
        break
30920 
      if fid == 0:
30921 
        if ftype == TType.LIST:
30922 
          self.success = []
30923 
          (_etype733, _size730) = iprot.readListBegin()
30924 
          for _i734 in xrange(_size730):
30925 
            _elem735 = iprot.readString();
30926 
            self.success.append(_elem735)
30927 
          iprot.readListEnd()
30928 
        else:
30929 
          iprot.skip(ftype)
30930 
      else:
30931 
        iprot.skip(ftype)
30932 
      iprot.readFieldEnd()
30933 
    iprot.readStructEnd()
30934 
 
30935 
  def write(self, oprot):
30936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30938 
      return
30939 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30940 
    if self.success is not None:
30941 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30942 
      oprot.writeListBegin(TType.STRING, len(self.success))
30943 
      for iter736 in self.success:
30944 
        oprot.writeString(iter736)
30945 
      oprot.writeListEnd()
30946 
      oprot.writeFieldEnd()
30947 
    oprot.writeFieldStop()
30948 
    oprot.writeStructEnd()
30949 
 
30950 
  def validate(self):
30951 
    return
30952 
 
30953 
 
30954 
  def __repr__(self):
30955 
    L = ['%s=%r' % (key, value)
30956 
      for key, value in self.__dict__.iteritems()]
30957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30958 
 
30959 
  def __eq__(self, other):
30960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30961 
 
30962 
  def __ne__(self, other):
30963 
    return not (self == other)
7073 anupam.sin 30964 
 
30965 
class createRechargeTransaction_args:
30966 
  """
30967 
  Attributes:
30968 
   - thriftRechargeTransaction
30969 
  """
30970 
 
30971 
  thrift_spec = (
30972 
    None, # 0
30973 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
30974 
  )
30975 
 
30976 
  def __init__(self, thriftRechargeTransaction=None,):
30977 
    self.thriftRechargeTransaction = thriftRechargeTransaction
30978 
 
30979 
  def read(self, iprot):
30980 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30981 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30982 
      return
30983 
    iprot.readStructBegin()
30984 
    while True:
30985 
      (fname, ftype, fid) = iprot.readFieldBegin()
30986 
      if ftype == TType.STOP:
30987 
        break
30988 
      if fid == 1:
30989 
        if ftype == TType.STRUCT:
30990 
          self.thriftRechargeTransaction = RechargeTransaction()
30991 
          self.thriftRechargeTransaction.read(iprot)
30992 
        else:
30993 
          iprot.skip(ftype)
30994 
      else:
30995 
        iprot.skip(ftype)
30996 
      iprot.readFieldEnd()
30997 
    iprot.readStructEnd()
30998 
 
30999 
  def write(self, oprot):
31000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31002 
      return
31003 
    oprot.writeStructBegin('createRechargeTransaction_args')
31004 
    if self.thriftRechargeTransaction is not None:
31005 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31006 
      self.thriftRechargeTransaction.write(oprot)
31007 
      oprot.writeFieldEnd()
31008 
    oprot.writeFieldStop()
31009 
    oprot.writeStructEnd()
31010 
 
31011 
  def validate(self):
31012 
    return
31013 
 
31014 
 
31015 
  def __repr__(self):
31016 
    L = ['%s=%r' % (key, value)
31017 
      for key, value in self.__dict__.iteritems()]
31018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31019 
 
31020 
  def __eq__(self, other):
31021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31022 
 
31023 
  def __ne__(self, other):
31024 
    return not (self == other)
31025 
 
31026 
class createRechargeTransaction_result:
31027 
  """
31028 
  Attributes:
31029 
   - success
31030 
  """
31031 
 
31032 
  thrift_spec = (
31033 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31034 
  )
31035 
 
31036 
  def __init__(self, success=None,):
31037 
    self.success = success
31038 
 
31039 
  def read(self, iprot):
31040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31042 
      return
31043 
    iprot.readStructBegin()
31044 
    while True:
31045 
      (fname, ftype, fid) = iprot.readFieldBegin()
31046 
      if ftype == TType.STOP:
31047 
        break
31048 
      if fid == 0:
31049 
        if ftype == TType.STRUCT:
31050 
          self.success = RechargeTransaction()
31051 
          self.success.read(iprot)
31052 
        else:
31053 
          iprot.skip(ftype)
31054 
      else:
31055 
        iprot.skip(ftype)
31056 
      iprot.readFieldEnd()
31057 
    iprot.readStructEnd()
31058 
 
31059 
  def write(self, oprot):
31060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31062 
      return
31063 
    oprot.writeStructBegin('createRechargeTransaction_result')
31064 
    if self.success is not None:
31065 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31066 
      self.success.write(oprot)
31067 
      oprot.writeFieldEnd()
31068 
    oprot.writeFieldStop()
31069 
    oprot.writeStructEnd()
31070 
 
31071 
  def validate(self):
31072 
    return
31073 
 
31074 
 
31075 
  def __repr__(self):
31076 
    L = ['%s=%r' % (key, value)
31077 
      for key, value in self.__dict__.iteritems()]
31078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31079 
 
31080 
  def __eq__(self, other):
31081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31082 
 
31083 
  def __ne__(self, other):
31084 
    return not (self == other)
7080 anupam.sin 31085 
 
7085 rajveer 31086 
class getRechargeTransactions_args:
31087 
  """
31088 
  Attributes:
31089 
   - storeId
31090 
  """
31091 
 
31092 
  thrift_spec = (
31093 
    None, # 0
31094 
    (1, TType.I64, 'storeId', None, None, ), # 1
31095 
  )
31096 
 
31097 
  def __init__(self, storeId=None,):
31098 
    self.storeId = storeId
31099 
 
31100 
  def read(self, iprot):
31101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31103 
      return
31104 
    iprot.readStructBegin()
31105 
    while True:
31106 
      (fname, ftype, fid) = iprot.readFieldBegin()
31107 
      if ftype == TType.STOP:
31108 
        break
31109 
      if fid == 1:
31110 
        if ftype == TType.I64:
31111 
          self.storeId = iprot.readI64();
31112 
        else:
31113 
          iprot.skip(ftype)
31114 
      else:
31115 
        iprot.skip(ftype)
31116 
      iprot.readFieldEnd()
31117 
    iprot.readStructEnd()
31118 
 
31119 
  def write(self, oprot):
31120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31122 
      return
31123 
    oprot.writeStructBegin('getRechargeTransactions_args')
31124 
    if self.storeId is not None:
31125 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31126 
      oprot.writeI64(self.storeId)
31127 
      oprot.writeFieldEnd()
31128 
    oprot.writeFieldStop()
31129 
    oprot.writeStructEnd()
31130 
 
31131 
  def validate(self):
31132 
    return
31133 
 
31134 
 
31135 
  def __repr__(self):
31136 
    L = ['%s=%r' % (key, value)
31137 
      for key, value in self.__dict__.iteritems()]
31138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31139 
 
31140 
  def __eq__(self, other):
31141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31142 
 
31143 
  def __ne__(self, other):
31144 
    return not (self == other)
31145 
 
31146 
class getRechargeTransactions_result:
31147 
  """
31148 
  Attributes:
31149 
   - success
31150 
  """
31151 
 
31152 
  thrift_spec = (
31153 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31154 
  )
31155 
 
31156 
  def __init__(self, success=None,):
31157 
    self.success = success
31158 
 
31159 
  def read(self, iprot):
31160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31162 
      return
31163 
    iprot.readStructBegin()
31164 
    while True:
31165 
      (fname, ftype, fid) = iprot.readFieldBegin()
31166 
      if ftype == TType.STOP:
31167 
        break
31168 
      if fid == 0:
31169 
        if ftype == TType.LIST:
31170 
          self.success = []
31171 
          (_etype740, _size737) = iprot.readListBegin()
31172 
          for _i741 in xrange(_size737):
31173 
            _elem742 = RechargeTransaction()
31174 
            _elem742.read(iprot)
31175 
            self.success.append(_elem742)
31176 
          iprot.readListEnd()
31177 
        else:
31178 
          iprot.skip(ftype)
31179 
      else:
31180 
        iprot.skip(ftype)
31181 
      iprot.readFieldEnd()
31182 
    iprot.readStructEnd()
31183 
 
31184 
  def write(self, oprot):
31185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31187 
      return
31188 
    oprot.writeStructBegin('getRechargeTransactions_result')
31189 
    if self.success is not None:
31190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31192 
      for iter743 in self.success:
31193 
        iter743.write(oprot)
31194 
      oprot.writeListEnd()
31195 
      oprot.writeFieldEnd()
31196 
    oprot.writeFieldStop()
31197 
    oprot.writeStructEnd()
31198 
 
31199 
  def validate(self):
31200 
    return
31201 
 
31202 
 
31203 
  def __repr__(self):
31204 
    L = ['%s=%r' % (key, value)
31205 
      for key, value in self.__dict__.iteritems()]
31206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31207 
 
31208 
  def __eq__(self, other):
31209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31210 
 
31211 
  def __ne__(self, other):
31212 
    return not (self == other)
31213 
 
7151 amit.gupta 31214 
class getRechargeTrans_args:
31215 
  """
31216 
  Attributes:
31217 
   - storeId
31218 
   - startDate
31219 
   - endDate
31220 
   - status
31221 
  """
31222 
 
31223 
  thrift_spec = (
31224 
    None, # 0
31225 
    (1, TType.I64, 'storeId', None, None, ), # 1
31226 
    (2, TType.I64, 'startDate', None, None, ), # 2
31227 
    (3, TType.I64, 'endDate', None, None, ), # 3
31228 
    (4, TType.I32, 'status', None, None, ), # 4
31229 
  )
31230 
 
31231 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31232 
    self.storeId = storeId
31233 
    self.startDate = startDate
31234 
    self.endDate = endDate
31235 
    self.status = status
31236 
 
31237 
  def read(self, iprot):
31238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31240 
      return
31241 
    iprot.readStructBegin()
31242 
    while True:
31243 
      (fname, ftype, fid) = iprot.readFieldBegin()
31244 
      if ftype == TType.STOP:
31245 
        break
31246 
      if fid == 1:
31247 
        if ftype == TType.I64:
31248 
          self.storeId = iprot.readI64();
31249 
        else:
31250 
          iprot.skip(ftype)
31251 
      elif fid == 2:
31252 
        if ftype == TType.I64:
31253 
          self.startDate = iprot.readI64();
31254 
        else:
31255 
          iprot.skip(ftype)
31256 
      elif fid == 3:
31257 
        if ftype == TType.I64:
31258 
          self.endDate = iprot.readI64();
31259 
        else:
31260 
          iprot.skip(ftype)
31261 
      elif fid == 4:
31262 
        if ftype == TType.I32:
31263 
          self.status = iprot.readI32();
31264 
        else:
31265 
          iprot.skip(ftype)
31266 
      else:
31267 
        iprot.skip(ftype)
31268 
      iprot.readFieldEnd()
31269 
    iprot.readStructEnd()
31270 
 
31271 
  def write(self, oprot):
31272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31274 
      return
31275 
    oprot.writeStructBegin('getRechargeTrans_args')
31276 
    if self.storeId is not None:
31277 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31278 
      oprot.writeI64(self.storeId)
31279 
      oprot.writeFieldEnd()
31280 
    if self.startDate is not None:
31281 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31282 
      oprot.writeI64(self.startDate)
31283 
      oprot.writeFieldEnd()
31284 
    if self.endDate is not None:
31285 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31286 
      oprot.writeI64(self.endDate)
31287 
      oprot.writeFieldEnd()
31288 
    if self.status is not None:
31289 
      oprot.writeFieldBegin('status', TType.I32, 4)
31290 
      oprot.writeI32(self.status)
31291 
      oprot.writeFieldEnd()
31292 
    oprot.writeFieldStop()
31293 
    oprot.writeStructEnd()
31294 
 
31295 
  def validate(self):
31296 
    return
31297 
 
31298 
 
31299 
  def __repr__(self):
31300 
    L = ['%s=%r' % (key, value)
31301 
      for key, value in self.__dict__.iteritems()]
31302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31303 
 
31304 
  def __eq__(self, other):
31305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31306 
 
31307 
  def __ne__(self, other):
31308 
    return not (self == other)
31309 
 
31310 
class getRechargeTrans_result:
31311 
  """
31312 
  Attributes:
31313 
   - success
31314 
  """
31315 
 
31316 
  thrift_spec = (
31317 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31318 
  )
31319 
 
31320 
  def __init__(self, success=None,):
31321 
    self.success = success
31322 
 
31323 
  def read(self, iprot):
31324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31326 
      return
31327 
    iprot.readStructBegin()
31328 
    while True:
31329 
      (fname, ftype, fid) = iprot.readFieldBegin()
31330 
      if ftype == TType.STOP:
31331 
        break
31332 
      if fid == 0:
31333 
        if ftype == TType.LIST:
31334 
          self.success = []
31335 
          (_etype747, _size744) = iprot.readListBegin()
31336 
          for _i748 in xrange(_size744):
31337 
            _elem749 = RechargeTransaction()
31338 
            _elem749.read(iprot)
31339 
            self.success.append(_elem749)
31340 
          iprot.readListEnd()
31341 
        else:
31342 
          iprot.skip(ftype)
31343 
      else:
31344 
        iprot.skip(ftype)
31345 
      iprot.readFieldEnd()
31346 
    iprot.readStructEnd()
31347 
 
31348 
  def write(self, oprot):
31349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31351 
      return
31352 
    oprot.writeStructBegin('getRechargeTrans_result')
31353 
    if self.success is not None:
31354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31356 
      for iter750 in self.success:
31357 
        iter750.write(oprot)
31358 
      oprot.writeListEnd()
31359 
      oprot.writeFieldEnd()
31360 
    oprot.writeFieldStop()
31361 
    oprot.writeStructEnd()
31362 
 
31363 
  def validate(self):
31364 
    return
31365 
 
31366 
 
31367 
  def __repr__(self):
31368 
    L = ['%s=%r' % (key, value)
31369 
      for key, value in self.__dict__.iteritems()]
31370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31371 
 
31372 
  def __eq__(self, other):
31373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31374 
 
31375 
  def __ne__(self, other):
31376 
    return not (self == other)
31377 
 
7080 anupam.sin 31378 
class getRechargeTransaction_args:
31379 
  """
31380 
  Attributes:
31381 
   - rechargeId
31382 
  """
31383 
 
31384 
  thrift_spec = (
31385 
    None, # 0
31386 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31387 
  )
31388 
 
31389 
  def __init__(self, rechargeId=None,):
31390 
    self.rechargeId = rechargeId
31391 
 
31392 
  def read(self, iprot):
31393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31395 
      return
31396 
    iprot.readStructBegin()
31397 
    while True:
31398 
      (fname, ftype, fid) = iprot.readFieldBegin()
31399 
      if ftype == TType.STOP:
31400 
        break
31401 
      if fid == 1:
31402 
        if ftype == TType.I64:
31403 
          self.rechargeId = iprot.readI64();
31404 
        else:
31405 
          iprot.skip(ftype)
31406 
      else:
31407 
        iprot.skip(ftype)
31408 
      iprot.readFieldEnd()
31409 
    iprot.readStructEnd()
31410 
 
31411 
  def write(self, oprot):
31412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31414 
      return
31415 
    oprot.writeStructBegin('getRechargeTransaction_args')
31416 
    if self.rechargeId is not None:
31417 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31418 
      oprot.writeI64(self.rechargeId)
31419 
      oprot.writeFieldEnd()
31420 
    oprot.writeFieldStop()
31421 
    oprot.writeStructEnd()
31422 
 
31423 
  def validate(self):
31424 
    return
31425 
 
31426 
 
31427 
  def __repr__(self):
31428 
    L = ['%s=%r' % (key, value)
31429 
      for key, value in self.__dict__.iteritems()]
31430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31431 
 
31432 
  def __eq__(self, other):
31433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31434 
 
31435 
  def __ne__(self, other):
31436 
    return not (self == other)
31437 
 
31438 
class getRechargeTransaction_result:
31439 
  """
31440 
  Attributes:
31441 
   - success
31442 
  """
31443 
 
31444 
  thrift_spec = (
31445 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31446 
  )
31447 
 
31448 
  def __init__(self, success=None,):
31449 
    self.success = success
31450 
 
31451 
  def read(self, iprot):
31452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31454 
      return
31455 
    iprot.readStructBegin()
31456 
    while True:
31457 
      (fname, ftype, fid) = iprot.readFieldBegin()
31458 
      if ftype == TType.STOP:
31459 
        break
31460 
      if fid == 0:
31461 
        if ftype == TType.STRUCT:
31462 
          self.success = RechargeTransaction()
31463 
          self.success.read(iprot)
31464 
        else:
31465 
          iprot.skip(ftype)
31466 
      else:
31467 
        iprot.skip(ftype)
31468 
      iprot.readFieldEnd()
31469 
    iprot.readStructEnd()
31470 
 
31471 
  def write(self, oprot):
31472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31474 
      return
31475 
    oprot.writeStructBegin('getRechargeTransaction_result')
31476 
    if self.success is not None:
31477 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31478 
      self.success.write(oprot)
31479 
      oprot.writeFieldEnd()
31480 
    oprot.writeFieldStop()
31481 
    oprot.writeStructEnd()
31482 
 
31483 
  def validate(self):
31484 
    return
31485 
 
31486 
 
31487 
  def __repr__(self):
31488 
    L = ['%s=%r' % (key, value)
31489 
      for key, value in self.__dict__.iteritems()]
31490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31491 
 
31492 
  def __eq__(self, other):
31493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31494 
 
31495 
  def __ne__(self, other):
31496 
    return not (self == other)
31497 
 
31498 
class getFRCs_args:
31499 
  """
31500 
  Attributes:
31501 
   - circleId
31502 
   - operatorId
31503 
  """
31504 
 
31505 
  thrift_spec = (
31506 
    None, # 0
31507 
    (1, TType.I64, 'circleId', None, None, ), # 1
31508 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31509 
  )
31510 
 
31511 
  def __init__(self, circleId=None, operatorId=None,):
31512 
    self.circleId = circleId
31513 
    self.operatorId = operatorId
31514 
 
31515 
  def read(self, iprot):
31516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31518 
      return
31519 
    iprot.readStructBegin()
31520 
    while True:
31521 
      (fname, ftype, fid) = iprot.readFieldBegin()
31522 
      if ftype == TType.STOP:
31523 
        break
31524 
      if fid == 1:
31525 
        if ftype == TType.I64:
31526 
          self.circleId = iprot.readI64();
31527 
        else:
31528 
          iprot.skip(ftype)
31529 
      elif fid == 2:
31530 
        if ftype == TType.I64:
31531 
          self.operatorId = iprot.readI64();
31532 
        else:
31533 
          iprot.skip(ftype)
31534 
      else:
31535 
        iprot.skip(ftype)
31536 
      iprot.readFieldEnd()
31537 
    iprot.readStructEnd()
31538 
 
31539 
  def write(self, oprot):
31540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31542 
      return
31543 
    oprot.writeStructBegin('getFRCs_args')
31544 
    if self.circleId is not None:
31545 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31546 
      oprot.writeI64(self.circleId)
31547 
      oprot.writeFieldEnd()
31548 
    if self.operatorId is not None:
31549 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31550 
      oprot.writeI64(self.operatorId)
31551 
      oprot.writeFieldEnd()
31552 
    oprot.writeFieldStop()
31553 
    oprot.writeStructEnd()
31554 
 
31555 
  def validate(self):
31556 
    return
31557 
 
31558 
 
31559 
  def __repr__(self):
31560 
    L = ['%s=%r' % (key, value)
31561 
      for key, value in self.__dict__.iteritems()]
31562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31563 
 
31564 
  def __eq__(self, other):
31565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31566 
 
31567 
  def __ne__(self, other):
31568 
    return not (self == other)
31569 
 
31570 
class getFRCs_result:
31571 
  """
31572 
  Attributes:
31573 
   - success
31574 
  """
31575 
 
31576 
  thrift_spec = (
31577 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31578 
  )
31579 
 
31580 
  def __init__(self, success=None,):
31581 
    self.success = success
31582 
 
31583 
  def read(self, iprot):
31584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31586 
      return
31587 
    iprot.readStructBegin()
31588 
    while True:
31589 
      (fname, ftype, fid) = iprot.readFieldBegin()
31590 
      if ftype == TType.STOP:
31591 
        break
31592 
      if fid == 0:
31593 
        if ftype == TType.LIST:
31594 
          self.success = []
7151 amit.gupta 31595 
          (_etype754, _size751) = iprot.readListBegin()
31596 
          for _i755 in xrange(_size751):
31597 
            _elem756 = FRC()
31598 
            _elem756.read(iprot)
31599 
            self.success.append(_elem756)
7080 anupam.sin 31600 
          iprot.readListEnd()
31601 
        else:
31602 
          iprot.skip(ftype)
31603 
      else:
31604 
        iprot.skip(ftype)
31605 
      iprot.readFieldEnd()
31606 
    iprot.readStructEnd()
31607 
 
31608 
  def write(self, oprot):
31609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31611 
      return
31612 
    oprot.writeStructBegin('getFRCs_result')
31613 
    if self.success is not None:
31614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31616 
      for iter757 in self.success:
31617 
        iter757.write(oprot)
7080 anupam.sin 31618 
      oprot.writeListEnd()
31619 
      oprot.writeFieldEnd()
31620 
    oprot.writeFieldStop()
31621 
    oprot.writeStructEnd()
31622 
 
31623 
  def validate(self):
31624 
    return
31625 
 
31626 
 
31627 
  def __repr__(self):
31628 
    L = ['%s=%r' % (key, value)
31629 
      for key, value in self.__dict__.iteritems()]
31630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31631 
 
31632 
  def __eq__(self, other):
31633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31634 
 
31635 
  def __ne__(self, other):
31636 
    return not (self == other)
7096 anupam.sin 31637 
 
31638 
class getHotspotStore_args:
31639 
  """
31640 
  Attributes:
31641 
   - id
31642 
   - hotspotid
31643 
  """
31644 
 
31645 
  thrift_spec = (
31646 
    None, # 0
31647 
    (1, TType.I64, 'id', None, None, ), # 1
31648 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31649 
  )
31650 
 
31651 
  def __init__(self, id=None, hotspotid=None,):
31652 
    self.id = id
31653 
    self.hotspotid = hotspotid
31654 
 
31655 
  def read(self, iprot):
31656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31658 
      return
31659 
    iprot.readStructBegin()
31660 
    while True:
31661 
      (fname, ftype, fid) = iprot.readFieldBegin()
31662 
      if ftype == TType.STOP:
31663 
        break
31664 
      if fid == 1:
31665 
        if ftype == TType.I64:
31666 
          self.id = iprot.readI64();
31667 
        else:
31668 
          iprot.skip(ftype)
31669 
      elif fid == 2:
31670 
        if ftype == TType.STRING:
31671 
          self.hotspotid = iprot.readString();
31672 
        else:
31673 
          iprot.skip(ftype)
31674 
      else:
31675 
        iprot.skip(ftype)
31676 
      iprot.readFieldEnd()
31677 
    iprot.readStructEnd()
31678 
 
31679 
  def write(self, oprot):
31680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31682 
      return
31683 
    oprot.writeStructBegin('getHotspotStore_args')
31684 
    if self.id is not None:
31685 
      oprot.writeFieldBegin('id', TType.I64, 1)
31686 
      oprot.writeI64(self.id)
31687 
      oprot.writeFieldEnd()
31688 
    if self.hotspotid is not None:
31689 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31690 
      oprot.writeString(self.hotspotid)
31691 
      oprot.writeFieldEnd()
31692 
    oprot.writeFieldStop()
31693 
    oprot.writeStructEnd()
31694 
 
31695 
  def validate(self):
31696 
    return
31697 
 
31698 
 
31699 
  def __repr__(self):
31700 
    L = ['%s=%r' % (key, value)
31701 
      for key, value in self.__dict__.iteritems()]
31702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31703 
 
31704 
  def __eq__(self, other):
31705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31706 
 
31707 
  def __ne__(self, other):
31708 
    return not (self == other)
31709 
 
31710 
class getHotspotStore_result:
31711 
  """
31712 
  Attributes:
31713 
   - success
31714 
  """
31715 
 
31716 
  thrift_spec = (
31717 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31718 
  )
31719 
 
31720 
  def __init__(self, success=None,):
31721 
    self.success = success
31722 
 
31723 
  def read(self, iprot):
31724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31726 
      return
31727 
    iprot.readStructBegin()
31728 
    while True:
31729 
      (fname, ftype, fid) = iprot.readFieldBegin()
31730 
      if ftype == TType.STOP:
31731 
        break
31732 
      if fid == 0:
31733 
        if ftype == TType.STRUCT:
31734 
          self.success = HotspotStore()
31735 
          self.success.read(iprot)
31736 
        else:
31737 
          iprot.skip(ftype)
31738 
      else:
31739 
        iprot.skip(ftype)
31740 
      iprot.readFieldEnd()
31741 
    iprot.readStructEnd()
31742 
 
31743 
  def write(self, oprot):
31744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31746 
      return
31747 
    oprot.writeStructBegin('getHotspotStore_result')
31748 
    if self.success is not None:
31749 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31750 
      self.success.write(oprot)
31751 
      oprot.writeFieldEnd()
31752 
    oprot.writeFieldStop()
31753 
    oprot.writeStructEnd()
31754 
 
31755 
  def validate(self):
31756 
    return
31757 
 
31758 
 
31759 
  def __repr__(self):
31760 
    L = ['%s=%r' % (key, value)
31761 
      for key, value in self.__dict__.iteritems()]
31762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31763 
 
31764 
  def __eq__(self, other):
31765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31766 
 
31767 
  def __ne__(self, other):
31768 
    return not (self == other)
31769 
 
31770 
class getTelecomCircle_args:
31771 
  """
31772 
  Attributes:
31773 
   - id
31774 
   - code
31775 
  """
31776 
 
31777 
  thrift_spec = (
31778 
    None, # 0
31779 
    (1, TType.I64, 'id', None, None, ), # 1
31780 
    (2, TType.STRING, 'code', None, None, ), # 2
31781 
  )
31782 
 
31783 
  def __init__(self, id=None, code=None,):
31784 
    self.id = id
31785 
    self.code = code
31786 
 
31787 
  def read(self, iprot):
31788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31790 
      return
31791 
    iprot.readStructBegin()
31792 
    while True:
31793 
      (fname, ftype, fid) = iprot.readFieldBegin()
31794 
      if ftype == TType.STOP:
31795 
        break
31796 
      if fid == 1:
31797 
        if ftype == TType.I64:
31798 
          self.id = iprot.readI64();
31799 
        else:
31800 
          iprot.skip(ftype)
31801 
      elif fid == 2:
31802 
        if ftype == TType.STRING:
31803 
          self.code = iprot.readString();
31804 
        else:
31805 
          iprot.skip(ftype)
31806 
      else:
31807 
        iprot.skip(ftype)
31808 
      iprot.readFieldEnd()
31809 
    iprot.readStructEnd()
31810 
 
31811 
  def write(self, oprot):
31812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31814 
      return
31815 
    oprot.writeStructBegin('getTelecomCircle_args')
31816 
    if self.id is not None:
31817 
      oprot.writeFieldBegin('id', TType.I64, 1)
31818 
      oprot.writeI64(self.id)
31819 
      oprot.writeFieldEnd()
31820 
    if self.code is not None:
31821 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31822 
      oprot.writeString(self.code)
31823 
      oprot.writeFieldEnd()
31824 
    oprot.writeFieldStop()
31825 
    oprot.writeStructEnd()
31826 
 
31827 
  def validate(self):
31828 
    return
31829 
 
31830 
 
31831 
  def __repr__(self):
31832 
    L = ['%s=%r' % (key, value)
31833 
      for key, value in self.__dict__.iteritems()]
31834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31835 
 
31836 
  def __eq__(self, other):
31837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31838 
 
31839 
  def __ne__(self, other):
31840 
    return not (self == other)
31841 
 
31842 
class getTelecomCircle_result:
31843 
  """
31844 
  Attributes:
31845 
   - success
31846 
  """
31847 
 
31848 
  thrift_spec = (
31849 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31850 
  )
31851 
 
31852 
  def __init__(self, success=None,):
31853 
    self.success = success
31854 
 
31855 
  def read(self, iprot):
31856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31858 
      return
31859 
    iprot.readStructBegin()
31860 
    while True:
31861 
      (fname, ftype, fid) = iprot.readFieldBegin()
31862 
      if ftype == TType.STOP:
31863 
        break
31864 
      if fid == 0:
31865 
        if ftype == TType.STRUCT:
31866 
          self.success = TelecomCircle()
31867 
          self.success.read(iprot)
31868 
        else:
31869 
          iprot.skip(ftype)
31870 
      else:
31871 
        iprot.skip(ftype)
31872 
      iprot.readFieldEnd()
31873 
    iprot.readStructEnd()
31874 
 
31875 
  def write(self, oprot):
31876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31878 
      return
31879 
    oprot.writeStructBegin('getTelecomCircle_result')
31880 
    if self.success is not None:
31881 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31882 
      self.success.write(oprot)
31883 
      oprot.writeFieldEnd()
31884 
    oprot.writeFieldStop()
31885 
    oprot.writeStructEnd()
31886 
 
31887 
  def validate(self):
31888 
    return
31889 
 
31890 
 
31891 
  def __repr__(self):
31892 
    L = ['%s=%r' % (key, value)
31893 
      for key, value in self.__dict__.iteritems()]
31894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31895 
 
31896 
  def __eq__(self, other):
31897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31898 
 
31899 
  def __ne__(self, other):
31900 
    return not (self == other)
7109 anupam.sin 31901 
 
31902 
class retrieveHotspotRechargeInvoice_args:
31903 
  """
31904 
  Attributes:
31905 
   - rechargeId
31906 
  """
31907 
 
31908 
  thrift_spec = (
31909 
    None, # 0
31910 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31911 
  )
31912 
 
31913 
  def __init__(self, rechargeId=None,):
31914 
    self.rechargeId = rechargeId
31915 
 
31916 
  def read(self, iprot):
31917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31919 
      return
31920 
    iprot.readStructBegin()
31921 
    while True:
31922 
      (fname, ftype, fid) = iprot.readFieldBegin()
31923 
      if ftype == TType.STOP:
31924 
        break
31925 
      if fid == 1:
31926 
        if ftype == TType.I64:
31927 
          self.rechargeId = iprot.readI64();
31928 
        else:
31929 
          iprot.skip(ftype)
31930 
      else:
31931 
        iprot.skip(ftype)
31932 
      iprot.readFieldEnd()
31933 
    iprot.readStructEnd()
31934 
 
31935 
  def write(self, oprot):
31936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31938 
      return
31939 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
31940 
    if self.rechargeId is not None:
31941 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31942 
      oprot.writeI64(self.rechargeId)
31943 
      oprot.writeFieldEnd()
31944 
    oprot.writeFieldStop()
31945 
    oprot.writeStructEnd()
31946 
 
31947 
  def validate(self):
31948 
    return
31949 
 
31950 
 
31951 
  def __repr__(self):
31952 
    L = ['%s=%r' % (key, value)
31953 
      for key, value in self.__dict__.iteritems()]
31954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31955 
 
31956 
  def __eq__(self, other):
31957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31958 
 
31959 
  def __ne__(self, other):
31960 
    return not (self == other)
31961 
 
31962 
class retrieveHotspotRechargeInvoice_result:
31963 
  """
31964 
  Attributes:
31965 
   - success
31966 
  """
31967 
 
31968 
  thrift_spec = (
31969 
    (0, TType.STRING, 'success', None, None, ), # 0
31970 
  )
31971 
 
31972 
  def __init__(self, success=None,):
31973 
    self.success = success
31974 
 
31975 
  def read(self, iprot):
31976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31978 
      return
31979 
    iprot.readStructBegin()
31980 
    while True:
31981 
      (fname, ftype, fid) = iprot.readFieldBegin()
31982 
      if ftype == TType.STOP:
31983 
        break
31984 
      if fid == 0:
31985 
        if ftype == TType.STRING:
31986 
          self.success = iprot.readString();
31987 
        else:
31988 
          iprot.skip(ftype)
31989 
      else:
31990 
        iprot.skip(ftype)
31991 
      iprot.readFieldEnd()
31992 
    iprot.readStructEnd()
31993 
 
31994 
  def write(self, oprot):
31995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31997 
      return
31998 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
31999 
    if self.success is not None:
32000 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32001 
      oprot.writeString(self.success)
32002 
      oprot.writeFieldEnd()
32003 
    oprot.writeFieldStop()
32004 
    oprot.writeStructEnd()
32005 
 
32006 
  def validate(self):
32007 
    return
32008 
 
32009 
 
32010 
  def __repr__(self):
32011 
    L = ['%s=%r' % (key, value)
32012 
      for key, value in self.__dict__.iteritems()]
32013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32014 
 
32015 
  def __eq__(self, other):
32016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32017 
 
32018 
  def __ne__(self, other):
32019 
    return not (self == other)
7169 anupam.sin 32020 
 
32021 
class getRechargeTransactionsByNumber_args:
32022 
  """
32023 
  Attributes:
32024 
   - number
7172 anupam.sin 32025 
   - storeId
7169 anupam.sin 32026 
  """
32027 
 
32028 
  thrift_spec = (
32029 
    None, # 0
32030 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32031 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32032 
  )
32033 
 
7172 anupam.sin 32034 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32035 
    self.number = number
7172 anupam.sin 32036 
    self.storeId = storeId
7169 anupam.sin 32037 
 
32038 
  def read(self, iprot):
32039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32041 
      return
32042 
    iprot.readStructBegin()
32043 
    while True:
32044 
      (fname, ftype, fid) = iprot.readFieldBegin()
32045 
      if ftype == TType.STOP:
32046 
        break
32047 
      if fid == 1:
32048 
        if ftype == TType.STRING:
32049 
          self.number = iprot.readString();
32050 
        else:
32051 
          iprot.skip(ftype)
7172 anupam.sin 32052 
      elif fid == 2:
32053 
        if ftype == TType.I64:
32054 
          self.storeId = iprot.readI64();
32055 
        else:
32056 
          iprot.skip(ftype)
7169 anupam.sin 32057 
      else:
32058 
        iprot.skip(ftype)
32059 
      iprot.readFieldEnd()
32060 
    iprot.readStructEnd()
32061 
 
32062 
  def write(self, oprot):
32063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32065 
      return
32066 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32067 
    if self.number is not None:
32068 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32069 
      oprot.writeString(self.number)
32070 
      oprot.writeFieldEnd()
7172 anupam.sin 32071 
    if self.storeId is not None:
32072 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32073 
      oprot.writeI64(self.storeId)
32074 
      oprot.writeFieldEnd()
7169 anupam.sin 32075 
    oprot.writeFieldStop()
32076 
    oprot.writeStructEnd()
32077 
 
32078 
  def validate(self):
32079 
    return
32080 
 
32081 
 
32082 
  def __repr__(self):
32083 
    L = ['%s=%r' % (key, value)
32084 
      for key, value in self.__dict__.iteritems()]
32085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32086 
 
32087 
  def __eq__(self, other):
32088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32089 
 
32090 
  def __ne__(self, other):
32091 
    return not (self == other)
32092 
 
32093 
class getRechargeTransactionsByNumber_result:
32094 
  """
32095 
  Attributes:
32096 
   - success
32097 
  """
32098 
 
32099 
  thrift_spec = (
32100 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32101 
  )
32102 
 
32103 
  def __init__(self, success=None,):
32104 
    self.success = success
32105 
 
32106 
  def read(self, iprot):
32107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32109 
      return
32110 
    iprot.readStructBegin()
32111 
    while True:
32112 
      (fname, ftype, fid) = iprot.readFieldBegin()
32113 
      if ftype == TType.STOP:
32114 
        break
32115 
      if fid == 0:
32116 
        if ftype == TType.LIST:
32117 
          self.success = []
32118 
          (_etype761, _size758) = iprot.readListBegin()
32119 
          for _i762 in xrange(_size758):
32120 
            _elem763 = RechargeTransaction()
32121 
            _elem763.read(iprot)
32122 
            self.success.append(_elem763)
32123 
          iprot.readListEnd()
32124 
        else:
32125 
          iprot.skip(ftype)
32126 
      else:
32127 
        iprot.skip(ftype)
32128 
      iprot.readFieldEnd()
32129 
    iprot.readStructEnd()
32130 
 
32131 
  def write(self, oprot):
32132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32134 
      return
32135 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32136 
    if self.success is not None:
32137 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32138 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32139 
      for iter764 in self.success:
32140 
        iter764.write(oprot)
32141 
      oprot.writeListEnd()
32142 
      oprot.writeFieldEnd()
32143 
    oprot.writeFieldStop()
32144 
    oprot.writeStructEnd()
32145 
 
32146 
  def validate(self):
32147 
    return
32148 
 
32149 
 
32150 
  def __repr__(self):
32151 
    L = ['%s=%r' % (key, value)
32152 
      for key, value in self.__dict__.iteritems()]
32153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32154 
 
32155 
  def __eq__(self, other):
32156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32157 
 
32158 
  def __ne__(self, other):
32159 
    return not (self == other)
32160 
 
32161 
class updateHotspotStorePassword_args:
32162 
  """
32163 
  Attributes:
32164 
   - storeId
32165 
   - password
32166 
  """
32167 
 
32168 
  thrift_spec = (
32169 
    None, # 0
32170 
    (1, TType.I64, 'storeId', None, None, ), # 1
32171 
    (2, TType.STRING, 'password', None, None, ), # 2
32172 
  )
32173 
 
32174 
  def __init__(self, storeId=None, password=None,):
32175 
    self.storeId = storeId
32176 
    self.password = password
32177 
 
32178 
  def read(self, iprot):
32179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32181 
      return
32182 
    iprot.readStructBegin()
32183 
    while True:
32184 
      (fname, ftype, fid) = iprot.readFieldBegin()
32185 
      if ftype == TType.STOP:
32186 
        break
32187 
      if fid == 1:
32188 
        if ftype == TType.I64:
32189 
          self.storeId = iprot.readI64();
32190 
        else:
32191 
          iprot.skip(ftype)
32192 
      elif fid == 2:
32193 
        if ftype == TType.STRING:
32194 
          self.password = iprot.readString();
32195 
        else:
32196 
          iprot.skip(ftype)
32197 
      else:
32198 
        iprot.skip(ftype)
32199 
      iprot.readFieldEnd()
32200 
    iprot.readStructEnd()
32201 
 
32202 
  def write(self, oprot):
32203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32205 
      return
32206 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32207 
    if self.storeId is not None:
32208 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32209 
      oprot.writeI64(self.storeId)
32210 
      oprot.writeFieldEnd()
32211 
    if self.password is not None:
32212 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32213 
      oprot.writeString(self.password)
32214 
      oprot.writeFieldEnd()
32215 
    oprot.writeFieldStop()
32216 
    oprot.writeStructEnd()
32217 
 
32218 
  def validate(self):
32219 
    return
32220 
 
32221 
 
32222 
  def __repr__(self):
32223 
    L = ['%s=%r' % (key, value)
32224 
      for key, value in self.__dict__.iteritems()]
32225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32226 
 
32227 
  def __eq__(self, other):
32228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32229 
 
32230 
  def __ne__(self, other):
32231 
    return not (self == other)
32232 
 
32233 
class updateHotspotStorePassword_result:
32234 
  """
32235 
  Attributes:
32236 
   - success
32237 
  """
32238 
 
32239 
  thrift_spec = (
32240 
    (0, TType.BOOL, 'success', None, None, ), # 0
32241 
  )
32242 
 
32243 
  def __init__(self, success=None,):
32244 
    self.success = success
32245 
 
32246 
  def read(self, iprot):
32247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32249 
      return
32250 
    iprot.readStructBegin()
32251 
    while True:
32252 
      (fname, ftype, fid) = iprot.readFieldBegin()
32253 
      if ftype == TType.STOP:
32254 
        break
32255 
      if fid == 0:
32256 
        if ftype == TType.BOOL:
32257 
          self.success = iprot.readBool();
32258 
        else:
32259 
          iprot.skip(ftype)
32260 
      else:
32261 
        iprot.skip(ftype)
32262 
      iprot.readFieldEnd()
32263 
    iprot.readStructEnd()
32264 
 
32265 
  def write(self, oprot):
32266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32268 
      return
32269 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32270 
    if self.success is not None:
32271 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32272 
      oprot.writeBool(self.success)
32273 
      oprot.writeFieldEnd()
32274 
    oprot.writeFieldStop()
32275 
    oprot.writeStructEnd()
32276 
 
32277 
  def validate(self):
32278 
    return
32279 
 
32280 
 
32281 
  def __repr__(self):
32282 
    L = ['%s=%r' % (key, value)
32283 
      for key, value in self.__dict__.iteritems()]
32284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32285 
 
32286 
  def __eq__(self, other):
32287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32288 
 
32289 
  def __ne__(self, other):
32290 
    return not (self == other)