Subversion Repositories SmartDukaan

Rev

Rev 6336 | Rev 6389 | 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 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    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.
525 
    Returns the final flag status.
526 
    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 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    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 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    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 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	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 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    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 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6206 rajveer 1349 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
6206 rajveer 1353 
     - onlyActive
6048 rajveer 1354 
    """
1355 
    pass
6000 mandeep.dh 1356 
 
6049 rajveer 1357 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1358 
    """
1359 
    Parameters:
6049 rajveer 1360 
     - rechargeType
6048 rajveer 1361 
     - deviceNumber
1362 
    """
1363 
    pass
1364 
 
6336 anupam.sin 1365 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 1366 
    """
1367 
    Parameters:
1368 
     - rechargeType
1369 
     - deviceNumber
6307 anupam.sin 1370 
     - userSelectedProviderId
6269 rajveer 1371 
    """
1372 
    pass
1373 
 
6094 rajveer 1374 
  def getRechargeOrdersForDevice(self, deviceNumber):
1375 
    """
1376 
    Parameters:
1377 
     - deviceNumber
1378 
    """
1379 
    pass
6048 rajveer 1380 
 
6094 rajveer 1381 
  def addAmountToWallet(self, userId, orderId, amount):
1382 
    """
1383 
    Parameters:
1384 
     - userId
1385 
     - orderId
1386 
     - amount
1387 
    """
1388 
    pass
1389 
 
6188 rajveer 1390 
  def getRechargeStatistics(self, ):
1391 
    pass
1392 
 
6154 rajveer 1393 
  def getRechargeOrdersForStatus(self, status):
1394 
    """
1395 
    Parameters:
1396 
     - status
1397 
    """
1398 
    pass
6094 rajveer 1399 
 
6159 rajveer 1400 
  def getPlansForOperator(self, operatorId):
1401 
    """
1402 
    Parameters:
1403 
     - operatorId
1404 
    """
1405 
    pass
6154 rajveer 1406 
 
6307 anupam.sin 1407 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1408 
    """
1409 
    Returns denominations for a given operator and circle
6159 rajveer 1410 
 
6289 anupam.sin 1411 
    Parameters:
1412 
     - operatorId
6307 anupam.sin 1413 
     - circleCode
6289 anupam.sin 1414 
     - denominationType
1415 
    """
1416 
    pass
1417 
 
6371 rajveer 1418 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1419 
    """
1420 
    Parameters:
1421 
     - operatorId
1422 
     - circleId
1423 
     - isAvailable
1424 
    """
1425 
    pass
6289 anupam.sin 1426 
 
6371 rajveer 1427 
 
3376 rajveer 1428 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1429 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1430 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1431 
 
1432 
  def createTransaction(self, transaction):
1433 
    """
1434 
    Parameters:
1435 
     - transaction
1436 
    """
1437 
    self.send_createTransaction(transaction)
132 ashish 1438 
    return self.recv_createTransaction()
94 ashish 1439 
 
1440 
  def send_createTransaction(self, transaction):
1441 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1442 
    args = createTransaction_args()
1443 
    args.transaction = transaction
1444 
    args.write(self._oprot)
1445 
    self._oprot.writeMessageEnd()
1446 
    self._oprot.trans.flush()
1447 
 
1448 
  def recv_createTransaction(self, ):
1449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1450 
    if mtype == TMessageType.EXCEPTION:
1451 
      x = TApplicationException()
1452 
      x.read(self._iprot)
1453 
      self._iprot.readMessageEnd()
1454 
      raise x
1455 
    result = createTransaction_result()
1456 
    result.read(self._iprot)
1457 
    self._iprot.readMessageEnd()
3431 rajveer 1458 
    if result.success is not None:
132 ashish 1459 
      return result.success
3431 rajveer 1460 
    if result.ex is not None:
94 ashish 1461 
      raise result.ex
132 ashish 1462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1463 
 
1464 
  def getTransaction(self, id):
1465 
    """
1466 
    Parameters:
1467 
     - id
1468 
    """
1469 
    self.send_getTransaction(id)
1470 
    return self.recv_getTransaction()
1471 
 
1472 
  def send_getTransaction(self, id):
1473 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1474 
    args = getTransaction_args()
1475 
    args.id = id
1476 
    args.write(self._oprot)
1477 
    self._oprot.writeMessageEnd()
1478 
    self._oprot.trans.flush()
1479 
 
1480 
  def recv_getTransaction(self, ):
1481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1482 
    if mtype == TMessageType.EXCEPTION:
1483 
      x = TApplicationException()
1484 
      x.read(self._iprot)
1485 
      self._iprot.readMessageEnd()
1486 
      raise x
1487 
    result = getTransaction_result()
1488 
    result.read(self._iprot)
1489 
    self._iprot.readMessageEnd()
3431 rajveer 1490 
    if result.success is not None:
94 ashish 1491 
      return result.success
3431 rajveer 1492 
    if result.ex is not None:
94 ashish 1493 
      raise result.ex
1494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1495 
 
1496 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1497 
    """
1498 
    Parameters:
1499 
     - customerId
1500 
     - from_date
1501 
     - to_date
1502 
     - status
1503 
    """
1504 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1505 
    return self.recv_getTransactionsForCustomer()
1506 
 
1507 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1508 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1509 
    args = getTransactionsForCustomer_args()
1510 
    args.customerId = customerId
1511 
    args.from_date = from_date
1512 
    args.to_date = to_date
1513 
    args.status = status
1514 
    args.write(self._oprot)
1515 
    self._oprot.writeMessageEnd()
1516 
    self._oprot.trans.flush()
1517 
 
1518 
  def recv_getTransactionsForCustomer(self, ):
1519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1520 
    if mtype == TMessageType.EXCEPTION:
1521 
      x = TApplicationException()
1522 
      x.read(self._iprot)
1523 
      self._iprot.readMessageEnd()
1524 
      raise x
1525 
    result = getTransactionsForCustomer_result()
1526 
    result.read(self._iprot)
1527 
    self._iprot.readMessageEnd()
3431 rajveer 1528 
    if result.success is not None:
94 ashish 1529 
      return result.success
3431 rajveer 1530 
    if result.ex is not None:
94 ashish 1531 
      raise result.ex
1532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1533 
 
132 ashish 1534 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1535 
    """
1536 
    Parameters:
1537 
     - shoppingCartId
1538 
    """
1539 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1540 
    return self.recv_getTransactionsForShoppingCartId()
1541 
 
1542 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1543 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1544 
    args = getTransactionsForShoppingCartId_args()
1545 
    args.shoppingCartId = shoppingCartId
1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_getTransactionsForShoppingCartId(self, ):
1551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1552 
    if mtype == TMessageType.EXCEPTION:
1553 
      x = TApplicationException()
1554 
      x.read(self._iprot)
1555 
      self._iprot.readMessageEnd()
1556 
      raise x
1557 
    result = getTransactionsForShoppingCartId_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
3431 rajveer 1560 
    if result.success is not None:
132 ashish 1561 
      return result.success
3431 rajveer 1562 
    if result.ex is not None:
132 ashish 1563 
      raise result.ex
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1565 
 
94 ashish 1566 
  def getTransactionStatus(self, transactionId):
1567 
    """
1568 
    Parameters:
1569 
     - transactionId
1570 
    """
1571 
    self.send_getTransactionStatus(transactionId)
1572 
    return self.recv_getTransactionStatus()
1573 
 
1574 
  def send_getTransactionStatus(self, transactionId):
1575 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1576 
    args = getTransactionStatus_args()
1577 
    args.transactionId = transactionId
1578 
    args.write(self._oprot)
1579 
    self._oprot.writeMessageEnd()
1580 
    self._oprot.trans.flush()
1581 
 
1582 
  def recv_getTransactionStatus(self, ):
1583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1584 
    if mtype == TMessageType.EXCEPTION:
1585 
      x = TApplicationException()
1586 
      x.read(self._iprot)
1587 
      self._iprot.readMessageEnd()
1588 
      raise x
1589 
    result = getTransactionStatus_result()
1590 
    result.read(self._iprot)
1591 
    self._iprot.readMessageEnd()
3431 rajveer 1592 
    if result.success is not None:
94 ashish 1593 
      return result.success
3431 rajveer 1594 
    if result.ex is not None:
94 ashish 1595 
      raise result.ex
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1597 
 
5527 anupam.sin 1598 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1599 
    """
1600 
    Parameters:
1601 
     - transactionId
1602 
     - status
1603 
     - description
5527 anupam.sin 1604 
     - pickUp
1605 
     - orderType
94 ashish 1606 
    """
5527 anupam.sin 1607 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1608 
    return self.recv_changeTransactionStatus()
1609 
 
5527 anupam.sin 1610 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1611 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1612 
    args = changeTransactionStatus_args()
1613 
    args.transactionId = transactionId
1614 
    args.status = status
1615 
    args.description = description
5527 anupam.sin 1616 
    args.pickUp = pickUp
1617 
    args.orderType = orderType
94 ashish 1618 
    args.write(self._oprot)
1619 
    self._oprot.writeMessageEnd()
1620 
    self._oprot.trans.flush()
1621 
 
1622 
  def recv_changeTransactionStatus(self, ):
1623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1624 
    if mtype == TMessageType.EXCEPTION:
1625 
      x = TApplicationException()
1626 
      x.read(self._iprot)
1627 
      self._iprot.readMessageEnd()
1628 
      raise x
1629 
    result = changeTransactionStatus_result()
1630 
    result.read(self._iprot)
1631 
    self._iprot.readMessageEnd()
3431 rajveer 1632 
    if result.success is not None:
94 ashish 1633 
      return result.success
3431 rajveer 1634 
    if result.ex is not None:
94 ashish 1635 
      raise result.ex
1636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1637 
 
1398 varun.gupt 1638 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1639 
    """
1640 
    Parameters:
1641 
     - transactionId
1642 
    """
1398 varun.gupt 1643 
    self.send_enqueueTransactionInfoEmail(transactionId)
1644 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1645 
 
1398 varun.gupt 1646 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1647 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1648 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1649 
    args.transactionId = transactionId
1650 
    args.write(self._oprot)
1651 
    self._oprot.writeMessageEnd()
1652 
    self._oprot.trans.flush()
1653 
 
1398 varun.gupt 1654 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1656 
    if mtype == TMessageType.EXCEPTION:
1657 
      x = TApplicationException()
1658 
      x.read(self._iprot)
1659 
      self._iprot.readMessageEnd()
1660 
      raise x
1398 varun.gupt 1661 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1662 
    result.read(self._iprot)
1663 
    self._iprot.readMessageEnd()
3431 rajveer 1664 
    if result.success is not None:
1382 varun.gupt 1665 
      return result.success
3431 rajveer 1666 
    if result.ex is not None:
1382 varun.gupt 1667 
      raise result.ex
1398 varun.gupt 1668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1669 
 
4801 anupam.sin 1670 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1671 
    """
1672 
    Parameters:
4801 anupam.sin 1673 
     - statuses
483 rajveer 1674 
     - from_date
1675 
     - to_date
1676 
     - warehouse_id
94 ashish 1677 
    """
4801 anupam.sin 1678 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1679 
    return self.recv_getAllOrders()
94 ashish 1680 
 
4801 anupam.sin 1681 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1682 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1683 
    args = getAllOrders_args()
4801 anupam.sin 1684 
    args.statuses = statuses
483 rajveer 1685 
    args.from_date = from_date
1686 
    args.to_date = to_date
1687 
    args.warehouse_id = warehouse_id
94 ashish 1688 
    args.write(self._oprot)
1689 
    self._oprot.writeMessageEnd()
1690 
    self._oprot.trans.flush()
1691 
 
483 rajveer 1692 
  def recv_getAllOrders(self, ):
94 ashish 1693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1694 
    if mtype == TMessageType.EXCEPTION:
1695 
      x = TApplicationException()
1696 
      x.read(self._iprot)
1697 
      self._iprot.readMessageEnd()
1698 
      raise x
483 rajveer 1699 
    result = getAllOrders_result()
94 ashish 1700 
    result.read(self._iprot)
1701 
    self._iprot.readMessageEnd()
3431 rajveer 1702 
    if result.success is not None:
94 ashish 1703 
      return result.success
3431 rajveer 1704 
    if result.ex is not None:
94 ashish 1705 
      raise result.ex
483 rajveer 1706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1707 
 
4133 chandransh 1708 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1709 
    """
1710 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1711 
    Pass the status as null and the limit as 0 to ignore them.
1712 
 
1713 
    Parameters:
1714 
     - statuses
1715 
     - offset
1716 
     - limit
1717 
     - warehouse_id
1718 
    """
1719 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1720 
    return self.recv_getOrdersInBatch()
1721 
 
1722 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1723 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1724 
    args = getOrdersInBatch_args()
1725 
    args.statuses = statuses
1726 
    args.offset = offset
1727 
    args.limit = limit
1728 
    args.warehouse_id = warehouse_id
1729 
    args.write(self._oprot)
1730 
    self._oprot.writeMessageEnd()
1731 
    self._oprot.trans.flush()
1732 
 
1733 
  def recv_getOrdersInBatch(self, ):
1734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1735 
    if mtype == TMessageType.EXCEPTION:
1736 
      x = TApplicationException()
1737 
      x.read(self._iprot)
1738 
      self._iprot.readMessageEnd()
1739 
      raise x
1740 
    result = getOrdersInBatch_result()
1741 
    result.read(self._iprot)
1742 
    self._iprot.readMessageEnd()
1743 
    if result.success is not None:
1744 
      return result.success
1745 
    if result.ex is not None:
1746 
      raise result.ex
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1748 
 
1749 
  def getOrderCount(self, statuses, warehouseId):
1750 
    """
1751 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1752 
 
1753 
    Parameters:
1754 
     - statuses
1755 
     - warehouseId
1756 
    """
1757 
    self.send_getOrderCount(statuses, warehouseId)
1758 
    return self.recv_getOrderCount()
1759 
 
1760 
  def send_getOrderCount(self, statuses, warehouseId):
1761 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1762 
    args = getOrderCount_args()
1763 
    args.statuses = statuses
1764 
    args.warehouseId = warehouseId
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_getOrderCount(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = getOrderCount_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
1779 
    if result.success is not None:
1780 
      return result.success
1781 
    if result.ex is not None:
1782 
      raise result.ex
1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1784 
 
999 varun.gupt 1785 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1786 
    """
1132 chandransh 1787 
    Returns orders within a range of their billing dates
3431 rajveer 1788 
 
999 varun.gupt 1789 
    Parameters:
1790 
     - status
1791 
     - start_billing_date
1792 
     - end_billing_date
1793 
     - warehouse_id
1794 
    """
1795 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1796 
    return self.recv_getOrdersByBillingDate()
1797 
 
1798 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1799 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1800 
    args = getOrdersByBillingDate_args()
1801 
    args.status = status
1802 
    args.start_billing_date = start_billing_date
1803 
    args.end_billing_date = end_billing_date
1804 
    args.warehouse_id = warehouse_id
1805 
    args.write(self._oprot)
1806 
    self._oprot.writeMessageEnd()
1807 
    self._oprot.trans.flush()
1808 
 
1809 
  def recv_getOrdersByBillingDate(self, ):
1810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1811 
    if mtype == TMessageType.EXCEPTION:
1812 
      x = TApplicationException()
1813 
      x.read(self._iprot)
1814 
      self._iprot.readMessageEnd()
1815 
      raise x
1816 
    result = getOrdersByBillingDate_result()
1817 
    result.read(self._iprot)
1818 
    self._iprot.readMessageEnd()
3431 rajveer 1819 
    if result.success is not None:
999 varun.gupt 1820 
      return result.success
3431 rajveer 1821 
    if result.ex is not None:
999 varun.gupt 1822 
      raise result.ex
1823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1824 
 
3451 chandransh 1825 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1826 
    """
1827 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1828 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1829 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1830 
 
3427 chandransh 1831 
    Parameters:
1832 
     - fromShippingDate
1833 
     - toShippingDate
1834 
     - providerId
1835 
     - warehouseId
3451 chandransh 1836 
     - cod
3427 chandransh 1837 
    """
3451 chandransh 1838 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1839 
    return self.recv_getOrdersByShippingDate()
1840 
 
3451 chandransh 1841 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1842 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1843 
    args = getOrdersByShippingDate_args()
1844 
    args.fromShippingDate = fromShippingDate
1845 
    args.toShippingDate = toShippingDate
1846 
    args.providerId = providerId
1847 
    args.warehouseId = warehouseId
3451 chandransh 1848 
    args.cod = cod
3427 chandransh 1849 
    args.write(self._oprot)
1850 
    self._oprot.writeMessageEnd()
1851 
    self._oprot.trans.flush()
1852 
 
1853 
  def recv_getOrdersByShippingDate(self, ):
1854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1855 
    if mtype == TMessageType.EXCEPTION:
1856 
      x = TApplicationException()
1857 
      x.read(self._iprot)
1858 
      self._iprot.readMessageEnd()
1859 
      raise x
1860 
    result = getOrdersByShippingDate_result()
1861 
    result.read(self._iprot)
1862 
    self._iprot.readMessageEnd()
3431 rajveer 1863 
    if result.success is not None:
3427 chandransh 1864 
      return result.success
3431 rajveer 1865 
    if result.ex is not None:
3427 chandransh 1866 
      raise result.ex
1867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1868 
 
1382 varun.gupt 1869 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1870 
    """
1871 
    Returns order ids for orders which can be returned
3431 rajveer 1872 
 
1382 varun.gupt 1873 
    Parameters:
1874 
     - customer_id
1875 
     - limit
1876 
    """
1877 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1878 
    return self.recv_getReturnableOrdersForCustomer()
1879 
 
1880 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1881 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1882 
    args = getReturnableOrdersForCustomer_args()
1883 
    args.customer_id = customer_id
1884 
    args.limit = limit
1885 
    args.write(self._oprot)
1886 
    self._oprot.writeMessageEnd()
1887 
    self._oprot.trans.flush()
1888 
 
1889 
  def recv_getReturnableOrdersForCustomer(self, ):
1890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1891 
    if mtype == TMessageType.EXCEPTION:
1892 
      x = TApplicationException()
1893 
      x.read(self._iprot)
1894 
      self._iprot.readMessageEnd()
1895 
      raise x
1896 
    result = getReturnableOrdersForCustomer_result()
1897 
    result.read(self._iprot)
1898 
    self._iprot.readMessageEnd()
3431 rajveer 1899 
    if result.success is not None:
1382 varun.gupt 1900 
      return result.success
3431 rajveer 1901 
    if result.ex is not None:
1382 varun.gupt 1902 
      raise result.ex
1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1904 
 
1905 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1906 
    """
1907 
    Returns order ids for orders which can be cancelled
3431 rajveer 1908 
 
1382 varun.gupt 1909 
    Parameters:
1910 
     - customer_id
1911 
     - limit
1912 
    """
1913 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1914 
    return self.recv_getCancellableOrdersForCustomer()
1915 
 
1916 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1917 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1918 
    args = getCancellableOrdersForCustomer_args()
1919 
    args.customer_id = customer_id
1920 
    args.limit = limit
1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1925 
  def recv_getCancellableOrdersForCustomer(self, ):
1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1932 
    result = getCancellableOrdersForCustomer_result()
1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
3431 rajveer 1935 
    if result.success is not None:
1382 varun.gupt 1936 
      return result.success
3431 rajveer 1937 
    if result.ex is not None:
1382 varun.gupt 1938 
      raise result.ex
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1940 
 
483 rajveer 1941 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1942 
    """
1943 
    Parameters:
483 rajveer 1944 
     - orderId
1945 
     - status
1946 
     - description
94 ashish 1947 
    """
483 rajveer 1948 
    self.send_changeOrderStatus(orderId, status, description)
1949 
    return self.recv_changeOrderStatus()
94 ashish 1950 
 
483 rajveer 1951 
  def send_changeOrderStatus(self, orderId, status, description):
1952 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1953 
    args = changeOrderStatus_args()
1954 
    args.orderId = orderId
1955 
    args.status = status
1956 
    args.description = description
94 ashish 1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
483 rajveer 1961 
  def recv_changeOrderStatus(self, ):
94 ashish 1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
483 rajveer 1968 
    result = changeOrderStatus_result()
94 ashish 1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
94 ashish 1972 
      return result.success
3431 rajveer 1973 
    if result.ex is not None:
94 ashish 1974 
      raise result.ex
483 rajveer 1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1976 
 
1528 ankur.sing 1977 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1978 
    """
1528 ankur.sing 1979 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1980 
    only user who owns the transaction can view its order details.
3431 rajveer 1981 
 
94 ashish 1982 
    Parameters:
1983 
     - transactionId
1528 ankur.sing 1984 
     - customerId
94 ashish 1985 
    """
1528 ankur.sing 1986 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1987 
    return self.recv_getOrdersForTransaction()
94 ashish 1988 
 
1528 ankur.sing 1989 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1990 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1991 
    args = getOrdersForTransaction_args()
94 ashish 1992 
    args.transactionId = transactionId
1528 ankur.sing 1993 
    args.customerId = customerId
94 ashish 1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
483 rajveer 1998 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
483 rajveer 2005 
    result = getOrdersForTransaction_result()
94 ashish 2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
3431 rajveer 2008 
    if result.success is not None:
94 ashish 2009 
      return result.success
3431 rajveer 2010 
    if result.ex is not None:
94 ashish 2011 
      raise result.ex
483 rajveer 2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2013 
 
3014 chandransh 2014 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2015 
    """
3014 chandransh 2016 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2017 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2018 
 
94 ashish 2019 
    Parameters:
483 rajveer 2020 
     - customerId
2021 
     - from_date
2022 
     - to_date
3014 chandransh 2023 
     - statuses
94 ashish 2024 
    """
3014 chandransh 2025 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2026 
    return self.recv_getOrdersForCustomer()
94 ashish 2027 
 
3014 chandransh 2028 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2029 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2030 
    args = getOrdersForCustomer_args()
2031 
    args.customerId = customerId
2032 
    args.from_date = from_date
2033 
    args.to_date = to_date
3014 chandransh 2034 
    args.statuses = statuses
94 ashish 2035 
    args.write(self._oprot)
2036 
    self._oprot.writeMessageEnd()
2037 
    self._oprot.trans.flush()
2038 
 
483 rajveer 2039 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2041 
    if mtype == TMessageType.EXCEPTION:
2042 
      x = TApplicationException()
2043 
      x.read(self._iprot)
2044 
      self._iprot.readMessageEnd()
2045 
      raise x
483 rajveer 2046 
    result = getOrdersForCustomer_result()
94 ashish 2047 
    result.read(self._iprot)
2048 
    self._iprot.readMessageEnd()
3431 rajveer 2049 
    if result.success is not None:
94 ashish 2050 
      return result.success
3431 rajveer 2051 
    if result.ex is not None:
94 ashish 2052 
      raise result.ex
483 rajveer 2053 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2054 
 
483 rajveer 2055 
  def createOrder(self, order):
94 ashish 2056 
    """
2057 
    Parameters:
483 rajveer 2058 
     - order
94 ashish 2059 
    """
483 rajveer 2060 
    self.send_createOrder(order)
2061 
    return self.recv_createOrder()
94 ashish 2062 
 
483 rajveer 2063 
  def send_createOrder(self, order):
2064 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2065 
    args = createOrder_args()
2066 
    args.order = order
94 ashish 2067 
    args.write(self._oprot)
2068 
    self._oprot.writeMessageEnd()
2069 
    self._oprot.trans.flush()
2070 
 
483 rajveer 2071 
  def recv_createOrder(self, ):
94 ashish 2072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2073 
    if mtype == TMessageType.EXCEPTION:
2074 
      x = TApplicationException()
2075 
      x.read(self._iprot)
2076 
      self._iprot.readMessageEnd()
2077 
      raise x
483 rajveer 2078 
    result = createOrder_result()
94 ashish 2079 
    result.read(self._iprot)
2080 
    self._iprot.readMessageEnd()
3431 rajveer 2081 
    if result.success is not None:
94 ashish 2082 
      return result.success
3431 rajveer 2083 
    if result.ex is not None:
94 ashish 2084 
      raise result.ex
483 rajveer 2085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2086 
 
483 rajveer 2087 
  def getOrder(self, id):
94 ashish 2088 
    """
2089 
    Parameters:
483 rajveer 2090 
     - id
94 ashish 2091 
    """
483 rajveer 2092 
    self.send_getOrder(id)
2093 
    return self.recv_getOrder()
94 ashish 2094 
 
483 rajveer 2095 
  def send_getOrder(self, id):
2096 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2097 
    args = getOrder_args()
2098 
    args.id = id
94 ashish 2099 
    args.write(self._oprot)
2100 
    self._oprot.writeMessageEnd()
2101 
    self._oprot.trans.flush()
2102 
 
483 rajveer 2103 
  def recv_getOrder(self, ):
94 ashish 2104 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2105 
    if mtype == TMessageType.EXCEPTION:
2106 
      x = TApplicationException()
2107 
      x.read(self._iprot)
2108 
      self._iprot.readMessageEnd()
2109 
      raise x
483 rajveer 2110 
    result = getOrder_result()
94 ashish 2111 
    result.read(self._iprot)
2112 
    self._iprot.readMessageEnd()
3431 rajveer 2113 
    if result.success is not None:
94 ashish 2114 
      return result.success
3431 rajveer 2115 
    if result.ex is not None:
94 ashish 2116 
      raise result.ex
483 rajveer 2117 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2118 
 
483 rajveer 2119 
  def getLineItemsForOrder(self, orderId):
94 ashish 2120 
    """
2121 
    Parameters:
483 rajveer 2122 
     - orderId
94 ashish 2123 
    """
483 rajveer 2124 
    self.send_getLineItemsForOrder(orderId)
2125 
    return self.recv_getLineItemsForOrder()
94 ashish 2126 
 
483 rajveer 2127 
  def send_getLineItemsForOrder(self, orderId):
2128 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2129 
    args = getLineItemsForOrder_args()
2130 
    args.orderId = orderId
94 ashish 2131 
    args.write(self._oprot)
2132 
    self._oprot.writeMessageEnd()
2133 
    self._oprot.trans.flush()
2134 
 
483 rajveer 2135 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2137 
    if mtype == TMessageType.EXCEPTION:
2138 
      x = TApplicationException()
2139 
      x.read(self._iprot)
2140 
      self._iprot.readMessageEnd()
2141 
      raise x
483 rajveer 2142 
    result = getLineItemsForOrder_result()
94 ashish 2143 
    result.read(self._iprot)
2144 
    self._iprot.readMessageEnd()
3431 rajveer 2145 
    if result.success is not None:
94 ashish 2146 
      return result.success
3431 rajveer 2147 
    if result.ex is not None:
94 ashish 2148 
      raise result.ex
483 rajveer 2149 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2150 
 
4999 phani.kuma 2151 
  def getOrderList(self, order_ids):
2152 
    """
2153 
    Parameters:
2154 
     - order_ids
2155 
    """
2156 
    self.send_getOrderList(order_ids)
2157 
    return self.recv_getOrderList()
2158 
 
2159 
  def send_getOrderList(self, order_ids):
2160 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2161 
    args = getOrderList_args()
2162 
    args.order_ids = order_ids
2163 
    args.write(self._oprot)
2164 
    self._oprot.writeMessageEnd()
2165 
    self._oprot.trans.flush()
2166 
 
2167 
  def recv_getOrderList(self, ):
2168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2169 
    if mtype == TMessageType.EXCEPTION:
2170 
      x = TApplicationException()
2171 
      x.read(self._iprot)
2172 
      self._iprot.readMessageEnd()
2173 
      raise x
2174 
    result = getOrderList_result()
2175 
    result.read(self._iprot)
2176 
    self._iprot.readMessageEnd()
2177 
    if result.success is not None:
2178 
      return result.success
2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2180 
 
5386 phani.kuma 2181 
  def getOrderListForVendor(self, order_ids, vendorId):
2182 
    """
2183 
    Parameters:
2184 
     - order_ids
2185 
     - vendorId
2186 
    """
2187 
    self.send_getOrderListForVendor(order_ids, vendorId)
2188 
    return self.recv_getOrderListForVendor()
2189 
 
2190 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2191 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2192 
    args = getOrderListForVendor_args()
2193 
    args.order_ids = order_ids
2194 
    args.vendorId = vendorId
2195 
    args.write(self._oprot)
2196 
    self._oprot.writeMessageEnd()
2197 
    self._oprot.trans.flush()
2198 
 
2199 
  def recv_getOrderListForVendor(self, ):
2200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2201 
    if mtype == TMessageType.EXCEPTION:
2202 
      x = TApplicationException()
2203 
      x.read(self._iprot)
2204 
      self._iprot.readMessageEnd()
2205 
      raise x
2206 
    result = getOrderListForVendor_result()
2207 
    result.read(self._iprot)
2208 
    self._iprot.readMessageEnd()
2209 
    if result.success is not None:
2210 
      return result.success
2211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2212 
 
1528 ankur.sing 2213 
  def getOrderForCustomer(self, orderId, customerId):
2214 
    """
2215 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2216 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2217 
 
1528 ankur.sing 2218 
    Parameters:
2219 
     - orderId
2220 
     - customerId
2221 
    """
2222 
    self.send_getOrderForCustomer(orderId, customerId)
2223 
    return self.recv_getOrderForCustomer()
2224 
 
2225 
  def send_getOrderForCustomer(self, orderId, customerId):
2226 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2227 
    args = getOrderForCustomer_args()
2228 
    args.orderId = orderId
2229 
    args.customerId = customerId
2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
2234 
  def recv_getOrderForCustomer(self, ):
2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
2241 
    result = getOrderForCustomer_result()
2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
3431 rajveer 2244 
    if result.success is not None:
1528 ankur.sing 2245 
      return result.success
3431 rajveer 2246 
    if result.ex is not None:
1528 ankur.sing 2247 
      raise result.ex
2248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2249 
 
4444 rajveer 2250 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2251 
    """
2252 
    Parameters:
4394 rajveer 2253 
     - type
4444 rajveer 2254 
     - warehouseId
4394 rajveer 2255 
     - status
2256 
     - timestamp
3064 chandransh 2257 
    """
4444 rajveer 2258 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2259 
    return self.recv_getAlerts()
2260 
 
4444 rajveer 2261 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2262 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2263 
    args = getAlerts_args()
4394 rajveer 2264 
    args.type = type
4444 rajveer 2265 
    args.warehouseId = warehouseId
4394 rajveer 2266 
    args.status = status
2267 
    args.timestamp = timestamp
3064 chandransh 2268 
    args.write(self._oprot)
2269 
    self._oprot.writeMessageEnd()
2270 
    self._oprot.trans.flush()
2271 
 
2272 
  def recv_getAlerts(self, ):
2273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2274 
    if mtype == TMessageType.EXCEPTION:
2275 
      x = TApplicationException()
2276 
      x.read(self._iprot)
2277 
      self._iprot.readMessageEnd()
2278 
      raise x
2279 
    result = getAlerts_result()
2280 
    result.read(self._iprot)
2281 
    self._iprot.readMessageEnd()
3431 rajveer 2282 
    if result.success is not None:
3064 chandransh 2283 
      return result.success
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2285 
 
4444 rajveer 2286 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2287 
    """
2288 
    Parameters:
2289 
     - type
4444 rajveer 2290 
     - warehouseId
4394 rajveer 2291 
     - description
3064 chandransh 2292 
    """
4444 rajveer 2293 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2294 
    self.recv_addAlert()
3064 chandransh 2295 
 
4444 rajveer 2296 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2297 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2298 
    args = addAlert_args()
3064 chandransh 2299 
    args.type = type
4444 rajveer 2300 
    args.warehouseId = warehouseId
4394 rajveer 2301 
    args.description = description
3064 chandransh 2302 
    args.write(self._oprot)
2303 
    self._oprot.writeMessageEnd()
2304 
    self._oprot.trans.flush()
2305 
 
4394 rajveer 2306 
  def recv_addAlert(self, ):
3064 chandransh 2307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2308 
    if mtype == TMessageType.EXCEPTION:
2309 
      x = TApplicationException()
2310 
      x.read(self._iprot)
2311 
      self._iprot.readMessageEnd()
2312 
      raise x
4394 rajveer 2313 
    result = addAlert_result()
3064 chandransh 2314 
    result.read(self._iprot)
2315 
    self._iprot.readMessageEnd()
2316 
    return
2317 
 
4444 rajveer 2318 
  def markAlertsAsSeen(self, warehouseId):
2319 
    """
2320 
    Parameters:
2321 
     - warehouseId
2322 
    """
2323 
    self.send_markAlertsAsSeen(warehouseId)
2324 
    self.recv_markAlertsAsSeen()
2325 
 
2326 
  def send_markAlertsAsSeen(self, warehouseId):
2327 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2328 
    args = markAlertsAsSeen_args()
2329 
    args.warehouseId = warehouseId
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_markAlertsAsSeen(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = markAlertsAsSeen_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
2344 
    return
2345 
 
3064 chandransh 2346 
  def getValidOrderCount(self, ):
2347 
    """
2348 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2349 
    """
2350 
    self.send_getValidOrderCount()
2351 
    return self.recv_getValidOrderCount()
2352 
 
2353 
  def send_getValidOrderCount(self, ):
2354 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2355 
    args = getValidOrderCount_args()
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
2360 
  def recv_getValidOrderCount(self, ):
2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
2367 
    result = getValidOrderCount_result()
2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
3431 rajveer 2370 
    if result.success is not None:
3064 chandransh 2371 
      return result.success
2372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2373 
 
2374 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2375 
    """
2376 
    Returns the number of distinct customers who have done successful transactions
2377 
    """
2378 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2379 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2380 
 
2381 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2382 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2383 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
2388 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
2395 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
3431 rajveer 2398 
    if result.success is not None:
3064 chandransh 2399 
      return result.success
2400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2401 
 
2402 
  def getValidOrdersAmountRange(self, ):
2403 
    """
2404 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2405 
    List contains two values, first minimum amount and second maximum amount.
2406 
    """
2407 
    self.send_getValidOrdersAmountRange()
2408 
    return self.recv_getValidOrdersAmountRange()
2409 
 
2410 
  def send_getValidOrdersAmountRange(self, ):
2411 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2412 
    args = getValidOrdersAmountRange_args()
2413 
    args.write(self._oprot)
2414 
    self._oprot.writeMessageEnd()
2415 
    self._oprot.trans.flush()
2416 
 
2417 
  def recv_getValidOrdersAmountRange(self, ):
2418 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2419 
    if mtype == TMessageType.EXCEPTION:
2420 
      x = TApplicationException()
2421 
      x.read(self._iprot)
2422 
      self._iprot.readMessageEnd()
2423 
      raise x
2424 
    result = getValidOrdersAmountRange_result()
2425 
    result.read(self._iprot)
2426 
    self._iprot.readMessageEnd()
3431 rajveer 2427 
    if result.success is not None:
3064 chandransh 2428 
      return result.success
2429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2430 
 
5874 rajveer 2431 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2432 
    """
2433 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2434 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2435 
 
3064 chandransh 2436 
    Parameters:
2437 
     - limit
5874 rajveer 2438 
     - onlyStore
3064 chandransh 2439 
    """
5874 rajveer 2440 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2441 
    return self.recv_getValidOrders()
2442 
 
5874 rajveer 2443 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2444 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2445 
    args = getValidOrders_args()
2446 
    args.limit = limit
5874 rajveer 2447 
    args.onlyStore = onlyStore
3064 chandransh 2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_getValidOrders(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = getValidOrders_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
3431 rajveer 2462 
    if result.success is not None:
3064 chandransh 2463 
      return result.success
2464 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2465 
 
1220 chandransh 2466 
  def batchOrders(self, warehouseId):
2467 
    """
2468 
    Create a batch of all the pending orders for the given warehouse.
2469 
    The returned list is orderd by created_timestamp.
2470 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2471 
 
1220 chandransh 2472 
    Parameters:
2473 
     - warehouseId
2474 
    """
2475 
    self.send_batchOrders(warehouseId)
2476 
    return self.recv_batchOrders()
2477 
 
2478 
  def send_batchOrders(self, warehouseId):
2479 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2480 
    args = batchOrders_args()
2481 
    args.warehouseId = warehouseId
2482 
    args.write(self._oprot)
2483 
    self._oprot.writeMessageEnd()
2484 
    self._oprot.trans.flush()
2485 
 
2486 
  def recv_batchOrders(self, ):
2487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2488 
    if mtype == TMessageType.EXCEPTION:
2489 
      x = TApplicationException()
2490 
      x.read(self._iprot)
2491 
      self._iprot.readMessageEnd()
2492 
      raise x
2493 
    result = batchOrders_result()
2494 
    result.read(self._iprot)
2495 
    self._iprot.readMessageEnd()
3431 rajveer 2496 
    if result.success is not None:
1220 chandransh 2497 
      return result.success
3431 rajveer 2498 
    if result.ex is not None:
1220 chandransh 2499 
      raise result.ex
2500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2501 
 
1208 chandransh 2502 
  def markOrderAsOutOfStock(self, orderId):
2503 
    """
2504 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2505 
 
1208 chandransh 2506 
    Parameters:
2507 
     - orderId
2508 
    """
2509 
    self.send_markOrderAsOutOfStock(orderId)
2510 
    return self.recv_markOrderAsOutOfStock()
2511 
 
2512 
  def send_markOrderAsOutOfStock(self, orderId):
2513 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2514 
    args = markOrderAsOutOfStock_args()
2515 
    args.orderId = orderId
2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
2520 
  def recv_markOrderAsOutOfStock(self, ):
2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
2527 
    result = markOrderAsOutOfStock_result()
2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
3431 rajveer 2530 
    if result.success is not None:
1208 chandransh 2531 
      return result.success
3431 rajveer 2532 
    if result.ex is not None:
1208 chandransh 2533 
      raise result.ex
2534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2535 
 
3064 chandransh 2536 
  def verifyOrder(self, orderId):
759 chandransh 2537 
    """
3064 chandransh 2538 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2539 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2540 
    used for all other orders as well.
2541 
    Throws an exception if no such order exists.
3431 rajveer 2542 
 
759 chandransh 2543 
    Parameters:
3064 chandransh 2544 
     - orderId
759 chandransh 2545 
    """
3064 chandransh 2546 
    self.send_verifyOrder(orderId)
2547 
    return self.recv_verifyOrder()
759 chandransh 2548 
 
3064 chandransh 2549 
  def send_verifyOrder(self, orderId):
2550 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2551 
    args = verifyOrder_args()
2552 
    args.orderId = orderId
759 chandransh 2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
3064 chandransh 2557 
  def recv_verifyOrder(self, ):
759 chandransh 2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
3064 chandransh 2564 
    result = verifyOrder_result()
759 chandransh 2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
3431 rajveer 2567 
    if result.success is not None:
759 chandransh 2568 
      return result.success
3431 rajveer 2569 
    if result.ex is not None:
759 chandransh 2570 
      raise result.ex
3064 chandransh 2571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2572 
 
3064 chandransh 2573 
  def acceptOrder(self, orderId):
1113 chandransh 2574 
    """
3064 chandransh 2575 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2576 
    given order is not a COD order, it also captures the payment if the same has
2577 
    not been captured.
2578 
    Throws an exception if no such order exists.
3431 rajveer 2579 
 
1113 chandransh 2580 
    Parameters:
3064 chandransh 2581 
     - orderId
1113 chandransh 2582 
    """
3064 chandransh 2583 
    self.send_acceptOrder(orderId)
2584 
    return self.recv_acceptOrder()
1113 chandransh 2585 
 
3064 chandransh 2586 
  def send_acceptOrder(self, orderId):
2587 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2588 
    args = acceptOrder_args()
2589 
    args.orderId = orderId
1113 chandransh 2590 
    args.write(self._oprot)
2591 
    self._oprot.writeMessageEnd()
2592 
    self._oprot.trans.flush()
2593 
 
3064 chandransh 2594 
  def recv_acceptOrder(self, ):
1113 chandransh 2595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2596 
    if mtype == TMessageType.EXCEPTION:
2597 
      x = TApplicationException()
2598 
      x.read(self._iprot)
2599 
      self._iprot.readMessageEnd()
2600 
      raise x
3064 chandransh 2601 
    result = acceptOrder_result()
1113 chandransh 2602 
    result.read(self._iprot)
2603 
    self._iprot.readMessageEnd()
3431 rajveer 2604 
    if result.success is not None:
1113 chandransh 2605 
      return result.success
3431 rajveer 2606 
    if result.ex is not None:
1113 chandransh 2607 
      raise result.ex
3064 chandransh 2608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2609 
 
5110 mandeep.dh 2610 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2611 
    """
3064 chandransh 2612 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2613 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2614 
    the IMEI no. if a -1 is supplied.
2615 
    Also, it generates an invoice number for the order, marks the order as
2616 
    BILLED and sets the billing timestamp.
2617 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2618 
 
1135 chandransh 2619 
    Parameters:
3064 chandransh 2620 
     - orderId
2621 
     - invoice_number
4658 mandeep.dh 2622 
     - serialNumber
4283 anupam.sin 2623 
     - itemNumber
3064 chandransh 2624 
     - billed_by
4264 rajveer 2625 
     - jacketNumber
4283 anupam.sin 2626 
     - billingType
5110 mandeep.dh 2627 
     - fulfilmentWarehouseId
4763 rajveer 2628 
     - authorize
1135 chandransh 2629 
    """
5110 mandeep.dh 2630 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2631 
    return self.recv_addBillingDetails()
1135 chandransh 2632 
 
5110 mandeep.dh 2633 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2634 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2635 
    args = addBillingDetails_args()
2636 
    args.orderId = orderId
2637 
    args.invoice_number = invoice_number
4658 mandeep.dh 2638 
    args.serialNumber = serialNumber
4283 anupam.sin 2639 
    args.itemNumber = itemNumber
3064 chandransh 2640 
    args.billed_by = billed_by
4264 rajveer 2641 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2642 
    args.billingType = billingType
5110 mandeep.dh 2643 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2644 
    args.authorize = authorize
1135 chandransh 2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
3064 chandransh 2649 
  def recv_addBillingDetails(self, ):
1135 chandransh 2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
3064 chandransh 2656 
    result = addBillingDetails_result()
1135 chandransh 2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
3431 rajveer 2659 
    if result.success is not None:
3064 chandransh 2660 
      return result.success
3431 rajveer 2661 
    if result.ex is not None:
1135 chandransh 2662 
      raise result.ex
3064 chandransh 2663 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2664 
 
4763 rajveer 2665 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2666 
    """
2667 
    Add the invoice number to the order.
2668 
 
2669 
    Parameters:
2670 
     - orderId
2671 
     - invoiceNumber
4763 rajveer 2672 
     - color
4579 rajveer 2673 
    """
4763 rajveer 2674 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2675 
    self.recv_addInvoiceNumber()
2676 
 
4763 rajveer 2677 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2678 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2679 
    args = addInvoiceNumber_args()
2680 
    args.orderId = orderId
2681 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2682 
    args.color = color
4579 rajveer 2683 
    args.write(self._oprot)
2684 
    self._oprot.writeMessageEnd()
2685 
    self._oprot.trans.flush()
2686 
 
2687 
  def recv_addInvoiceNumber(self, ):
2688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2689 
    if mtype == TMessageType.EXCEPTION:
2690 
      x = TApplicationException()
2691 
      x.read(self._iprot)
2692 
      self._iprot.readMessageEnd()
2693 
      raise x
2694 
    result = addInvoiceNumber_result()
2695 
    result.read(self._iprot)
2696 
    self._iprot.readMessageEnd()
2697 
    if result.ex is not None:
2698 
      raise result.ex
2699 
    return
2700 
 
4910 phani.kuma 2701 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2702 
    """
3064 chandransh 2703 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2704 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2705 
 
1408 ankur.sing 2706 
    Parameters:
3064 chandransh 2707 
     - warehouseId
1408 ankur.sing 2708 
     - providerId
3064 chandransh 2709 
     - cod
4910 phani.kuma 2710 
     - orderIds
1408 ankur.sing 2711 
    """
4910 phani.kuma 2712 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2713 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2714 
 
4910 phani.kuma 2715 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2716 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2717 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2718 
    args.warehouseId = warehouseId
1408 ankur.sing 2719 
    args.providerId = providerId
3064 chandransh 2720 
    args.cod = cod
4910 phani.kuma 2721 
    args.orderIds = orderIds
1408 ankur.sing 2722 
    args.write(self._oprot)
2723 
    self._oprot.writeMessageEnd()
2724 
    self._oprot.trans.flush()
2725 
 
4910 phani.kuma 2726 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2728 
    if mtype == TMessageType.EXCEPTION:
2729 
      x = TApplicationException()
2730 
      x.read(self._iprot)
2731 
      self._iprot.readMessageEnd()
2732 
      raise x
4910 phani.kuma 2733 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2734 
    result.read(self._iprot)
2735 
    self._iprot.readMessageEnd()
3431 rajveer 2736 
    if result.success is not None:
1408 ankur.sing 2737 
      return result.success
3431 rajveer 2738 
    if result.ex is not None:
3064 chandransh 2739 
      raise result.ex
4910 phani.kuma 2740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2741 
 
5713 rajveer 2742 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2743 
    """
2744 
    Parameters:
2745 
     - providerId
2746 
     - orderIds
5713 rajveer 2747 
     - awbs
5676 rajveer 2748 
    """
5713 rajveer 2749 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2750 
    return self.recv_markOrdersAsReturnedFromStore()
2751 
 
5713 rajveer 2752 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2753 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2754 
    args = markOrdersAsReturnedFromStore_args()
2755 
    args.providerId = providerId
2756 
    args.orderIds = orderIds
5713 rajveer 2757 
    args.awbs = awbs
5676 rajveer 2758 
    args.write(self._oprot)
2759 
    self._oprot.writeMessageEnd()
2760 
    self._oprot.trans.flush()
2761 
 
2762 
  def recv_markOrdersAsReturnedFromStore(self, ):
2763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2764 
    if mtype == TMessageType.EXCEPTION:
2765 
      x = TApplicationException()
2766 
      x.read(self._iprot)
2767 
      self._iprot.readMessageEnd()
2768 
      raise x
2769 
    result = markOrdersAsReturnedFromStore_result()
2770 
    result.read(self._iprot)
2771 
    self._iprot.readMessageEnd()
2772 
    if result.success is not None:
2773 
      return result.success
2774 
    if result.ex is not None:
2775 
      raise result.ex
2776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2777 
 
4910 phani.kuma 2778 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2779 
    """
4910 phani.kuma 2780 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2781 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2782 
 
2783 
    Parameters:
2784 
     - providerId
4910 phani.kuma 2785 
     - pickupDetails
4410 rajveer 2786 
    """
4910 phani.kuma 2787 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2788 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2789 
 
4910 phani.kuma 2790 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2791 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2792 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2793 
    args.providerId = providerId
4910 phani.kuma 2794 
    args.pickupDetails = pickupDetails
4410 rajveer 2795 
    args.write(self._oprot)
2796 
    self._oprot.writeMessageEnd()
2797 
    self._oprot.trans.flush()
2798 
 
4910 phani.kuma 2799 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2801 
    if mtype == TMessageType.EXCEPTION:
2802 
      x = TApplicationException()
2803 
      x.read(self._iprot)
2804 
      self._iprot.readMessageEnd()
2805 
      raise x
4910 phani.kuma 2806 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2807 
    result.read(self._iprot)
2808 
    self._iprot.readMessageEnd()
2809 
    if result.ex is not None:
2810 
      raise result.ex
4910 phani.kuma 2811 
    return
4410 rajveer 2812 
 
4910 phani.kuma 2813 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2814 
    """
3064 chandransh 2815 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2816 
 
94 ashish 2817 
    Parameters:
3064 chandransh 2818 
     - providerId
304 ashish 2819 
    """
4910 phani.kuma 2820 
    self.send_getOrdersNotPickedUp(providerId)
2821 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2822 
 
4910 phani.kuma 2823 
  def send_getOrdersNotPickedUp(self, providerId):
2824 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2825 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2826 
    args.providerId = providerId
304 ashish 2827 
    args.write(self._oprot)
2828 
    self._oprot.writeMessageEnd()
2829 
    self._oprot.trans.flush()
2830 
 
4910 phani.kuma 2831 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2833 
    if mtype == TMessageType.EXCEPTION:
2834 
      x = TApplicationException()
2835 
      x.read(self._iprot)
2836 
      self._iprot.readMessageEnd()
2837 
      raise x
4910 phani.kuma 2838 
    result = getOrdersNotPickedUp_result()
304 ashish 2839 
    result.read(self._iprot)
2840 
    self._iprot.readMessageEnd()
3431 rajveer 2841 
    if result.success is not None:
304 ashish 2842 
      return result.success
4910 phani.kuma 2843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2844 
 
3064 chandransh 2845 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2846 
    """
3064 chandransh 2847 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2848 
    the name of the receiver.
2849 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2850 
 
304 ashish 2851 
    Parameters:
3064 chandransh 2852 
     - providerId
2853 
     - deliveredOrders
304 ashish 2854 
    """
3064 chandransh 2855 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2856 
    self.recv_markOrdersAsDelivered()
304 ashish 2857 
 
3064 chandransh 2858 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2859 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2860 
    args = markOrdersAsDelivered_args()
2861 
    args.providerId = providerId
2862 
    args.deliveredOrders = deliveredOrders
304 ashish 2863 
    args.write(self._oprot)
2864 
    self._oprot.writeMessageEnd()
2865 
    self._oprot.trans.flush()
2866 
 
3064 chandransh 2867 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2869 
    if mtype == TMessageType.EXCEPTION:
2870 
      x = TApplicationException()
2871 
      x.read(self._iprot)
2872 
      self._iprot.readMessageEnd()
2873 
      raise x
3064 chandransh 2874 
    result = markOrdersAsDelivered_result()
304 ashish 2875 
    result.read(self._iprot)
2876 
    self._iprot.readMessageEnd()
3431 rajveer 2877 
    if result.ex is not None:
3064 chandransh 2878 
      raise result.ex
304 ashish 2879 
    return
2880 
 
4910 phani.kuma 2881 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2882 
    """
4910 phani.kuma 2883 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2884 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2885 
 
3064 chandransh 2886 
    Parameters:
2887 
     - providerId
2888 
     - returnedOrders
1596 ankur.sing 2889 
    """
4910 phani.kuma 2890 
    self.send_markAsRTOrders(providerId, returnedOrders)
2891 
    self.recv_markAsRTOrders()
304 ashish 2892 
 
4910 phani.kuma 2893 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2894 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2895 
    args = markAsRTOrders_args()
3064 chandransh 2896 
    args.providerId = providerId
2897 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2898 
    args.write(self._oprot)
2899 
    self._oprot.writeMessageEnd()
2900 
    self._oprot.trans.flush()
2901 
 
4910 phani.kuma 2902 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2903 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2904 
    if mtype == TMessageType.EXCEPTION:
2905 
      x = TApplicationException()
2906 
      x.read(self._iprot)
2907 
      self._iprot.readMessageEnd()
2908 
      raise x
4910 phani.kuma 2909 
    result = markAsRTOrders_result()
1596 ankur.sing 2910 
    result.read(self._iprot)
2911 
    self._iprot.readMessageEnd()
3431 rajveer 2912 
    if result.ex is not None:
3064 chandransh 2913 
      raise result.ex
2914 
    return
1596 ankur.sing 2915 
 
4910 phani.kuma 2916 
  def getRTOrders(self, providerId):
2917 
    """
2918 
    Returns a list of orders that were returned by courier.
2919 
 
2920 
    Parameters:
2921 
     - providerId
2922 
    """
2923 
    self.send_getRTOrders(providerId)
2924 
    return self.recv_getRTOrders()
2925 
 
2926 
  def send_getRTOrders(self, providerId):
2927 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2928 
    args = getRTOrders_args()
2929 
    args.providerId = providerId
2930 
    args.write(self._oprot)
2931 
    self._oprot.writeMessageEnd()
2932 
    self._oprot.trans.flush()
2933 
 
2934 
  def recv_getRTOrders(self, ):
2935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2936 
    if mtype == TMessageType.EXCEPTION:
2937 
      x = TApplicationException()
2938 
      x.read(self._iprot)
2939 
      self._iprot.readMessageEnd()
2940 
      raise x
2941 
    result = getRTOrders_result()
2942 
    result.read(self._iprot)
2943 
    self._iprot.readMessageEnd()
2944 
    if result.success is not None:
2945 
      return result.success
2946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2947 
 
3064 chandransh 2948 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2949 
    """
3064 chandransh 2950 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2951 
 
3064 chandransh 2952 
    Parameters:
2953 
     - providerId
2954 
     - undeliveredOrders
1627 ankur.sing 2955 
    """
3064 chandransh 2956 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2957 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2958 
 
3064 chandransh 2959 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2960 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2961 
    args = updateNonDeliveryReason_args()
2962 
    args.providerId = providerId
2963 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2964 
    args.write(self._oprot)
2965 
    self._oprot.writeMessageEnd()
2966 
    self._oprot.trans.flush()
2967 
 
3064 chandransh 2968 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2970 
    if mtype == TMessageType.EXCEPTION:
2971 
      x = TApplicationException()
2972 
      x.read(self._iprot)
2973 
      self._iprot.readMessageEnd()
2974 
      raise x
3064 chandransh 2975 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2976 
    result.read(self._iprot)
2977 
    self._iprot.readMessageEnd()
4910 phani.kuma 2978 
    if result.ex is not None:
2979 
      raise result.ex
2980 
    return
2981 
 
2982 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2983 
    """
2984 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2985 
 
2986 
    Parameters:
2987 
     - providerId
2988 
    """
2989 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2990 
    return self.recv_getNonDeliveredOrdersbyCourier()
2991 
 
2992 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2993 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2994 
    args = getNonDeliveredOrdersbyCourier_args()
2995 
    args.providerId = providerId
2996 
    args.write(self._oprot)
2997 
    self._oprot.writeMessageEnd()
2998 
    self._oprot.trans.flush()
2999 
 
3000 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3002 
    if mtype == TMessageType.EXCEPTION:
3003 
      x = TApplicationException()
3004 
      x.read(self._iprot)
3005 
      self._iprot.readMessageEnd()
3006 
      raise x
3007 
    result = getNonDeliveredOrdersbyCourier_result()
3008 
    result.read(self._iprot)
3009 
    self._iprot.readMessageEnd()
4581 phani.kuma 3010 
    if result.success is not None:
3011 
      return result.success
4910 phani.kuma 3012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3013 
 
3014 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3015 
    """
3016 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3017 
 
3018 
    Parameters:
3019 
     - providerId
3020 
     - local_connected_orders
3021 
    """
3022 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3023 
    self.recv_markOrdersAsLocalConnected()
3024 
 
3025 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3026 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3027 
    args = markOrdersAsLocalConnected_args()
3028 
    args.providerId = providerId
3029 
    args.local_connected_orders = local_connected_orders
3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3034 
  def recv_markOrdersAsLocalConnected(self, ):
3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3041 
    result = markOrdersAsLocalConnected_result()
3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
3431 rajveer 3044 
    if result.ex is not None:
3064 chandransh 3045 
      raise result.ex
4910 phani.kuma 3046 
    return
1627 ankur.sing 3047 
 
4910 phani.kuma 3048 
  def getOrdersNotLocalConnected(self, providerId):
3049 
    """
3050 
    Returns a list of orders that were picked up or shipped but pending local connection.
3051 
 
3052 
    Parameters:
3053 
     - providerId
3054 
    """
3055 
    self.send_getOrdersNotLocalConnected(providerId)
3056 
    return self.recv_getOrdersNotLocalConnected()
3057 
 
3058 
  def send_getOrdersNotLocalConnected(self, providerId):
3059 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3060 
    args = getOrdersNotLocalConnected_args()
3061 
    args.providerId = providerId
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_getOrdersNotLocalConnected(self, ):
3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
3073 
    result = getOrdersNotLocalConnected_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3076 
    if result.success is not None:
3077 
      return result.success
3078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3079 
 
3080 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3081 
    """
3082 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3083 
 
3084 
    Parameters:
3085 
     - providerId
3086 
     - destination_city_reached_orders
3087 
    """
3088 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3089 
    self.recv_markOrdersAsDestinationCityReached()
3090 
 
3091 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3092 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3093 
    args = markOrdersAsDestinationCityReached_args()
3094 
    args.providerId = providerId
3095 
    args.destination_city_reached_orders = destination_city_reached_orders
3096 
    args.write(self._oprot)
3097 
    self._oprot.writeMessageEnd()
3098 
    self._oprot.trans.flush()
3099 
 
3100 
  def recv_markOrdersAsDestinationCityReached(self, ):
3101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3102 
    if mtype == TMessageType.EXCEPTION:
3103 
      x = TApplicationException()
3104 
      x.read(self._iprot)
3105 
      self._iprot.readMessageEnd()
3106 
      raise x
3107 
    result = markOrdersAsDestinationCityReached_result()
3108 
    result.read(self._iprot)
3109 
    self._iprot.readMessageEnd()
3110 
    if result.ex is not None:
3111 
      raise result.ex
3112 
    return
3113 
 
3114 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3115 
    """
3116 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3117 
 
3118 
    Parameters:
3119 
     - providerId
3120 
     - first_atdl_orders
3121 
    """
3122 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3123 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3124 
 
3125 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3126 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3127 
    args = markOrdersAsFirstDeliveryAttempted_args()
3128 
    args.providerId = providerId
3129 
    args.first_atdl_orders = first_atdl_orders
3130 
    args.write(self._oprot)
3131 
    self._oprot.writeMessageEnd()
3132 
    self._oprot.trans.flush()
3133 
 
3134 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3136 
    if mtype == TMessageType.EXCEPTION:
3137 
      x = TApplicationException()
3138 
      x.read(self._iprot)
3139 
      self._iprot.readMessageEnd()
3140 
      raise x
3141 
    result = markOrdersAsFirstDeliveryAttempted_result()
3142 
    result.read(self._iprot)
3143 
    self._iprot.readMessageEnd()
3144 
    if result.ex is not None:
3145 
      raise result.ex
3146 
    return
3147 
 
3064 chandransh 3148 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3149 
    """
3064 chandransh 3150 
    Returns the list of orders whose delivery time has passed but have not been
3151 
    delivered yet for the given provider and warehouse. To get a complete list of
3152 
    undelivered orders, pass them as -1.
3153 
    Returns an empty list if no such orders exist.
3431 rajveer 3154 
 
1886 ankur.sing 3155 
    Parameters:
3064 chandransh 3156 
     - providerId
3157 
     - warehouseId
1886 ankur.sing 3158 
    """
3064 chandransh 3159 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3160 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3161 
 
3064 chandransh 3162 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3163 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3164 
    args = getUndeliveredOrders_args()
3165 
    args.providerId = providerId
3166 
    args.warehouseId = warehouseId
1886 ankur.sing 3167 
    args.write(self._oprot)
3168 
    self._oprot.writeMessageEnd()
3169 
    self._oprot.trans.flush()
3170 
 
3064 chandransh 3171 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3173 
    if mtype == TMessageType.EXCEPTION:
3174 
      x = TApplicationException()
3175 
      x.read(self._iprot)
3176 
      self._iprot.readMessageEnd()
3177 
      raise x
3064 chandransh 3178 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3179 
    result.read(self._iprot)
3180 
    self._iprot.readMessageEnd()
3431 rajveer 3181 
    if result.success is not None:
1886 ankur.sing 3182 
      return result.success
3064 chandransh 3183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3184 
 
4783 phani.kuma 3185 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3186 
    """
3187 
    Returns the list of orders whose expected delivery date has passed but have not been
3188 
    delivered yet.
3189 
    Returns an empty list if no such orders exist.
3190 
    """
3191 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3192 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3193 
 
3194 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3195 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3196 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3197 
    args.write(self._oprot)
3198 
    self._oprot.writeMessageEnd()
3199 
    self._oprot.trans.flush()
3200 
 
3201 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3203 
    if mtype == TMessageType.EXCEPTION:
3204 
      x = TApplicationException()
3205 
      x.read(self._iprot)
3206 
      self._iprot.readMessageEnd()
3207 
      raise x
3208 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3209 
    result.read(self._iprot)
3210 
    self._iprot.readMessageEnd()
3211 
    if result.success is not None:
3212 
      return result.success
3213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3214 
 
2536 chandransh 3215 
  def toggleDOAFlag(self, orderId):
3216 
    """
3217 
    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.
3218 
    Returns the final flag status.
3219 
    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 3220 
 
2536 chandransh 3221 
    Parameters:
3222 
     - orderId
3223 
    """
3224 
    self.send_toggleDOAFlag(orderId)
3225 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3226 
 
2536 chandransh 3227 
  def send_toggleDOAFlag(self, orderId):
3228 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3229 
    args = toggleDOAFlag_args()
3230 
    args.orderId = orderId
3231 
    args.write(self._oprot)
3232 
    self._oprot.writeMessageEnd()
3233 
    self._oprot.trans.flush()
3234 
 
3235 
  def recv_toggleDOAFlag(self, ):
3236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3237 
    if mtype == TMessageType.EXCEPTION:
3238 
      x = TApplicationException()
3239 
      x.read(self._iprot)
3240 
      self._iprot.readMessageEnd()
3241 
      raise x
3242 
    result = toggleDOAFlag_result()
3243 
    result.read(self._iprot)
3244 
    self._iprot.readMessageEnd()
3431 rajveer 3245 
    if result.success is not None:
2536 chandransh 3246 
      return result.success
3431 rajveer 3247 
    if result.ex is not None:
2536 chandransh 3248 
      raise result.ex
3249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3250 
 
4712 rajveer 3251 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3252 
    """
3253 
    Parameters:
3254 
     - orderId
3255 
     - deliveryTimestamp
3256 
     - receiver
3257 
    """
3258 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3259 
    self.recv_markOrderAsDelivered()
3260 
 
3261 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3262 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3263 
    args = markOrderAsDelivered_args()
3264 
    args.orderId = orderId
3265 
    args.deliveryTimestamp = deliveryTimestamp
3266 
    args.receiver = receiver
3267 
    args.write(self._oprot)
3268 
    self._oprot.writeMessageEnd()
3269 
    self._oprot.trans.flush()
3270 
 
3271 
  def recv_markOrderAsDelivered(self, ):
3272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3273 
    if mtype == TMessageType.EXCEPTION:
3274 
      x = TApplicationException()
3275 
      x.read(self._iprot)
3276 
      self._iprot.readMessageEnd()
3277 
      raise x
3278 
    result = markOrderAsDelivered_result()
3279 
    result.read(self._iprot)
3280 
    self._iprot.readMessageEnd()
3281 
    if result.ex is not None:
3282 
      raise result.ex
3283 
    return
3284 
 
5553 rajveer 3285 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3286 
    """
3287 
    Parameters:
3288 
     - orderId
3289 
     - deliveryTimestamp
3290 
    """
3291 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3292 
    self.recv_markOrderAsReceivedAtStore()
3293 
 
3294 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3295 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3296 
    args = markOrderAsReceivedAtStore_args()
3297 
    args.orderId = orderId
3298 
    args.deliveryTimestamp = deliveryTimestamp
3299 
    args.write(self._oprot)
3300 
    self._oprot.writeMessageEnd()
3301 
    self._oprot.trans.flush()
3302 
 
3303 
  def recv_markOrderAsReceivedAtStore(self, ):
3304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3305 
    if mtype == TMessageType.EXCEPTION:
3306 
      x = TApplicationException()
3307 
      x.read(self._iprot)
3308 
      self._iprot.readMessageEnd()
3309 
      raise x
3310 
    result = markOrderAsReceivedAtStore_result()
3311 
    result.read(self._iprot)
3312 
    self._iprot.readMessageEnd()
3313 
    if result.ex is not None:
3314 
      raise result.ex
3315 
    return
3316 
 
4454 rajveer 3317 
  def markOrderDoaRequestReceived(self, orderId):
3318 
    """
3319 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3320 
 
3321 
    Parameters:
3322 
     - orderId
3323 
    """
3324 
    self.send_markOrderDoaRequestReceived(orderId)
3325 
    return self.recv_markOrderDoaRequestReceived()
3326 
 
3327 
  def send_markOrderDoaRequestReceived(self, orderId):
3328 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3329 
    args = markOrderDoaRequestReceived_args()
3330 
    args.orderId = orderId
3331 
    args.write(self._oprot)
3332 
    self._oprot.writeMessageEnd()
3333 
    self._oprot.trans.flush()
3334 
 
3335 
  def recv_markOrderDoaRequestReceived(self, ):
3336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3337 
    if mtype == TMessageType.EXCEPTION:
3338 
      x = TApplicationException()
3339 
      x.read(self._iprot)
3340 
      self._iprot.readMessageEnd()
3341 
      raise x
3342 
    result = markOrderDoaRequestReceived_result()
3343 
    result.read(self._iprot)
3344 
    self._iprot.readMessageEnd()
3345 
    if result.success is not None:
3346 
      return result.success
3347 
    if result.ex is not None:
3348 
      raise result.ex
3349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3350 
 
3351 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3352 
    """
3353 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3354 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3355 
 
3356 
    Parameters:
3357 
     - orderId
3358 
     - isAuthorized
3359 
    """
3360 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3361 
    return self.recv_markOrderDoaRequestAuthorized()
3362 
 
3363 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3364 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3365 
    args = markOrderDoaRequestAuthorized_args()
3366 
    args.orderId = orderId
3367 
    args.isAuthorized = isAuthorized
3368 
    args.write(self._oprot)
3369 
    self._oprot.writeMessageEnd()
3370 
    self._oprot.trans.flush()
3371 
 
3372 
  def recv_markOrderDoaRequestAuthorized(self, ):
3373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3374 
    if mtype == TMessageType.EXCEPTION:
3375 
      x = TApplicationException()
3376 
      x.read(self._iprot)
3377 
      self._iprot.readMessageEnd()
3378 
      raise x
3379 
    result = markOrderDoaRequestAuthorized_result()
3380 
    result.read(self._iprot)
3381 
    self._iprot.readMessageEnd()
3382 
    if result.success is not None:
3383 
      return result.success
3384 
    if result.ex is not None:
3385 
      raise result.ex
3386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3387 
 
4488 rajveer 3388 
  def markOrderReturnRequestReceived(self, orderId):
3389 
    """
3390 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3391 
 
3392 
    Parameters:
3393 
     - orderId
3394 
    """
3395 
    self.send_markOrderReturnRequestReceived(orderId)
3396 
    return self.recv_markOrderReturnRequestReceived()
3397 
 
3398 
  def send_markOrderReturnRequestReceived(self, orderId):
3399 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3400 
    args = markOrderReturnRequestReceived_args()
3401 
    args.orderId = orderId
3402 
    args.write(self._oprot)
3403 
    self._oprot.writeMessageEnd()
3404 
    self._oprot.trans.flush()
3405 
 
3406 
  def recv_markOrderReturnRequestReceived(self, ):
3407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3408 
    if mtype == TMessageType.EXCEPTION:
3409 
      x = TApplicationException()
3410 
      x.read(self._iprot)
3411 
      self._iprot.readMessageEnd()
3412 
      raise x
3413 
    result = markOrderReturnRequestReceived_result()
3414 
    result.read(self._iprot)
3415 
    self._iprot.readMessageEnd()
3416 
    if result.success is not None:
3417 
      return result.success
3418 
    if result.ex is not None:
3419 
      raise result.ex
3420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3421 
 
3422 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3423 
    """
3424 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3425 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3426 
 
3427 
    Parameters:
3428 
     - orderId
3429 
     - isAuthorized
3430 
    """
3431 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3432 
    return self.recv_markOrderReturnRequestAuthorized()
3433 
 
3434 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3435 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3436 
    args = markOrderReturnRequestAuthorized_args()
3437 
    args.orderId = orderId
3438 
    args.isAuthorized = isAuthorized
3439 
    args.write(self._oprot)
3440 
    self._oprot.writeMessageEnd()
3441 
    self._oprot.trans.flush()
3442 
 
3443 
  def recv_markOrderReturnRequestAuthorized(self, ):
3444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3445 
    if mtype == TMessageType.EXCEPTION:
3446 
      x = TApplicationException()
3447 
      x.read(self._iprot)
3448 
      self._iprot.readMessageEnd()
3449 
      raise x
3450 
    result = markOrderReturnRequestAuthorized_result()
3451 
    result.read(self._iprot)
3452 
    self._iprot.readMessageEnd()
3453 
    if result.success is not None:
3454 
      return result.success
3455 
    if result.ex is not None:
3456 
      raise result.ex
3457 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3458 
 
4579 rajveer 3459 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3460 
    """
3461 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3462 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3463 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3464 
    For any other status, it returns false.
3465 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3466 
 
2536 chandransh 3467 
    Parameters:
3468 
     - orderId
4579 rajveer 3469 
     - providerId
2536 chandransh 3470 
    """
4579 rajveer 3471 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3472 
    return self.recv_requestPickupNumber()
3473 
 
4579 rajveer 3474 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3475 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3476 
    args = requestPickupNumber_args()
3477 
    args.orderId = orderId
4579 rajveer 3478 
    args.providerId = providerId
2536 chandransh 3479 
    args.write(self._oprot)
3480 
    self._oprot.writeMessageEnd()
3481 
    self._oprot.trans.flush()
3482 
 
3483 
  def recv_requestPickupNumber(self, ):
3484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3485 
    if mtype == TMessageType.EXCEPTION:
3486 
      x = TApplicationException()
3487 
      x.read(self._iprot)
3488 
      self._iprot.readMessageEnd()
3489 
      raise x
3490 
    result = requestPickupNumber_result()
3491 
    result.read(self._iprot)
3492 
    self._iprot.readMessageEnd()
3431 rajveer 3493 
    if result.success is not None:
2536 chandransh 3494 
      return result.success
3431 rajveer 3495 
    if result.ex is not None:
2536 chandransh 3496 
      raise result.ex
3497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3498 
 
4602 rajveer 3499 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3500 
    """
4452 rajveer 3501 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3502 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3503 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3504 
    	3. Returns true
2591 chandransh 3505 
    If the order is in any other status, it returns false.
2536 chandransh 3506 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3507 
 
2536 chandransh 3508 
    Parameters:
3509 
     - orderId
3510 
     - pickupNumber
4602 rajveer 3511 
     - providerId
2536 chandransh 3512 
    """
4602 rajveer 3513 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3514 
    return self.recv_authorizePickup()
3515 
 
4602 rajveer 3516 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3517 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3518 
    args = authorizePickup_args()
3519 
    args.orderId = orderId
3520 
    args.pickupNumber = pickupNumber
4602 rajveer 3521 
    args.providerId = providerId
2536 chandransh 3522 
    args.write(self._oprot)
3523 
    self._oprot.writeMessageEnd()
3524 
    self._oprot.trans.flush()
3525 
 
3526 
  def recv_authorizePickup(self, ):
3527 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3528 
    if mtype == TMessageType.EXCEPTION:
3529 
      x = TApplicationException()
3530 
      x.read(self._iprot)
3531 
      self._iprot.readMessageEnd()
3532 
      raise x
3533 
    result = authorizePickup_result()
3534 
    result.read(self._iprot)
3535 
    self._iprot.readMessageEnd()
3431 rajveer 3536 
    if result.success is not None:
2536 chandransh 3537 
      return result.success
3431 rajveer 3538 
    if result.ex is not None:
2536 chandransh 3539 
      raise result.ex
3540 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3541 
 
2764 chandransh 3542 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3543 
    """
3544 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3545 
 
2764 chandransh 3546 
    Parameters:
3547 
     - providerId
3548 
     - pickupDetails
3549 
    """
3550 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3551 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3552 
 
3553 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3554 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3555 
    args = markDoasAsPickedUp_args()
3556 
    args.providerId = providerId
3557 
    args.pickupDetails = pickupDetails
3558 
    args.write(self._oprot)
3559 
    self._oprot.writeMessageEnd()
3560 
    self._oprot.trans.flush()
3561 
 
3562 
  def recv_markDoasAsPickedUp(self, ):
3563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3564 
    if mtype == TMessageType.EXCEPTION:
3565 
      x = TApplicationException()
3566 
      x.read(self._iprot)
3567 
      self._iprot.readMessageEnd()
3568 
      raise x
3569 
    result = markDoasAsPickedUp_result()
3570 
    result.read(self._iprot)
3571 
    self._iprot.readMessageEnd()
4910 phani.kuma 3572 
    return
3573 
 
3574 
  def getDoasNotPickedUp(self, providerId):
3575 
    """
3576 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3577 
 
3578 
    Parameters:
3579 
     - providerId
3580 
    """
3581 
    self.send_getDoasNotPickedUp(providerId)
3582 
    return self.recv_getDoasNotPickedUp()
3583 
 
3584 
  def send_getDoasNotPickedUp(self, providerId):
3585 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3586 
    args = getDoasNotPickedUp_args()
3587 
    args.providerId = providerId
3588 
    args.write(self._oprot)
3589 
    self._oprot.writeMessageEnd()
3590 
    self._oprot.trans.flush()
3591 
 
3592 
  def recv_getDoasNotPickedUp(self, ):
3593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3594 
    if mtype == TMessageType.EXCEPTION:
3595 
      x = TApplicationException()
3596 
      x.read(self._iprot)
3597 
      self._iprot.readMessageEnd()
3598 
      raise x
3599 
    result = getDoasNotPickedUp_result()
3600 
    result.read(self._iprot)
3601 
    self._iprot.readMessageEnd()
3431 rajveer 3602 
    if result.success is not None:
2764 chandransh 3603 
      return result.success
4910 phani.kuma 3604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3605 
 
4741 phani.kuma 3606 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3607 
    """
3608 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3609 
 
3610 
    Parameters:
3611 
     - providerId
3612 
     - pickupDetails
3613 
    """
3614 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3615 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3616 
 
3617 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3618 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3619 
    args = markReturnOrdersAsPickedUp_args()
3620 
    args.providerId = providerId
3621 
    args.pickupDetails = pickupDetails
3622 
    args.write(self._oprot)
3623 
    self._oprot.writeMessageEnd()
3624 
    self._oprot.trans.flush()
3625 
 
3626 
  def recv_markReturnOrdersAsPickedUp(self, ):
3627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3628 
    if mtype == TMessageType.EXCEPTION:
3629 
      x = TApplicationException()
3630 
      x.read(self._iprot)
3631 
      self._iprot.readMessageEnd()
3632 
      raise x
3633 
    result = markReturnOrdersAsPickedUp_result()
3634 
    result.read(self._iprot)
3635 
    self._iprot.readMessageEnd()
4910 phani.kuma 3636 
    return
3637 
 
3638 
  def getReturnOrdersNotPickedUp(self, providerId):
3639 
    """
3640 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3641 
 
3642 
    Parameters:
3643 
     - providerId
3644 
    """
3645 
    self.send_getReturnOrdersNotPickedUp(providerId)
3646 
    return self.recv_getReturnOrdersNotPickedUp()
3647 
 
3648 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3649 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3650 
    args = getReturnOrdersNotPickedUp_args()
3651 
    args.providerId = providerId
3652 
    args.write(self._oprot)
3653 
    self._oprot.writeMessageEnd()
3654 
    self._oprot.trans.flush()
3655 
 
3656 
  def recv_getReturnOrdersNotPickedUp(self, ):
3657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3658 
    if mtype == TMessageType.EXCEPTION:
3659 
      x = TApplicationException()
3660 
      x.read(self._iprot)
3661 
      self._iprot.readMessageEnd()
3662 
      raise x
3663 
    result = getReturnOrdersNotPickedUp_result()
3664 
    result.read(self._iprot)
3665 
    self._iprot.readMessageEnd()
4741 phani.kuma 3666 
    if result.success is not None:
3667 
      return result.success
4910 phani.kuma 3668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3669 
 
4479 rajveer 3670 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3671 
    """
4452 rajveer 3672 
    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 3673 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3674 
    If the order is in any other state, it returns false.
3675 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3676 
 
2591 chandransh 3677 
    Parameters:
3678 
     - orderId
4479 rajveer 3679 
     - receiveCondition
2591 chandransh 3680 
    """
4479 rajveer 3681 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3682 
    return self.recv_receiveReturn()
2536 chandransh 3683 
 
4479 rajveer 3684 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3685 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3686 
    args = receiveReturn_args()
2591 chandransh 3687 
    args.orderId = orderId
4479 rajveer 3688 
    args.receiveCondition = receiveCondition
2591 chandransh 3689 
    args.write(self._oprot)
3690 
    self._oprot.writeMessageEnd()
3691 
    self._oprot.trans.flush()
3692 
 
2616 chandransh 3693 
  def recv_receiveReturn(self, ):
2591 chandransh 3694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3695 
    if mtype == TMessageType.EXCEPTION:
3696 
      x = TApplicationException()
3697 
      x.read(self._iprot)
3698 
      self._iprot.readMessageEnd()
3699 
      raise x
2616 chandransh 3700 
    result = receiveReturn_result()
2591 chandransh 3701 
    result.read(self._iprot)
3702 
    self._iprot.readMessageEnd()
3431 rajveer 3703 
    if result.success is not None:
2591 chandransh 3704 
      return result.success
3431 rajveer 3705 
    if result.ex is not None:
2591 chandransh 3706 
      raise result.ex
2616 chandransh 3707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3708 
 
3709 
  def validateDoa(self, orderId, isValid):
3710 
    """
4452 rajveer 3711 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3712 
    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 3713 
    If the order is in any other state, it returns false.
3714 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3715 
 
2591 chandransh 3716 
    Parameters:
3717 
     - orderId
3718 
     - isValid
3719 
    """
3720 
    self.send_validateDoa(orderId, isValid)
3721 
    return self.recv_validateDoa()
3722 
 
3723 
  def send_validateDoa(self, orderId, isValid):
3724 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3725 
    args = validateDoa_args()
3726 
    args.orderId = orderId
3727 
    args.isValid = isValid
3728 
    args.write(self._oprot)
3729 
    self._oprot.writeMessageEnd()
3730 
    self._oprot.trans.flush()
3731 
 
3732 
  def recv_validateDoa(self, ):
3733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3734 
    if mtype == TMessageType.EXCEPTION:
3735 
      x = TApplicationException()
3736 
      x.read(self._iprot)
3737 
      self._iprot.readMessageEnd()
3738 
      raise x
3739 
    result = validateDoa_result()
3740 
    result.read(self._iprot)
3741 
    self._iprot.readMessageEnd()
3431 rajveer 3742 
    if result.success is not None:
2591 chandransh 3743 
      return result.success
3431 rajveer 3744 
    if result.ex is not None:
2591 chandransh 3745 
      raise result.ex
3746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3747 
 
4495 rajveer 3748 
  def validateReturnProduct(self, orderId, isUsable):
3749 
    """
3750 
    Parameters:
3751 
     - orderId
3752 
     - isUsable
3753 
    """
3754 
    self.send_validateReturnProduct(orderId, isUsable)
3755 
    return self.recv_validateReturnProduct()
3756 
 
3757 
  def send_validateReturnProduct(self, orderId, isUsable):
3758 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3759 
    args = validateReturnProduct_args()
3760 
    args.orderId = orderId
3761 
    args.isUsable = isUsable
3762 
    args.write(self._oprot)
3763 
    self._oprot.writeMessageEnd()
3764 
    self._oprot.trans.flush()
3765 
 
3766 
  def recv_validateReturnProduct(self, ):
3767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3768 
    if mtype == TMessageType.EXCEPTION:
3769 
      x = TApplicationException()
3770 
      x.read(self._iprot)
3771 
      self._iprot.readMessageEnd()
3772 
      raise x
3773 
    result = validateReturnProduct_result()
3774 
    result.read(self._iprot)
3775 
    self._iprot.readMessageEnd()
3776 
    if result.success is not None:
3777 
      return result.success
3778 
    if result.ex is not None:
3779 
      raise result.ex
3780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3781 
 
2616 chandransh 3782 
  def reshipOrder(self, orderId):
3783 
    """
4484 rajveer 3784 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3785 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3786 
    	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 3787 
 
3788 
    If the order is in DOA_CERT_VALID state, it does the following:
3789 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3790 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3791 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3792 
 
2616 chandransh 3793 
    Returns the id of the newly created order.
3431 rajveer 3794 
 
2616 chandransh 3795 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3796 
 
2616 chandransh 3797 
    Parameters:
3798 
     - orderId
3799 
    """
3800 
    self.send_reshipOrder(orderId)
3801 
    return self.recv_reshipOrder()
2591 chandransh 3802 
 
2616 chandransh 3803 
  def send_reshipOrder(self, orderId):
3804 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3805 
    args = reshipOrder_args()
3806 
    args.orderId = orderId
3807 
    args.write(self._oprot)
3808 
    self._oprot.writeMessageEnd()
3809 
    self._oprot.trans.flush()
3810 
 
3811 
  def recv_reshipOrder(self, ):
3812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3813 
    if mtype == TMessageType.EXCEPTION:
3814 
      x = TApplicationException()
3815 
      x.read(self._iprot)
3816 
      self._iprot.readMessageEnd()
3817 
      raise x
3818 
    result = reshipOrder_result()
3819 
    result.read(self._iprot)
3820 
    self._iprot.readMessageEnd()
3431 rajveer 3821 
    if result.success is not None:
2616 chandransh 3822 
      return result.success
3431 rajveer 3823 
    if result.ex is not None:
2616 chandransh 3824 
      raise result.ex
3825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3826 
 
3226 chandransh 3827 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3828 
    """
4484 rajveer 3829 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3830 
    	1. Creates a refund request for batch processing.
3831 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3832 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3833 
 
2616 chandransh 3834 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3835 
    	1. Creates a refund request for batch processing.
3226 chandransh 3836 
    	2. Cancels the reservation of the item in the warehouse.
3837 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3838 
 
3226 chandransh 3839 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3840 
    	1. Cancels the reservation of the item in the warehouse.
3841 
    	2. Marks the current order as CANCELED.
3842 
 
3843 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3844 
 
2616 chandransh 3845 
    Returns True if it is successful, False otherwise.
3431 rajveer 3846 
 
2616 chandransh 3847 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3848 
 
2616 chandransh 3849 
    Parameters:
3850 
     - orderId
3226 chandransh 3851 
     - refundedBy
3852 
     - reason
2616 chandransh 3853 
    """
3226 chandransh 3854 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3855 
    return self.recv_refundOrder()
3856 
 
3226 chandransh 3857 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3858 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3859 
    args = refundOrder_args()
3860 
    args.orderId = orderId
3226 chandransh 3861 
    args.refundedBy = refundedBy
3862 
    args.reason = reason
2616 chandransh 3863 
    args.write(self._oprot)
3864 
    self._oprot.writeMessageEnd()
3865 
    self._oprot.trans.flush()
3866 
 
3867 
  def recv_refundOrder(self, ):
3868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3869 
    if mtype == TMessageType.EXCEPTION:
3870 
      x = TApplicationException()
3871 
      x.read(self._iprot)
3872 
      self._iprot.readMessageEnd()
3873 
      raise x
3874 
    result = refundOrder_result()
3875 
    result.read(self._iprot)
3876 
    self._iprot.readMessageEnd()
3431 rajveer 3877 
    if result.success is not None:
2616 chandransh 3878 
      return result.success
3431 rajveer 3879 
    if result.ex is not None:
2616 chandransh 3880 
      raise result.ex
3881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3882 
 
2690 chandransh 3883 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3884 
    """
3885 
    Get all return orders created between the from and to dates for the given warehouse.
3886 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3887 
 
2690 chandransh 3888 
    Parameters:
3889 
     - warehouseId
3890 
     - fromDate
3891 
     - toDate
3892 
    """
3893 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3894 
    return self.recv_getReturnOrders()
2616 chandransh 3895 
 
2690 chandransh 3896 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3897 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3898 
    args = getReturnOrders_args()
3899 
    args.warehouseId = warehouseId
3900 
    args.fromDate = fromDate
3901 
    args.toDate = toDate
3902 
    args.write(self._oprot)
3903 
    self._oprot.writeMessageEnd()
3904 
    self._oprot.trans.flush()
3905 
 
3906 
  def recv_getReturnOrders(self, ):
3907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3908 
    if mtype == TMessageType.EXCEPTION:
3909 
      x = TApplicationException()
3910 
      x.read(self._iprot)
3911 
      self._iprot.readMessageEnd()
3912 
      raise x
3913 
    result = getReturnOrders_result()
3914 
    result.read(self._iprot)
3915 
    self._iprot.readMessageEnd()
3431 rajveer 3916 
    if result.success is not None:
2690 chandransh 3917 
      return result.success
3918 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3919 
 
5481 phani.kuma 3920 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3921 
    """
3922 
    Get all return orders created between the from and to dates.
3923 
 
3924 
    Parameters:
3925 
     - onlyNotProcessed
3926 
     - fromDate
3927 
     - toDate
3928 
    """
3929 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3930 
    return self.recv_getAllReturnOrders()
3931 
 
3932 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3933 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3934 
    args = getAllReturnOrders_args()
3935 
    args.onlyNotProcessed = onlyNotProcessed
3936 
    args.fromDate = fromDate
3937 
    args.toDate = toDate
3938 
    args.write(self._oprot)
3939 
    self._oprot.writeMessageEnd()
3940 
    self._oprot.trans.flush()
3941 
 
3942 
  def recv_getAllReturnOrders(self, ):
3943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3944 
    if mtype == TMessageType.EXCEPTION:
3945 
      x = TApplicationException()
3946 
      x.read(self._iprot)
3947 
      self._iprot.readMessageEnd()
3948 
      raise x
3949 
    result = getAllReturnOrders_result()
3950 
    result.read(self._iprot)
3951 
    self._iprot.readMessageEnd()
3952 
    if result.success is not None:
3953 
      return result.success
3954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3955 
 
2700 chandransh 3956 
  def getReturnOrder(self, id):
3957 
    """
3958 
    Returns the ReturnOrder corresponding to the given id.
3959 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3960 
 
2700 chandransh 3961 
    Parameters:
3962 
     - id
3963 
    """
3964 
    self.send_getReturnOrder(id)
3965 
    return self.recv_getReturnOrder()
3966 
 
3967 
  def send_getReturnOrder(self, id):
3968 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3969 
    args = getReturnOrder_args()
3970 
    args.id = id
3971 
    args.write(self._oprot)
3972 
    self._oprot.writeMessageEnd()
3973 
    self._oprot.trans.flush()
3974 
 
3975 
  def recv_getReturnOrder(self, ):
3976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3977 
    if mtype == TMessageType.EXCEPTION:
3978 
      x = TApplicationException()
3979 
      x.read(self._iprot)
3980 
      self._iprot.readMessageEnd()
3981 
      raise x
3982 
    result = getReturnOrder_result()
3983 
    result.read(self._iprot)
3984 
    self._iprot.readMessageEnd()
3431 rajveer 3985 
    if result.success is not None:
2700 chandransh 3986 
      return result.success
3431 rajveer 3987 
    if result.ex is not None:
2700 chandransh 3988 
      raise result.ex
3989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3990 
 
2690 chandransh 3991 
  def processReturn(self, returnOrderId):
3992 
    """
3993 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3994 
 
2690 chandransh 3995 
    Parameters:
3996 
     - returnOrderId
3997 
    """
3998 
    self.send_processReturn(returnOrderId)
3999 
    self.recv_processReturn()
4000 
 
4001 
  def send_processReturn(self, returnOrderId):
4002 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4003 
    args = processReturn_args()
4004 
    args.returnOrderId = returnOrderId
4005 
    args.write(self._oprot)
4006 
    self._oprot.writeMessageEnd()
4007 
    self._oprot.trans.flush()
4008 
 
4009 
  def recv_processReturn(self, ):
4010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4011 
    if mtype == TMessageType.EXCEPTION:
4012 
      x = TApplicationException()
4013 
      x.read(self._iprot)
4014 
      self._iprot.readMessageEnd()
4015 
      raise x
4016 
    result = processReturn_result()
4017 
    result.read(self._iprot)
4018 
    self._iprot.readMessageEnd()
3431 rajveer 4019 
    if result.ex is not None:
2690 chandransh 4020 
      raise result.ex
4021 
    return
4022 
 
3451 chandransh 4023 
  def updateWeight(self, orderId, weight):
4024 
    """
4025 
    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 4026 
 
3451 chandransh 4027 
    Parameters:
4028 
     - orderId
4029 
     - weight
4030 
    """
4031 
    self.send_updateWeight(orderId, weight)
4032 
    return self.recv_updateWeight()
4033 
 
4034 
  def send_updateWeight(self, orderId, weight):
4035 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4036 
    args = updateWeight_args()
4037 
    args.orderId = orderId
4038 
    args.weight = weight
4039 
    args.write(self._oprot)
4040 
    self._oprot.writeMessageEnd()
4041 
    self._oprot.trans.flush()
4042 
 
4043 
  def recv_updateWeight(self, ):
4044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4045 
    if mtype == TMessageType.EXCEPTION:
4046 
      x = TApplicationException()
4047 
      x.read(self._iprot)
4048 
      self._iprot.readMessageEnd()
4049 
      raise x
4050 
    result = updateWeight_result()
4051 
    result.read(self._iprot)
4052 
    self._iprot.readMessageEnd()
4053 
    if result.success is not None:
4054 
      return result.success
4055 
    if result.ex is not None:
4056 
      raise result.ex
4057 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4058 
 
3469 chandransh 4059 
  def changeItem(self, orderId, itemId):
4060 
    """
4061 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4062 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4063 
 
3469 chandransh 4064 
    Parameters:
4065 
     - orderId
4066 
     - itemId
4067 
    """
4068 
    self.send_changeItem(orderId, itemId)
4069 
    return self.recv_changeItem()
4070 
 
4071 
  def send_changeItem(self, orderId, itemId):
4072 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4073 
    args = changeItem_args()
4074 
    args.orderId = orderId
4075 
    args.itemId = itemId
4076 
    args.write(self._oprot)
4077 
    self._oprot.writeMessageEnd()
4078 
    self._oprot.trans.flush()
4079 
 
4080 
  def recv_changeItem(self, ):
4081 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4082 
    if mtype == TMessageType.EXCEPTION:
4083 
      x = TApplicationException()
4084 
      x.read(self._iprot)
4085 
      self._iprot.readMessageEnd()
4086 
      raise x
4087 
    result = changeItem_result()
4088 
    result.read(self._iprot)
4089 
    self._iprot.readMessageEnd()
4090 
    if result.success is not None:
4091 
      return result.success
4092 
    if result.ex is not None:
4093 
      raise result.ex
4094 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4095 
 
4096 
  def shiftToWarehouse(self, orderId, warehouseId):
4097 
    """
4098 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4099 
 
4100 
    Parameters:
4101 
     - orderId
4102 
     - warehouseId
4103 
    """
4104 
    self.send_shiftToWarehouse(orderId, warehouseId)
4105 
    return self.recv_shiftToWarehouse()
4106 
 
4107 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4108 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4109 
    args = shiftToWarehouse_args()
4110 
    args.orderId = orderId
4111 
    args.warehouseId = warehouseId
4112 
    args.write(self._oprot)
4113 
    self._oprot.writeMessageEnd()
4114 
    self._oprot.trans.flush()
4115 
 
4116 
  def recv_shiftToWarehouse(self, ):
4117 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4118 
    if mtype == TMessageType.EXCEPTION:
4119 
      x = TApplicationException()
4120 
      x.read(self._iprot)
4121 
      self._iprot.readMessageEnd()
4122 
      raise x
4123 
    result = shiftToWarehouse_result()
4124 
    result.read(self._iprot)
4125 
    self._iprot.readMessageEnd()
4126 
    if result.success is not None:
4127 
      return result.success
4128 
    if result.ex is not None:
4129 
      raise result.ex
4130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4131 
 
4647 rajveer 4132 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4133 
    """
4134 
    Adds the given delay reason to the given order.
3986 chandransh 4135 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4136 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4137 
 
3553 chandransh 4138 
    Parameters:
4139 
     - orderId
4140 
     - delayReason
3986 chandransh 4141 
     - furtherDelay
4647 rajveer 4142 
     - delayReasonText
3553 chandransh 4143 
    """
4647 rajveer 4144 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4145 
    return self.recv_addDelayReason()
4146 
 
4647 rajveer 4147 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4148 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4149 
    args = addDelayReason_args()
4150 
    args.orderId = orderId
4151 
    args.delayReason = delayReason
3986 chandransh 4152 
    args.furtherDelay = furtherDelay
4647 rajveer 4153 
    args.delayReasonText = delayReasonText
3553 chandransh 4154 
    args.write(self._oprot)
4155 
    self._oprot.writeMessageEnd()
4156 
    self._oprot.trans.flush()
4157 
 
4158 
  def recv_addDelayReason(self, ):
4159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4160 
    if mtype == TMessageType.EXCEPTION:
4161 
      x = TApplicationException()
4162 
      x.read(self._iprot)
4163 
      self._iprot.readMessageEnd()
4164 
      raise x
4165 
    result = addDelayReason_result()
4166 
    result.read(self._iprot)
4167 
    self._iprot.readMessageEnd()
4168 
    if result.success is not None:
4169 
      return result.success
4170 
    if result.ex is not None:
4171 
      raise result.ex
4172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4173 
 
3956 chandransh 4174 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4175 
    """
4176 
    Marks the COD orders with given AWB nos. as having been processed.
4177 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4178 
 
3956 chandransh 4179 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4180 
    1. There is no order corresponding to an AWB number.
4181 
    2. The captured amount for a payment exceeds the total payment.
4182 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4183 
 
4184 
    Parameters:
4185 
     - collectedAmountMap
4186 
     - xferBy
4187 
     - xferTxnId
4188 
     - xferDate
4189 
    """
4190 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4191 
    return self.recv_reconcileCodCollection()
4192 
 
4193 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4194 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4195 
    args = reconcileCodCollection_args()
4196 
    args.collectedAmountMap = collectedAmountMap
4197 
    args.xferBy = xferBy
4198 
    args.xferTxnId = xferTxnId
4199 
    args.xferDate = xferDate
4200 
    args.write(self._oprot)
4201 
    self._oprot.writeMessageEnd()
4202 
    self._oprot.trans.flush()
4203 
 
4204 
  def recv_reconcileCodCollection(self, ):
4205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4206 
    if mtype == TMessageType.EXCEPTION:
4207 
      x = TApplicationException()
4208 
      x.read(self._iprot)
4209 
      self._iprot.readMessageEnd()
4210 
      raise x
4211 
    result = reconcileCodCollection_result()
4212 
    result.read(self._iprot)
4213 
    self._iprot.readMessageEnd()
4214 
    if result.success is not None:
4215 
      return result.success
4216 
    if result.ex is not None:
4217 
      raise result.ex
4218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4219 
 
4008 mandeep.dh 4220 
  def getTransactionsRequiringExtraProcessing(self, category):
4221 
    """
4065 mandeep.dh 4222 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4223 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4224 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4225 
 
4008 mandeep.dh 4226 
    Parameters:
4227 
     - category
4228 
    """
4229 
    self.send_getTransactionsRequiringExtraProcessing(category)
4230 
    return self.recv_getTransactionsRequiringExtraProcessing()
4231 
 
4232 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4233 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4234 
    args = getTransactionsRequiringExtraProcessing_args()
4235 
    args.category = category
4236 
    args.write(self._oprot)
4237 
    self._oprot.writeMessageEnd()
4238 
    self._oprot.trans.flush()
4239 
 
4240 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4242 
    if mtype == TMessageType.EXCEPTION:
4243 
      x = TApplicationException()
4244 
      x.read(self._iprot)
4245 
      self._iprot.readMessageEnd()
4246 
      raise x
4247 
    result = getTransactionsRequiringExtraProcessing_result()
4248 
    result.read(self._iprot)
4249 
    self._iprot.readMessageEnd()
4250 
    if result.success is not None:
4251 
      return result.success
4252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4253 
 
4254 
  def markTransactionAsProcessed(self, transactionId, category):
4255 
    """
4256 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4257 
    It essentially deletes the transaction id record for a particular
4258 
    processing type category (if present) from DB.
4259 
    This is currently used by CRM application.
4008 mandeep.dh 4260 
 
4261 
    Parameters:
4262 
     - transactionId
4263 
     - category
4264 
    """
4265 
    self.send_markTransactionAsProcessed(transactionId, category)
4266 
    self.recv_markTransactionAsProcessed()
4267 
 
4268 
  def send_markTransactionAsProcessed(self, transactionId, category):
4269 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4270 
    args = markTransactionAsProcessed_args()
4271 
    args.transactionId = transactionId
4272 
    args.category = category
4273 
    args.write(self._oprot)
4274 
    self._oprot.writeMessageEnd()
4275 
    self._oprot.trans.flush()
4276 
 
4277 
  def recv_markTransactionAsProcessed(self, ):
4278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4279 
    if mtype == TMessageType.EXCEPTION:
4280 
      x = TApplicationException()
4281 
      x.read(self._iprot)
4282 
      self._iprot.readMessageEnd()
4283 
      raise x
4284 
    result = markTransactionAsProcessed_result()
4285 
    result.read(self._iprot)
4286 
    self._iprot.readMessageEnd()
4287 
    return
4288 
 
4018 chandransh 4289 
  def getItemWiseRiskyOrdersCount(self, ):
4290 
    """
4291 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4292 
    is defined as one whose shipping date is about to expire.
4293 
    """
4294 
    self.send_getItemWiseRiskyOrdersCount()
4295 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4296 
 
4018 chandransh 4297 
  def send_getItemWiseRiskyOrdersCount(self, ):
4298 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4299 
    args = getItemWiseRiskyOrdersCount_args()
4300 
    args.write(self._oprot)
4301 
    self._oprot.writeMessageEnd()
4302 
    self._oprot.trans.flush()
4303 
 
4304 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4306 
    if mtype == TMessageType.EXCEPTION:
4307 
      x = TApplicationException()
4308 
      x.read(self._iprot)
4309 
      self._iprot.readMessageEnd()
4310 
      raise x
4311 
    result = getItemWiseRiskyOrdersCount_result()
4312 
    result.read(self._iprot)
4313 
    self._iprot.readMessageEnd()
4314 
    if result.success is not None:
4315 
      return result.success
4316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4317 
 
4295 varun.gupt 4318 
  def getOrdersForItemIds(self, itemIds):
4319 
    """
4320 
    Returns a list of all orders which have items with given id
4321 
 
4322 
    Parameters:
4323 
     - itemIds
4324 
    """
4325 
    self.send_getOrdersForItemIds(itemIds)
4326 
    return self.recv_getOrdersForItemIds()
4327 
 
4328 
  def send_getOrdersForItemIds(self, itemIds):
4329 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4330 
    args = getOrdersForItemIds_args()
4331 
    args.itemIds = itemIds
4332 
    args.write(self._oprot)
4333 
    self._oprot.writeMessageEnd()
4334 
    self._oprot.trans.flush()
4335 
 
4336 
  def recv_getOrdersForItemIds(self, ):
4337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4338 
    if mtype == TMessageType.EXCEPTION:
4339 
      x = TApplicationException()
4340 
      x.read(self._iprot)
4341 
      self._iprot.readMessageEnd()
4342 
      raise x
4343 
    result = getOrdersForItemIds_result()
4344 
    result.read(self._iprot)
4345 
    self._iprot.readMessageEnd()
4346 
    if result.success is not None:
4347 
      return result.success
4348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4349 
 
4247 rajveer 4350 
  def markOrderCancellationRequestReceived(self, orderId):
4351 
    """
4352 
    Mark order as cancellation request received. If customer sends request of cancellation of
4353 
    a particular order, this method will be called. It will just change status of the order
4354 
    depending on its current status. It also records the previous status, so that we can move
4355 
    back to that status if cancellation request is denied.
4018 chandransh 4356 
 
4247 rajveer 4357 
    Parameters:
4358 
     - orderId
4359 
    """
4360 
    self.send_markOrderCancellationRequestReceived(orderId)
4361 
    self.recv_markOrderCancellationRequestReceived()
4362 
 
4363 
  def send_markOrderCancellationRequestReceived(self, orderId):
4364 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4365 
    args = markOrderCancellationRequestReceived_args()
4366 
    args.orderId = orderId
4367 
    args.write(self._oprot)
4368 
    self._oprot.writeMessageEnd()
4369 
    self._oprot.trans.flush()
4370 
 
4371 
  def recv_markOrderCancellationRequestReceived(self, ):
4372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4373 
    if mtype == TMessageType.EXCEPTION:
4374 
      x = TApplicationException()
4375 
      x.read(self._iprot)
4376 
      self._iprot.readMessageEnd()
4377 
      raise x
4378 
    result = markOrderCancellationRequestReceived_result()
4379 
    result.read(self._iprot)
4380 
    self._iprot.readMessageEnd()
4381 
    if result.ex is not None:
4382 
      raise result.ex
4383 
    return
4384 
 
4385 
  def markOrderCancellationRequestConfirmed(self, orderId):
4386 
    """
4387 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4388 
    cancellation request confirmed. After this OM will be able to cancel the order.
4389 
 
4390 
    Parameters:
4391 
     - orderId
4392 
    """
4393 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4394 
    self.recv_markOrderCancellationRequestConfirmed()
4395 
 
4396 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4397 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4398 
    args = markOrderCancellationRequestConfirmed_args()
4399 
    args.orderId = orderId
4400 
    args.write(self._oprot)
4401 
    self._oprot.writeMessageEnd()
4402 
    self._oprot.trans.flush()
4403 
 
4404 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4406 
    if mtype == TMessageType.EXCEPTION:
4407 
      x = TApplicationException()
4408 
      x.read(self._iprot)
4409 
      self._iprot.readMessageEnd()
4410 
      raise x
4411 
    result = markOrderCancellationRequestConfirmed_result()
4412 
    result.read(self._iprot)
4413 
    self._iprot.readMessageEnd()
4414 
    if result.ex is not None:
4415 
      raise result.ex
4416 
    return
4417 
 
4418 
  def markOrderCancellationRequestDenied(self, orderId):
4419 
    """
4420 
    If we decide to not to cancel order, we will move the order ro previous status.
4421 
 
4422 
    Parameters:
4423 
     - orderId
4424 
    """
4425 
    self.send_markOrderCancellationRequestDenied(orderId)
4426 
    self.recv_markOrderCancellationRequestDenied()
4427 
 
4428 
  def send_markOrderCancellationRequestDenied(self, orderId):
4429 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4430 
    args = markOrderCancellationRequestDenied_args()
4431 
    args.orderId = orderId
4432 
    args.write(self._oprot)
4433 
    self._oprot.writeMessageEnd()
4434 
    self._oprot.trans.flush()
4435 
 
4436 
  def recv_markOrderCancellationRequestDenied(self, ):
4437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4438 
    if mtype == TMessageType.EXCEPTION:
4439 
      x = TApplicationException()
4440 
      x.read(self._iprot)
4441 
      self._iprot.readMessageEnd()
4442 
      raise x
4443 
    result = markOrderCancellationRequestDenied_result()
4444 
    result.read(self._iprot)
4445 
    self._iprot.readMessageEnd()
4446 
    if result.ex is not None:
4447 
      raise result.ex
4448 
    return
4449 
 
4258 rajveer 4450 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4451 
    """
4258 rajveer 4452 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4453 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4454 
 
4455 
    Parameters:
4258 rajveer 4456 
     - transactionId
4247 rajveer 4457 
    """
4258 rajveer 4458 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4459 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4460 
 
4258 rajveer 4461 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4462 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4463 
    args = markTransactionAsPaymentFlagRemoved_args()
4464 
    args.transactionId = transactionId
4247 rajveer 4465 
    args.write(self._oprot)
4466 
    self._oprot.writeMessageEnd()
4467 
    self._oprot.trans.flush()
4468 
 
4258 rajveer 4469 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4471 
    if mtype == TMessageType.EXCEPTION:
4472 
      x = TApplicationException()
4473 
      x.read(self._iprot)
4474 
      self._iprot.readMessageEnd()
4475 
      raise x
4258 rajveer 4476 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4477 
    result.read(self._iprot)
4478 
    self._iprot.readMessageEnd()
4479 
    if result.ex is not None:
4480 
      raise result.ex
4481 
    return
4482 
 
4259 anupam.sin 4483 
  def refundTransaction(self, transactionId, refundedBy, reason):
4484 
    """
4485 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4486 
    need to be cancelled
4247 rajveer 4487 
 
4259 anupam.sin 4488 
    Parameters:
4489 
     - transactionId
4490 
     - refundedBy
4491 
     - reason
4492 
    """
4493 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4494 
    self.recv_refundTransaction()
4495 
 
4496 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4497 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4498 
    args = refundTransaction_args()
4499 
    args.transactionId = transactionId
4500 
    args.refundedBy = refundedBy
4501 
    args.reason = reason
4502 
    args.write(self._oprot)
4503 
    self._oprot.writeMessageEnd()
4504 
    self._oprot.trans.flush()
4505 
 
4506 
  def recv_refundTransaction(self, ):
4507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4508 
    if mtype == TMessageType.EXCEPTION:
4509 
      x = TApplicationException()
4510 
      x.read(self._iprot)
4511 
      self._iprot.readMessageEnd()
4512 
      raise x
4513 
    result = refundTransaction_result()
4514 
    result.read(self._iprot)
4515 
    self._iprot.readMessageEnd()
4516 
    if result.ex is not None:
4517 
      raise result.ex
4518 
    return
4519 
 
4324 mandeep.dh 4520 
  def updateShipmentAddress(self, orderId, addressId):
4521 
    """
4522 
    Updates shipment address of an order. Delivery and shipping date estimates
4523 
    etc. are also updated here.
4524 
 
4525 
    Throws TransactionServiceException in case address change is not
4526 
    possible due to certain reasons such as new pincode in address is
4527 
    not serviceable etc.
4528 
 
4529 
    Parameters:
4530 
     - orderId
4531 
     - addressId
4532 
    """
4533 
    self.send_updateShipmentAddress(orderId, addressId)
4534 
    self.recv_updateShipmentAddress()
4535 
 
4536 
  def send_updateShipmentAddress(self, orderId, addressId):
4537 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4538 
    args = updateShipmentAddress_args()
4539 
    args.orderId = orderId
4540 
    args.addressId = addressId
4541 
    args.write(self._oprot)
4542 
    self._oprot.writeMessageEnd()
4543 
    self._oprot.trans.flush()
4544 
 
4545 
  def recv_updateShipmentAddress(self, ):
4546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4547 
    if mtype == TMessageType.EXCEPTION:
4548 
      x = TApplicationException()
4549 
      x.read(self._iprot)
4550 
      self._iprot.readMessageEnd()
4551 
      raise x
4552 
    result = updateShipmentAddress_result()
4553 
    result.read(self._iprot)
4554 
    self._iprot.readMessageEnd()
4555 
    if result.ex is not None:
4556 
      raise result.ex
4557 
    return
4558 
 
4285 rajveer 4559 
  def acceptOrdersForItemId(self, itemId, inventory):
4560 
    """
4561 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4562 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4563 
 
4285 rajveer 4564 
    Parameters:
4565 
     - itemId
4566 
     - inventory
4567 
    """
4568 
    self.send_acceptOrdersForItemId(itemId, inventory)
4569 
    return self.recv_acceptOrdersForItemId()
4570 
 
4571 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4572 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4573 
    args = acceptOrdersForItemId_args()
4574 
    args.itemId = itemId
4575 
    args.inventory = inventory
4576 
    args.write(self._oprot)
4577 
    self._oprot.writeMessageEnd()
4578 
    self._oprot.trans.flush()
4579 
 
4580 
  def recv_acceptOrdersForItemId(self, ):
4581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4582 
    if mtype == TMessageType.EXCEPTION:
4583 
      x = TApplicationException()
4584 
      x.read(self._iprot)
4585 
      self._iprot.readMessageEnd()
4586 
      raise x
4587 
    result = acceptOrdersForItemId_result()
4588 
    result.read(self._iprot)
4589 
    self._iprot.readMessageEnd()
4590 
    if result.success is not None:
4591 
      return result.success
4592 
    if result.ex is not None:
4593 
      raise result.ex
4594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4595 
 
4369 rajveer 4596 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4597 
    """
4598 
    Parameters:
4599 
     - vendorId
4600 
     - itemId
4601 
     - quantity
4602 
     - estimate
4369 rajveer 4603 
     - isReminder
4303 rajveer 4604 
    """
4369 rajveer 4605 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4606 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4607 
 
4369 rajveer 4608 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4609 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4610 
    args = markOrdersAsPORaised_args()
4611 
    args.vendorId = vendorId
4612 
    args.itemId = itemId
4613 
    args.quantity = quantity
4614 
    args.estimate = estimate
4369 rajveer 4615 
    args.isReminder = isReminder
4303 rajveer 4616 
    args.write(self._oprot)
4617 
    self._oprot.writeMessageEnd()
4618 
    self._oprot.trans.flush()
4619 
 
4620 
  def recv_markOrdersAsPORaised(self, ):
4621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4622 
    if mtype == TMessageType.EXCEPTION:
4623 
      x = TApplicationException()
4624 
      x.read(self._iprot)
4625 
      self._iprot.readMessageEnd()
4626 
      raise x
4627 
    result = markOrdersAsPORaised_result()
4628 
    result.read(self._iprot)
4629 
    self._iprot.readMessageEnd()
4630 
    if result.ex is not None:
4631 
      raise result.ex
4632 
    return
4633 
 
4369 rajveer 4634 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4635 
    """
4636 
    Parameters:
4637 
     - vendorId
4638 
     - itemId
4639 
     - quantity
4640 
     - estimate
4369 rajveer 4641 
     - isReminder
4303 rajveer 4642 
    """
4369 rajveer 4643 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4644 
    self.recv_markOrdersAsReversalInitiated()
4645 
 
4369 rajveer 4646 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4647 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4648 
    args = markOrdersAsReversalInitiated_args()
4649 
    args.vendorId = vendorId
4650 
    args.itemId = itemId
4651 
    args.quantity = quantity
4652 
    args.estimate = estimate
4369 rajveer 4653 
    args.isReminder = isReminder
4303 rajveer 4654 
    args.write(self._oprot)
4655 
    self._oprot.writeMessageEnd()
4656 
    self._oprot.trans.flush()
4657 
 
4658 
  def recv_markOrdersAsReversalInitiated(self, ):
4659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4660 
    if mtype == TMessageType.EXCEPTION:
4661 
      x = TApplicationException()
4662 
      x.read(self._iprot)
4663 
      self._iprot.readMessageEnd()
4664 
      raise x
4665 
    result = markOrdersAsReversalInitiated_result()
4666 
    result.read(self._iprot)
4667 
    self._iprot.readMessageEnd()
4668 
    if result.ex is not None:
4669 
      raise result.ex
4670 
    return
4671 
 
4369 rajveer 4672 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4673 
    """
4674 
    Parameters:
4675 
     - vendorId
4676 
     - itemId
4677 
     - quantity
4678 
     - estimate
4369 rajveer 4679 
     - isReminder
4303 rajveer 4680 
    """
4369 rajveer 4681 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4682 
    self.recv_markOrdersAsNotAvailabke()
4683 
 
4369 rajveer 4684 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4685 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4686 
    args = markOrdersAsNotAvailabke_args()
4687 
    args.vendorId = vendorId
4688 
    args.itemId = itemId
4689 
    args.quantity = quantity
4690 
    args.estimate = estimate
4369 rajveer 4691 
    args.isReminder = isReminder
4303 rajveer 4692 
    args.write(self._oprot)
4693 
    self._oprot.writeMessageEnd()
4694 
    self._oprot.trans.flush()
4695 
 
4696 
  def recv_markOrdersAsNotAvailabke(self, ):
4697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4698 
    if mtype == TMessageType.EXCEPTION:
4699 
      x = TApplicationException()
4700 
      x.read(self._iprot)
4701 
      self._iprot.readMessageEnd()
4702 
      raise x
4703 
    result = markOrdersAsNotAvailabke_result()
4704 
    result.read(self._iprot)
4705 
    self._iprot.readMessageEnd()
4706 
    if result.ex is not None:
4707 
      raise result.ex
4708 
    return
4709 
 
4369 rajveer 4710 
  def markOrdersAsTimeout(self, vendorId):
4711 
    """
4712 
    Parameters:
4713 
     - vendorId
4714 
    """
4715 
    self.send_markOrdersAsTimeout(vendorId)
4716 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4717 
 
4369 rajveer 4718 
  def send_markOrdersAsTimeout(self, vendorId):
4719 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4720 
    args = markOrdersAsTimeout_args()
4721 
    args.vendorId = vendorId
4722 
    args.write(self._oprot)
4723 
    self._oprot.writeMessageEnd()
4724 
    self._oprot.trans.flush()
4725 
 
4726 
  def recv_markOrdersAsTimeout(self, ):
4727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4728 
    if mtype == TMessageType.EXCEPTION:
4729 
      x = TApplicationException()
4730 
      x.read(self._iprot)
4731 
      self._iprot.readMessageEnd()
4732 
      raise x
4733 
    result = markOrdersAsTimeout_result()
4734 
    result.read(self._iprot)
4735 
    self._iprot.readMessageEnd()
4736 
    if result.success is not None:
4737 
      return result.success
4738 
    if result.ex is not None:
4739 
      raise result.ex
4740 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4741 
 
4662 rajveer 4742 
  def markOrderAsLostInTransit(self, orderId):
4743 
    """
4744 
    Mark order as LOST_IN_TRANSIT
4745 
 
4746 
    Parameters:
4747 
     - orderId
4748 
    """
4749 
    self.send_markOrderAsLostInTransit(orderId)
4750 
    return self.recv_markOrderAsLostInTransit()
4751 
 
4752 
  def send_markOrderAsLostInTransit(self, orderId):
4753 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4754 
    args = markOrderAsLostInTransit_args()
4755 
    args.orderId = orderId
4756 
    args.write(self._oprot)
4757 
    self._oprot.writeMessageEnd()
4758 
    self._oprot.trans.flush()
4759 
 
4760 
  def recv_markOrderAsLostInTransit(self, ):
4761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4762 
    if mtype == TMessageType.EXCEPTION:
4763 
      x = TApplicationException()
4764 
      x.read(self._iprot)
4765 
      self._iprot.readMessageEnd()
4766 
      raise x
4767 
    result = markOrderAsLostInTransit_result()
4768 
    result.read(self._iprot)
4769 
    self._iprot.readMessageEnd()
4770 
    if result.success is not None:
4771 
      return result.success
4772 
    if result.ex is not None:
4773 
      raise result.ex
4774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4775 
 
4386 anupam.sin 4776 
  def getOrderForAwb(self, awb):
4777 
    """
4778 
    Returns the order corresponding to an AWB number
4369 rajveer 4779 
 
4386 anupam.sin 4780 
    Parameters:
4781 
     - awb
4782 
    """
4783 
    self.send_getOrderForAwb(awb)
4784 
    return self.recv_getOrderForAwb()
4785 
 
4786 
  def send_getOrderForAwb(self, awb):
4787 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4788 
    args = getOrderForAwb_args()
4789 
    args.awb = awb
4790 
    args.write(self._oprot)
4791 
    self._oprot.writeMessageEnd()
4792 
    self._oprot.trans.flush()
4793 
 
4794 
  def recv_getOrderForAwb(self, ):
4795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4796 
    if mtype == TMessageType.EXCEPTION:
4797 
      x = TApplicationException()
4798 
      x.read(self._iprot)
4799 
      self._iprot.readMessageEnd()
4800 
      raise x
4801 
    result = getOrderForAwb_result()
4802 
    result.read(self._iprot)
4803 
    self._iprot.readMessageEnd()
4804 
    if result.success is not None:
4805 
      return result.success
4806 
    if result.ex is not None:
4807 
      raise result.ex
4808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4809 
 
4910 phani.kuma 4810 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4811 
    """
4910 phani.kuma 4812 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4813 
 
4506 phani.kuma 4814 
    Parameters:
4815 
     - logistics_provider_id
4910 phani.kuma 4816 
     - order_status_list
4506 phani.kuma 4817 
    """
4910 phani.kuma 4818 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4819 
    return self.recv_getOrdersForProviderForStatus()
4820 
 
4910 phani.kuma 4821 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4822 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4823 
    args = getOrdersForProviderForStatus_args()
4824 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4825 
    args.order_status_list = order_status_list
4506 phani.kuma 4826 
    args.write(self._oprot)
4827 
    self._oprot.writeMessageEnd()
4828 
    self._oprot.trans.flush()
4829 
 
4830 
  def recv_getOrdersForProviderForStatus(self, ):
4831 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4832 
    if mtype == TMessageType.EXCEPTION:
4833 
      x = TApplicationException()
4834 
      x.read(self._iprot)
4835 
      self._iprot.readMessageEnd()
4836 
      raise x
4837 
    result = getOrdersForProviderForStatus_result()
4838 
    result.read(self._iprot)
4839 
    self._iprot.readMessageEnd()
4840 
    if result.success is not None:
4841 
      return result.success
4842 
    if result.ex is not None:
4843 
      raise result.ex
4844 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4845 
 
4600 varun.gupt 4846 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4847 
    """
4848 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4849 
 
4600 varun.gupt 4850 
    Parameters:
4851 
     - vendorId
4852 
     - billingDateFrom
4853 
     - billingDateTo
4854 
    """
4855 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4856 
    return self.recv_getBilledOrdersForVendor()
4857 
 
4858 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4859 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4860 
    args = getBilledOrdersForVendor_args()
4861 
    args.vendorId = vendorId
4862 
    args.billingDateFrom = billingDateFrom
4863 
    args.billingDateTo = billingDateTo
4864 
    args.write(self._oprot)
4865 
    self._oprot.writeMessageEnd()
4866 
    self._oprot.trans.flush()
4867 
 
4868 
  def recv_getBilledOrdersForVendor(self, ):
4869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4870 
    if mtype == TMessageType.EXCEPTION:
4871 
      x = TApplicationException()
4872 
      x.read(self._iprot)
4873 
      self._iprot.readMessageEnd()
4874 
      raise x
4875 
    result = getBilledOrdersForVendor_result()
4876 
    result.read(self._iprot)
4877 
    self._iprot.readMessageEnd()
4878 
    if result.success is not None:
4879 
      return result.success
4880 
    if result.ex is not None:
4881 
      raise result.ex
4882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4883 
 
4607 rajveer 4884 
  def getSlippedSippingDateOrders(self, ):
4885 
    self.send_getSlippedSippingDateOrders()
4886 
    return self.recv_getSlippedSippingDateOrders()
4887 
 
4888 
  def send_getSlippedSippingDateOrders(self, ):
4889 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4890 
    args = getSlippedSippingDateOrders_args()
4891 
    args.write(self._oprot)
4892 
    self._oprot.writeMessageEnd()
4893 
    self._oprot.trans.flush()
4894 
 
4895 
  def recv_getSlippedSippingDateOrders(self, ):
4896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4897 
    if mtype == TMessageType.EXCEPTION:
4898 
      x = TApplicationException()
4899 
      x.read(self._iprot)
4900 
      self._iprot.readMessageEnd()
4901 
      raise x
4902 
    result = getSlippedSippingDateOrders_result()
4903 
    result.read(self._iprot)
4904 
    self._iprot.readMessageEnd()
4905 
    if result.success is not None:
4906 
      return result.success
4907 
    if result.ex is not None:
4908 
      raise result.ex
4909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4910 
 
4709 rajveer 4911 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4912 
    """
4913 
    Parameters:
4914 
     - cancelDateFrom
4915 
     - cancelDateTo
4916 
    """
4917 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4918 
    return self.recv_getCancelledOrders()
4919 
 
4920 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4921 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4922 
    args = getCancelledOrders_args()
4923 
    args.cancelDateFrom = cancelDateFrom
4924 
    args.cancelDateTo = cancelDateTo
4925 
    args.write(self._oprot)
4926 
    self._oprot.writeMessageEnd()
4927 
    self._oprot.trans.flush()
4928 
 
4929 
  def recv_getCancelledOrders(self, ):
4930 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4931 
    if mtype == TMessageType.EXCEPTION:
4932 
      x = TApplicationException()
4933 
      x.read(self._iprot)
4934 
      self._iprot.readMessageEnd()
4935 
      raise x
4936 
    result = getCancelledOrders_result()
4937 
    result.read(self._iprot)
4938 
    self._iprot.readMessageEnd()
4939 
    if result.success is not None:
4940 
      return result.success
4941 
    if result.ex is not None:
4942 
      raise result.ex
4943 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4944 
 
4600 varun.gupt 4945 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4946 
    """
4947 
    Parameters:
4948 
     - mapAWBAndAmount
4949 
    """
4950 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4951 
    self.recv_saveBluedartSettlements()
4952 
 
4953 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4954 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4955 
    args = saveBluedartSettlements_args()
4956 
    args.mapAWBAndAmount = mapAWBAndAmount
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_saveBluedartSettlements(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = saveBluedartSettlements_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.ex is not None:
4972 
      raise result.ex
4973 
    return
4974 
 
4905 varun.gupt 4975 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4976 
    """
4977 
    Parameters:
4978 
     - settlementDate
4979 
     - paymentGatewayId
4905 varun.gupt 4980 
     - referenceId
4600 varun.gupt 4981 
     - serviceTax
4982 
     - otherCharges
4983 
     - netCollection
4984 
    """
4905 varun.gupt 4985 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4986 
    self.recv_savePaymentSettlements()
4987 
 
4905 varun.gupt 4988 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4989 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4990 
    args = savePaymentSettlements_args()
4991 
    args.settlementDate = settlementDate
4992 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4993 
    args.referenceId = referenceId
4600 varun.gupt 4994 
    args.serviceTax = serviceTax
4995 
    args.otherCharges = otherCharges
4996 
    args.netCollection = netCollection
4997 
    args.write(self._oprot)
4998 
    self._oprot.writeMessageEnd()
4999 
    self._oprot.trans.flush()
5000 
 
5001 
  def recv_savePaymentSettlements(self, ):
5002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5003 
    if mtype == TMessageType.EXCEPTION:
5004 
      x = TApplicationException()
5005 
      x.read(self._iprot)
5006 
      self._iprot.readMessageEnd()
5007 
      raise x
5008 
    result = savePaymentSettlements_result()
5009 
    result.read(self._iprot)
5010 
    self._iprot.readMessageEnd()
5011 
    if result.ex is not None:
5012 
      raise result.ex
5013 
    return
5014 
 
5015 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5016 
    """
5017 
    Parameters:
5018 
     - settlementId
5019 
     - settlementDate
5020 
     - transactionDateFrom
5021 
     - transactionDateTo
5022 
     - amount
5023 
    """
5024 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5025 
    self.recv_saveEBSSettlementSummary()
5026 
 
5027 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5028 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5029 
    args = saveEBSSettlementSummary_args()
5030 
    args.settlementId = settlementId
5031 
    args.settlementDate = settlementDate
5032 
    args.transactionDateFrom = transactionDateFrom
5033 
    args.transactionDateTo = transactionDateTo
5034 
    args.amount = amount
5035 
    args.write(self._oprot)
5036 
    self._oprot.writeMessageEnd()
5037 
    self._oprot.trans.flush()
5038 
 
5039 
  def recv_saveEBSSettlementSummary(self, ):
5040 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5041 
    if mtype == TMessageType.EXCEPTION:
5042 
      x = TApplicationException()
5043 
      x.read(self._iprot)
5044 
      self._iprot.readMessageEnd()
5045 
      raise x
5046 
    result = saveEBSSettlementSummary_result()
5047 
    result.read(self._iprot)
5048 
    self._iprot.readMessageEnd()
5049 
    if result.ex is not None:
5050 
      raise result.ex
5051 
    return
5052 
 
5386 phani.kuma 5053 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5054 
    """
5055 
    Parameters:
5189 varun.gupt 5056 
     - referenceId
5057 
     - isRefund
4600 varun.gupt 5058 
    """
5386 phani.kuma 5059 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5060 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5061 
 
5386 phani.kuma 5062 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5063 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5064 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5065 
    args.referenceId = referenceId
5066 
    args.isRefund = isRefund
4600 varun.gupt 5067 
    args.write(self._oprot)
5068 
    self._oprot.writeMessageEnd()
5069 
    self._oprot.trans.flush()
5070 
 
5386 phani.kuma 5071 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5073 
    if mtype == TMessageType.EXCEPTION:
5074 
      x = TApplicationException()
5075 
      x.read(self._iprot)
5076 
      self._iprot.readMessageEnd()
5077 
      raise x
5386 phani.kuma 5078 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5079 
    result.read(self._iprot)
5080 
    self._iprot.readMessageEnd()
5081 
    if result.success is not None:
5082 
      return result.success
5083 
    if result.ex is not None:
5084 
      raise result.ex
5386 phani.kuma 5085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5086 
 
5386 phani.kuma 5087 
  def getSettlementForCod(self, orderId, isRefund):
5088 
    """
5089 
    Parameters:
5090 
     - orderId
5091 
     - isRefund
5092 
    """
5093 
    self.send_getSettlementForCod(orderId, isRefund)
5094 
    return self.recv_getSettlementForCod()
5095 
 
5096 
  def send_getSettlementForCod(self, orderId, isRefund):
5097 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5098 
    args = getSettlementForCod_args()
5099 
    args.orderId = orderId
5100 
    args.isRefund = isRefund
5101 
    args.write(self._oprot)
5102 
    self._oprot.writeMessageEnd()
5103 
    self._oprot.trans.flush()
5104 
 
5105 
  def recv_getSettlementForCod(self, ):
5106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5107 
    if mtype == TMessageType.EXCEPTION:
5108 
      x = TApplicationException()
5109 
      x.read(self._iprot)
5110 
      self._iprot.readMessageEnd()
5111 
      raise x
5112 
    result = getSettlementForCod_result()
5113 
    result.read(self._iprot)
5114 
    self._iprot.readMessageEnd()
5115 
    if result.success is not None:
5116 
      return result.success
5117 
    if result.ex is not None:
5118 
      raise result.ex
5119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5120 
 
4600 varun.gupt 5121 
  def getEBSSettlementSummaries(self, ):
5122 
    self.send_getEBSSettlementSummaries()
5123 
    return self.recv_getEBSSettlementSummaries()
5124 
 
5125 
  def send_getEBSSettlementSummaries(self, ):
5126 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5127 
    args = getEBSSettlementSummaries_args()
5128 
    args.write(self._oprot)
5129 
    self._oprot.writeMessageEnd()
5130 
    self._oprot.trans.flush()
5131 
 
5132 
  def recv_getEBSSettlementSummaries(self, ):
5133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5134 
    if mtype == TMessageType.EXCEPTION:
5135 
      x = TApplicationException()
5136 
      x.read(self._iprot)
5137 
      self._iprot.readMessageEnd()
5138 
      raise x
5139 
    result = getEBSSettlementSummaries_result()
5140 
    result.read(self._iprot)
5141 
    self._iprot.readMessageEnd()
5142 
    if result.success is not None:
5143 
      return result.success
5144 
    if result.ex is not None:
5145 
      raise result.ex
5146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5147 
 
5148 
  def markEBSSettlementUploaded(self, settlementId):
5149 
    """
5150 
    Parameters:
5151 
     - settlementId
5152 
    """
5153 
    self.send_markEBSSettlementUploaded(settlementId)
5154 
    self.recv_markEBSSettlementUploaded()
5155 
 
5156 
  def send_markEBSSettlementUploaded(self, settlementId):
5157 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5158 
    args = markEBSSettlementUploaded_args()
5159 
    args.settlementId = settlementId
5160 
    args.write(self._oprot)
5161 
    self._oprot.writeMessageEnd()
5162 
    self._oprot.trans.flush()
5163 
 
5164 
  def recv_markEBSSettlementUploaded(self, ):
5165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5166 
    if mtype == TMessageType.EXCEPTION:
5167 
      x = TApplicationException()
5168 
      x.read(self._iprot)
5169 
      self._iprot.readMessageEnd()
5170 
      raise x
5171 
    result = markEBSSettlementUploaded_result()
5172 
    result.read(self._iprot)
5173 
    self._iprot.readMessageEnd()
5174 
    if result.ex is not None:
5175 
      raise result.ex
5176 
    return
5177 
 
5178 
  def getEBSSettlementDate(self, settlementId):
5179 
    """
5180 
    Parameters:
5181 
     - settlementId
5182 
    """
5183 
    self.send_getEBSSettlementDate(settlementId)
5184 
    return self.recv_getEBSSettlementDate()
5185 
 
5186 
  def send_getEBSSettlementDate(self, settlementId):
5187 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5188 
    args = getEBSSettlementDate_args()
5189 
    args.settlementId = settlementId
5190 
    args.write(self._oprot)
5191 
    self._oprot.writeMessageEnd()
5192 
    self._oprot.trans.flush()
5193 
 
5194 
  def recv_getEBSSettlementDate(self, ):
5195 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5196 
    if mtype == TMessageType.EXCEPTION:
5197 
      x = TApplicationException()
5198 
      x.read(self._iprot)
5199 
      self._iprot.readMessageEnd()
5200 
      raise x
5201 
    result = getEBSSettlementDate_result()
5202 
    result.read(self._iprot)
5203 
    self._iprot.readMessageEnd()
5204 
    if result.success is not None:
5205 
      return result.success
5206 
    if result.ex is not None:
5207 
      raise result.ex
5208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5209 
 
4715 varun.gupt 5210 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5211 
    """
5212 
    Parameters:
5213 
     - settlementDateFrom
5214 
     - settlementDateTo
5215 
     - isRefund
5216 
    """
5217 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5218 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5219 
 
4715 varun.gupt 5220 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5221 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5222 
    args = getSettlementsByDate_args()
5223 
    args.settlementDateFrom = settlementDateFrom
5224 
    args.settlementDateTo = settlementDateTo
5225 
    args.isRefund = isRefund
5226 
    args.write(self._oprot)
5227 
    self._oprot.writeMessageEnd()
5228 
    self._oprot.trans.flush()
5229 
 
5230 
  def recv_getSettlementsByDate(self, ):
5231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5232 
    if mtype == TMessageType.EXCEPTION:
5233 
      x = TApplicationException()
5234 
      x.read(self._iprot)
5235 
      self._iprot.readMessageEnd()
5236 
      raise x
5237 
    result = getSettlementsByDate_result()
5238 
    result.read(self._iprot)
5239 
    self._iprot.readMessageEnd()
5240 
    if result.success is not None:
5241 
      return result.success
5242 
    if result.ex is not None:
5243 
      raise result.ex
5244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5245 
 
5246 
  def getReshippedOrderIds(self, orderIds):
5247 
    """
5248 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5249 
 
5250 
    Parameters:
5251 
     - orderIds
5252 
    """
5253 
    self.send_getReshippedOrderIds(orderIds)
5254 
    return self.recv_getReshippedOrderIds()
5255 
 
5256 
  def send_getReshippedOrderIds(self, orderIds):
5257 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5258 
    args = getReshippedOrderIds_args()
5259 
    args.orderIds = orderIds
5260 
    args.write(self._oprot)
5261 
    self._oprot.writeMessageEnd()
5262 
    self._oprot.trans.flush()
5263 
 
5264 
  def recv_getReshippedOrderIds(self, ):
5265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5266 
    if mtype == TMessageType.EXCEPTION:
5267 
      x = TApplicationException()
5268 
      x.read(self._iprot)
5269 
      self._iprot.readMessageEnd()
5270 
      raise x
5271 
    result = getReshippedOrderIds_result()
5272 
    result.read(self._iprot)
5273 
    self._iprot.readMessageEnd()
5274 
    if result.success is not None:
5275 
      return result.success
5276 
    if result.ex is not None:
5277 
      raise result.ex
5278 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5279 
 
5481 phani.kuma 5280 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5281 
    """
5282 
    Parameters:
5283 
     - vendorId
5481 phani.kuma 5284 
     - onlyVendorNotPaid
5285 
     - billingDateFrom
5286 
     - billingDateTo
4875 varun.gupt 5287 
    """
5481 phani.kuma 5288 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5289 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5290 
 
5481 phani.kuma 5291 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5292 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5293 
    args = getBilledOrders_args()
4875 varun.gupt 5294 
    args.vendorId = vendorId
5481 phani.kuma 5295 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5296 
    args.billingDateFrom = billingDateFrom
5297 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5298 
    args.write(self._oprot)
5299 
    self._oprot.writeMessageEnd()
5300 
    self._oprot.trans.flush()
5301 
 
5481 phani.kuma 5302 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5304 
    if mtype == TMessageType.EXCEPTION:
5305 
      x = TApplicationException()
5306 
      x.read(self._iprot)
5307 
      self._iprot.readMessageEnd()
5308 
      raise x
5481 phani.kuma 5309 
    result = getBilledOrders_result()
4875 varun.gupt 5310 
    result.read(self._iprot)
5311 
    self._iprot.readMessageEnd()
5312 
    if result.success is not None:
5313 
      return result.success
5314 
    if result.ex is not None:
5315 
      raise result.ex
5481 phani.kuma 5316 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5317 
 
5031 varun.gupt 5318 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5319 
    """
5320 
    Parameters:
5321 
     - startDate
5322 
     - endDate
5323 
    """
5324 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5325 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5326 
 
5031 varun.gupt 5327 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5328 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5329 
    args = getStatusDistributionOfOrders_args()
5330 
    args.startDate = startDate
5331 
    args.endDate = endDate
5332 
    args.write(self._oprot)
5333 
    self._oprot.writeMessageEnd()
5334 
    self._oprot.trans.flush()
5335 
 
5336 
  def recv_getStatusDistributionOfOrders(self, ):
5337 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5338 
    if mtype == TMessageType.EXCEPTION:
5339 
      x = TApplicationException()
5340 
      x.read(self._iprot)
5341 
      self._iprot.readMessageEnd()
5342 
      raise x
5343 
    result = getStatusDistributionOfOrders_result()
5344 
    result.read(self._iprot)
5345 
    self._iprot.readMessageEnd()
5346 
    if result.success is not None:
5347 
      return result.success
5348 
    if result.ex is not None:
5349 
      raise result.ex
5350 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5351 
 
5067 varun.gupt 5352 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5353 
    """
5354 
    Parameters:
5355 
     - status
5356 
     - startDatetime
5357 
     - endDatetime
5358 
    """
5359 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5360 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5361 
 
5067 varun.gupt 5362 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5363 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5364 
    args = getOrderIdsForStatus_args()
5365 
    args.status = status
5366 
    args.startDatetime = startDatetime
5367 
    args.endDatetime = endDatetime
5368 
    args.write(self._oprot)
5369 
    self._oprot.writeMessageEnd()
5370 
    self._oprot.trans.flush()
5371 
 
5372 
  def recv_getOrderIdsForStatus(self, ):
5373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5374 
    if mtype == TMessageType.EXCEPTION:
5375 
      x = TApplicationException()
5376 
      x.read(self._iprot)
5377 
      self._iprot.readMessageEnd()
5378 
      raise x
5379 
    result = getOrderIdsForStatus_result()
5380 
    result.read(self._iprot)
5381 
    self._iprot.readMessageEnd()
5382 
    if result.success is not None:
5383 
      return result.success
5384 
    if result.ex is not None:
5385 
      raise result.ex
5386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5387 
 
5348 anupam.sin 5388 
  def updateCODAgent(self, agent, orderId):
5389 
    """
5390 
    Updates the agent who handled the COD verification call
5391 
 
5392 
    Parameters:
5393 
     - agent
5394 
     - orderId
5395 
    """
5396 
    self.send_updateCODAgent(agent, orderId)
5397 
    self.recv_updateCODAgent()
5398 
 
5399 
  def send_updateCODAgent(self, agent, orderId):
5400 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5401 
    args = updateCODAgent_args()
5402 
    args.agent = agent
5403 
    args.orderId = orderId
5404 
    args.write(self._oprot)
5405 
    self._oprot.writeMessageEnd()
5406 
    self._oprot.trans.flush()
5407 
 
5408 
  def recv_updateCODAgent(self, ):
5409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5410 
    if mtype == TMessageType.EXCEPTION:
5411 
      x = TApplicationException()
5412 
      x.read(self._iprot)
5413 
      self._iprot.readMessageEnd()
5414 
      raise x
5415 
    result = updateCODAgent_result()
5416 
    result.read(self._iprot)
5417 
    self._iprot.readMessageEnd()
5418 
    if result.ex is not None:
5419 
      raise result.ex
5420 
    return
5421 
 
5099 varun.gupt 5422 
  def updateOrderAsPaidToVendor(self, orderId):
5423 
    """
5424 
    Parameters:
5425 
     - orderId
5426 
    """
5427 
    self.send_updateOrderAsPaidToVendor(orderId)
5428 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5429 
 
5099 varun.gupt 5430 
  def send_updateOrderAsPaidToVendor(self, orderId):
5431 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5432 
    args = updateOrderAsPaidToVendor_args()
5433 
    args.orderId = orderId
5434 
    args.write(self._oprot)
5435 
    self._oprot.writeMessageEnd()
5436 
    self._oprot.trans.flush()
5437 
 
5438 
  def recv_updateOrderAsPaidToVendor(self, ):
5439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5440 
    if mtype == TMessageType.EXCEPTION:
5441 
      x = TApplicationException()
5442 
      x.read(self._iprot)
5443 
      self._iprot.readMessageEnd()
5444 
      raise x
5445 
    result = updateOrderAsPaidToVendor_result()
5446 
    result.read(self._iprot)
5447 
    self._iprot.readMessageEnd()
5448 
    if result.ex is not None:
5449 
      raise result.ex
5450 
    return
5451 
 
5386 phani.kuma 5452 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5453 
    """
5454 
    Parameters:
5455 
     - orderId
5456 
    """
5457 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5458 
    self.recv_updateOrderOnlyAsPaidToVendor()
5459 
 
5460 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5461 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5462 
    args = updateOrderOnlyAsPaidToVendor_args()
5463 
    args.orderId = orderId
5464 
    args.write(self._oprot)
5465 
    self._oprot.writeMessageEnd()
5466 
    self._oprot.trans.flush()
5467 
 
5468 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5470 
    if mtype == TMessageType.EXCEPTION:
5471 
      x = TApplicationException()
5472 
      x.read(self._iprot)
5473 
      self._iprot.readMessageEnd()
5474 
      raise x
5475 
    result = updateOrderOnlyAsPaidToVendor_result()
5476 
    result.read(self._iprot)
5477 
    self._iprot.readMessageEnd()
5478 
    if result.ex is not None:
5479 
      raise result.ex
5480 
    return
5481 
 
5208 varun.gupt 5482 
  def getRefundedOrdersMarkedPaid(self, ):
5483 
    self.send_getRefundedOrdersMarkedPaid()
5484 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5485 
 
5208 varun.gupt 5486 
  def send_getRefundedOrdersMarkedPaid(self, ):
5487 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5488 
    args = getRefundedOrdersMarkedPaid_args()
5489 
    args.write(self._oprot)
5490 
    self._oprot.writeMessageEnd()
5491 
    self._oprot.trans.flush()
5492 
 
5493 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5495 
    if mtype == TMessageType.EXCEPTION:
5496 
      x = TApplicationException()
5497 
      x.read(self._iprot)
5498 
      self._iprot.readMessageEnd()
5499 
      raise x
5500 
    result = getRefundedOrdersMarkedPaid_result()
5501 
    result.read(self._iprot)
5502 
    self._iprot.readMessageEnd()
5503 
    if result.success is not None:
5504 
      return result.success
5505 
    if result.ex is not None:
5506 
      raise result.ex
5507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5508 
 
5447 anupam.sin 5509 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5510 
    """
5511 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5512 
 
5447 anupam.sin 5513 
 
5514 
    Parameters:
5515 
     - minOrderId
5516 
     - maxOrderId
5517 
    """
5518 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5519 
    return self.recv_getAllVerificationAgents()
5520 
 
5521 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5522 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5523 
    args = getAllVerificationAgents_args()
5524 
    args.minOrderId = minOrderId
5525 
    args.maxOrderId = maxOrderId
5526 
    args.write(self._oprot)
5527 
    self._oprot.writeMessageEnd()
5528 
    self._oprot.trans.flush()
5529 
 
5530 
  def recv_getAllVerificationAgents(self, ):
5531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5532 
    if mtype == TMessageType.EXCEPTION:
5533 
      x = TApplicationException()
5534 
      x.read(self._iprot)
5535 
      self._iprot.readMessageEnd()
5536 
      raise x
5537 
    result = getAllVerificationAgents_result()
5538 
    result.read(self._iprot)
5539 
    self._iprot.readMessageEnd()
5540 
    if result.success is not None:
5541 
      return result.success
5542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5543 
 
5527 anupam.sin 5544 
  def getAllAttributesForOrderId(self, orderId):
5545 
    """
5546 
    gets all attributes for a given orderId
5447 anupam.sin 5547 
 
5527 anupam.sin 5548 
    Parameters:
5549 
     - orderId
5550 
    """
5551 
    self.send_getAllAttributesForOrderId(orderId)
5552 
    return self.recv_getAllAttributesForOrderId()
5553 
 
5554 
  def send_getAllAttributesForOrderId(self, orderId):
5555 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5556 
    args = getAllAttributesForOrderId_args()
5557 
    args.orderId = orderId
5558 
    args.write(self._oprot)
5559 
    self._oprot.writeMessageEnd()
5560 
    self._oprot.trans.flush()
5561 
 
5562 
  def recv_getAllAttributesForOrderId(self, ):
5563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5564 
    if mtype == TMessageType.EXCEPTION:
5565 
      x = TApplicationException()
5566 
      x.read(self._iprot)
5567 
      self._iprot.readMessageEnd()
5568 
      raise x
5569 
    result = getAllAttributesForOrderId_result()
5570 
    result.read(self._iprot)
5571 
    self._iprot.readMessageEnd()
5572 
    if result.success is not None:
5573 
      return result.success
5574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5575 
 
5676 rajveer 5576 
  def setOrderAttributes(self, orderId, attributes):
5577 
    """
5578 
    sets attributes for an order
5579 
 
5580 
    Parameters:
5581 
     - orderId
5582 
     - attributes
5583 
    """
5584 
    self.send_setOrderAttributes(orderId, attributes)
5585 
    self.recv_setOrderAttributes()
5586 
 
5587 
  def send_setOrderAttributes(self, orderId, attributes):
5588 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5589 
    args = setOrderAttributes_args()
5590 
    args.orderId = orderId
5591 
    args.attributes = attributes
5592 
    args.write(self._oprot)
5593 
    self._oprot.writeMessageEnd()
5594 
    self._oprot.trans.flush()
5595 
 
5596 
  def recv_setOrderAttributes(self, ):
5597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5598 
    if mtype == TMessageType.EXCEPTION:
5599 
      x = TApplicationException()
5600 
      x.read(self._iprot)
5601 
      self._iprot.readMessageEnd()
5602 
      raise x
5603 
    result = setOrderAttributes_result()
5604 
    result.read(self._iprot)
5605 
    self._iprot.readMessageEnd()
5606 
    return
5607 
 
5527 anupam.sin 5608 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5609 
    """
5610 
    sets attributes for all orders in a transaction
5611 
 
5612 
    Parameters:
5613 
     - transactionId
5614 
     - attribute
5615 
    """
5616 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5617 
    self.recv_setOrderAttributeForTransaction()
5618 
 
5619 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5620 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5621 
    args = setOrderAttributeForTransaction_args()
5622 
    args.transactionId = transactionId
5623 
    args.attribute = attribute
5624 
    args.write(self._oprot)
5625 
    self._oprot.writeMessageEnd()
5626 
    self._oprot.trans.flush()
5627 
 
5628 
  def recv_setOrderAttributeForTransaction(self, ):
5629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5630 
    if mtype == TMessageType.EXCEPTION:
5631 
      x = TApplicationException()
5632 
      x.read(self._iprot)
5633 
      self._iprot.readMessageEnd()
5634 
      raise x
5635 
    result = setOrderAttributeForTransaction_result()
5636 
    result.read(self._iprot)
5637 
    self._iprot.readMessageEnd()
5638 
    return
5639 
 
5553 rajveer 5640 
  def getReceivePendingOrders(self, storeId):
5641 
    """
5642 
    Parameters:
5643 
     - storeId
5644 
    """
5645 
    self.send_getReceivePendingOrders(storeId)
5646 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5647 
 
5553 rajveer 5648 
  def send_getReceivePendingOrders(self, storeId):
5649 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5650 
    args = getReceivePendingOrders_args()
5651 
    args.storeId = storeId
5652 
    args.write(self._oprot)
5653 
    self._oprot.writeMessageEnd()
5654 
    self._oprot.trans.flush()
5655 
 
5656 
  def recv_getReceivePendingOrders(self, ):
5657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5658 
    if mtype == TMessageType.EXCEPTION:
5659 
      x = TApplicationException()
5660 
      x.read(self._iprot)
5661 
      self._iprot.readMessageEnd()
5662 
      raise x
5663 
    result = getReceivePendingOrders_result()
5664 
    result.read(self._iprot)
5665 
    self._iprot.readMessageEnd()
5666 
    if result.success is not None:
5667 
      return result.success
5668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5669 
 
5670 
  def getReceivedAtStoreOrders(self, storeId):
5671 
    """
5672 
    Parameters:
5673 
     - storeId
5674 
    """
5675 
    self.send_getReceivedAtStoreOrders(storeId)
5676 
    return self.recv_getReceivedAtStoreOrders()
5677 
 
5678 
  def send_getReceivedAtStoreOrders(self, storeId):
5679 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5680 
    args = getReceivedAtStoreOrders_args()
5681 
    args.storeId = storeId
5682 
    args.write(self._oprot)
5683 
    self._oprot.writeMessageEnd()
5684 
    self._oprot.trans.flush()
5685 
 
5686 
  def recv_getReceivedAtStoreOrders(self, ):
5687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5688 
    if mtype == TMessageType.EXCEPTION:
5689 
      x = TApplicationException()
5690 
      x.read(self._iprot)
5691 
      self._iprot.readMessageEnd()
5692 
      raise x
5693 
    result = getReceivedAtStoreOrders_result()
5694 
    result.read(self._iprot)
5695 
    self._iprot.readMessageEnd()
5696 
    if result.success is not None:
5697 
      return result.success
5698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5699 
 
5713 rajveer 5700 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5701 
    """
5702 
    Parameters:
5703 
     - storeId
5704 
     - fromDate
5705 
     - toDate
5706 
     - onlyCod
5707 
    """
5708 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5709 
    return self.recv_getOrdersCollectionAtStore()
5710 
 
5711 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5712 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5713 
    args = getOrdersCollectionAtStore_args()
5714 
    args.storeId = storeId
5715 
    args.fromDate = fromDate
5716 
    args.toDate = toDate
5717 
    args.onlyCod = onlyCod
5718 
    args.write(self._oprot)
5719 
    self._oprot.writeMessageEnd()
5720 
    self._oprot.trans.flush()
5721 
 
5722 
  def recv_getOrdersCollectionAtStore(self, ):
5723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5724 
    if mtype == TMessageType.EXCEPTION:
5725 
      x = TApplicationException()
5726 
      x.read(self._iprot)
5727 
      self._iprot.readMessageEnd()
5728 
      raise x
5729 
    result = getOrdersCollectionAtStore_result()
5730 
    result.read(self._iprot)
5731 
    self._iprot.readMessageEnd()
5732 
    if result.success is not None:
5733 
      return result.success
5734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5735 
 
5833 rajveer 5736 
  def getOrderAttributeValue(self, orderId, attributeName):
5737 
    """
5738 
    Parameters:
5739 
     - orderId
5740 
     - attributeName
5741 
    """
5742 
    self.send_getOrderAttributeValue(orderId, attributeName)
5743 
    return self.recv_getOrderAttributeValue()
5744 
 
5745 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5746 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5747 
    args = getOrderAttributeValue_args()
5748 
    args.orderId = orderId
5749 
    args.attributeName = attributeName
5750 
    args.write(self._oprot)
5751 
    self._oprot.writeMessageEnd()
5752 
    self._oprot.trans.flush()
5753 
 
5754 
  def recv_getOrderAttributeValue(self, ):
5755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5756 
    if mtype == TMessageType.EXCEPTION:
5757 
      x = TApplicationException()
5758 
      x.read(self._iprot)
5759 
      self._iprot.readMessageEnd()
5760 
      raise x
5761 
    result = getOrderAttributeValue_result()
5762 
    result.read(self._iprot)
5763 
    self._iprot.readMessageEnd()
5764 
    if result.success is not None:
5765 
      return result.success
5766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5767 
 
6019 rajveer 5768 
  def changeJacketNumber(self, orderId, jacketNumber):
5769 
    """
5770 
    Parameters:
5771 
     - orderId
5772 
     - jacketNumber
5773 
    """
5774 
    self.send_changeJacketNumber(orderId, jacketNumber)
5775 
    return self.recv_changeJacketNumber()
5776 
 
5777 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5778 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5779 
    args = changeJacketNumber_args()
5780 
    args.orderId = orderId
5781 
    args.jacketNumber = jacketNumber
5782 
    args.write(self._oprot)
5783 
    self._oprot.writeMessageEnd()
5784 
    self._oprot.trans.flush()
5785 
 
5786 
  def recv_changeJacketNumber(self, ):
5787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5788 
    if mtype == TMessageType.EXCEPTION:
5789 
      x = TApplicationException()
5790 
      x.read(self._iprot)
5791 
      self._iprot.readMessageEnd()
5792 
      raise x
5793 
    result = changeJacketNumber_result()
5794 
    result.read(self._iprot)
5795 
    self._iprot.readMessageEnd()
5796 
    if result.success is not None:
5797 
      return result.success
5798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5799 
 
5800 
  def markOrderAsRtoInTransit(self, orderId):
5801 
    """
5802 
    Parameters:
5803 
     - orderId
5804 
    """
5805 
    self.send_markOrderAsRtoInTransit(orderId)
5806 
    return self.recv_markOrderAsRtoInTransit()
5807 
 
5808 
  def send_markOrderAsRtoInTransit(self, orderId):
5809 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5810 
    args = markOrderAsRtoInTransit_args()
5811 
    args.orderId = orderId
5812 
    args.write(self._oprot)
5813 
    self._oprot.writeMessageEnd()
5814 
    self._oprot.trans.flush()
5815 
 
5816 
  def recv_markOrderAsRtoInTransit(self, ):
5817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5818 
    if mtype == TMessageType.EXCEPTION:
5819 
      x = TApplicationException()
5820 
      x.read(self._iprot)
5821 
      self._iprot.readMessageEnd()
5822 
      raise x
5823 
    result = markOrderAsRtoInTransit_result()
5824 
    result.read(self._iprot)
5825 
    self._iprot.readMessageEnd()
5826 
    if result.success is not None:
5827 
      return result.success
5828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5829 
 
5593 mandeep.dh 5830 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5831 
    """
5832 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5833 
    invoked while scanning IN of items.
5553 rajveer 5834 
 
5593 mandeep.dh 5835 
    Parameters:
5836 
     - itemId
5837 
     - quantity
5838 
     - fulfilmentWarehouseId
5839 
     - billingWarehouseId
5840 
    """
5841 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5842 
    self.recv_acceptOrderForItem()
5843 
 
5844 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5845 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5846 
    args = acceptOrderForItem_args()
5847 
    args.itemId = itemId
5848 
    args.quantity = quantity
5849 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5850 
    args.billingWarehouseId = billingWarehouseId
5851 
    args.write(self._oprot)
5852 
    self._oprot.writeMessageEnd()
5853 
    self._oprot.trans.flush()
5854 
 
5855 
  def recv_acceptOrderForItem(self, ):
5856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5857 
    if mtype == TMessageType.EXCEPTION:
5858 
      x = TApplicationException()
5859 
      x.read(self._iprot)
5860 
      self._iprot.readMessageEnd()
5861 
      raise x
5862 
    result = acceptOrderForItem_result()
5863 
    result.read(self._iprot)
5864 
    self._iprot.readMessageEnd()
5865 
    return
5866 
 
6000 mandeep.dh 5867 
  def createRechargeOrder(self, rechargeOrder):
5868 
    """
5869 
    Parameters:
5870 
     - rechargeOrder
5871 
    """
5872 
    self.send_createRechargeOrder(rechargeOrder)
5873 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5874 
 
6000 mandeep.dh 5875 
  def send_createRechargeOrder(self, rechargeOrder):
5876 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5877 
    args = createRechargeOrder_args()
5878 
    args.rechargeOrder = rechargeOrder
5879 
    args.write(self._oprot)
5880 
    self._oprot.writeMessageEnd()
5881 
    self._oprot.trans.flush()
5882 
 
5883 
  def recv_createRechargeOrder(self, ):
5884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5885 
    if mtype == TMessageType.EXCEPTION:
5886 
      x = TApplicationException()
5887 
      x.read(self._iprot)
5888 
      self._iprot.readMessageEnd()
5889 
      raise x
5890 
    result = createRechargeOrder_result()
5891 
    result.read(self._iprot)
5892 
    self._iprot.readMessageEnd()
5893 
    if result.success is not None:
5894 
      return result.success
5895 
    if result.ex is not None:
5896 
      raise result.ex
5897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5898 
 
6031 rajveer 5899 
  def getRechargeOrder(self, rechargeRrderId):
5900 
    """
5901 
    Parameters:
5902 
     - rechargeRrderId
5903 
    """
5904 
    self.send_getRechargeOrder(rechargeRrderId)
5905 
    return self.recv_getRechargeOrder()
5906 
 
5907 
  def send_getRechargeOrder(self, rechargeRrderId):
5908 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5909 
    args = getRechargeOrder_args()
5910 
    args.rechargeRrderId = rechargeRrderId
5911 
    args.write(self._oprot)
5912 
    self._oprot.writeMessageEnd()
5913 
    self._oprot.trans.flush()
5914 
 
5915 
  def recv_getRechargeOrder(self, ):
5916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5917 
    if mtype == TMessageType.EXCEPTION:
5918 
      x = TApplicationException()
5919 
      x.read(self._iprot)
5920 
      self._iprot.readMessageEnd()
5921 
      raise x
5922 
    result = getRechargeOrder_result()
5923 
    result.read(self._iprot)
5924 
    self._iprot.readMessageEnd()
5925 
    if result.success is not None:
5926 
      return result.success
5927 
    if result.ex is not None:
5928 
      raise result.ex
5929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5930 
 
5931 
  def getRechargeOrders(self, userId):
5932 
    """
5933 
    Parameters:
5934 
     - userId
5935 
    """
5936 
    self.send_getRechargeOrders(userId)
5937 
    return self.recv_getRechargeOrders()
5938 
 
5939 
  def send_getRechargeOrders(self, userId):
5940 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5941 
    args = getRechargeOrders_args()
5942 
    args.userId = userId
5943 
    args.write(self._oprot)
5944 
    self._oprot.writeMessageEnd()
5945 
    self._oprot.trans.flush()
5946 
 
5947 
  def recv_getRechargeOrders(self, ):
5948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5949 
    if mtype == TMessageType.EXCEPTION:
5950 
      x = TApplicationException()
5951 
      x.read(self._iprot)
5952 
      self._iprot.readMessageEnd()
5953 
      raise x
5954 
    result = getRechargeOrders_result()
5955 
    result.read(self._iprot)
5956 
    self._iprot.readMessageEnd()
5957 
    if result.success is not None:
5958 
      return result.success
5959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5960 
 
6000 mandeep.dh 5961 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5962 
    """
5963 
    Parameters:
5964 
     - rechargeOrderId
5965 
     - rechargeOrderStatus
5966 
    """
5967 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5968 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5969 
 
5970 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5971 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5972 
    args = updateRechargeOrderStatus_args()
5973 
    args.rechargeOrderId = rechargeOrderId
5974 
    args.rechargeOrderStatus = rechargeOrderStatus
5975 
    args.write(self._oprot)
5976 
    self._oprot.writeMessageEnd()
5977 
    self._oprot.trans.flush()
5978 
 
5979 
  def recv_updateRechargeOrderStatus(self, ):
5980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5981 
    if mtype == TMessageType.EXCEPTION:
5982 
      x = TApplicationException()
5983 
      x.read(self._iprot)
5984 
      self._iprot.readMessageEnd()
5985 
      raise x
5986 
    result = updateRechargeOrderStatus_result()
5987 
    result.read(self._iprot)
5988 
    self._iprot.readMessageEnd()
6031 rajveer 5989 
    if result.success is not None:
5990 
      return result.success
6000 mandeep.dh 5991 
    if result.ex is not None:
5992 
      raise result.ex
6031 rajveer 5993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5994 
 
6031 rajveer 5995 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5996 
    """
5997 
    Parameters:
6031 rajveer 5998 
     - rechargeOrderId
6000 mandeep.dh 5999 
    """
6031 rajveer 6000 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6001 
    return self.recv_activateRechargeTxn()
6002 
 
6031 rajveer 6003 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6004 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6005 
    args = activateRechargeTxn_args()
6031 rajveer 6006 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6007 
    args.write(self._oprot)
6008 
    self._oprot.writeMessageEnd()
6009 
    self._oprot.trans.flush()
6010 
 
6011 
  def recv_activateRechargeTxn(self, ):
6012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6013 
    if mtype == TMessageType.EXCEPTION:
6014 
      x = TApplicationException()
6015 
      x.read(self._iprot)
6016 
      self._iprot.readMessageEnd()
6017 
      raise x
6018 
    result = activateRechargeTxn_result()
6019 
    result.read(self._iprot)
6020 
    self._iprot.readMessageEnd()
6021 
    if result.success is not None:
6022 
      return result.success
6023 
    if result.ex is not None:
6024 
      raise result.ex
6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6026 
 
6031 rajveer 6027 
  def getUserWallet(self, userId):
6000 mandeep.dh 6028 
    """
6029 
    Parameters:
6031 rajveer 6030 
     - userId
6000 mandeep.dh 6031 
    """
6031 rajveer 6032 
    self.send_getUserWallet(userId)
6033 
    return self.recv_getUserWallet()
6000 mandeep.dh 6034 
 
6031 rajveer 6035 
  def send_getUserWallet(self, userId):
6036 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6037 
    args = getUserWallet_args()
6038 
    args.userId = userId
6000 mandeep.dh 6039 
    args.write(self._oprot)
6040 
    self._oprot.writeMessageEnd()
6041 
    self._oprot.trans.flush()
6042 
 
6031 rajveer 6043 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6044 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6045 
    if mtype == TMessageType.EXCEPTION:
6046 
      x = TApplicationException()
6047 
      x.read(self._iprot)
6048 
      self._iprot.readMessageEnd()
6049 
      raise x
6031 rajveer 6050 
    result = getUserWallet_result()
6000 mandeep.dh 6051 
    result.read(self._iprot)
6052 
    self._iprot.readMessageEnd()
6053 
    if result.success is not None:
6054 
      return result.success
6031 rajveer 6055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6056 
 
6031 rajveer 6057 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6058 
    """
6059 
    Parameters:
6031 rajveer 6060 
     - userId
6000 mandeep.dh 6061 
    """
6031 rajveer 6062 
    self.send_getUserWalletHistory(userId)
6063 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6064 
 
6031 rajveer 6065 
  def send_getUserWalletHistory(self, userId):
6066 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6067 
    args = getUserWalletHistory_args()
6068 
    args.userId = userId
6000 mandeep.dh 6069 
    args.write(self._oprot)
6070 
    self._oprot.writeMessageEnd()
6071 
    self._oprot.trans.flush()
6072 
 
6031 rajveer 6073 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6074 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6075 
    if mtype == TMessageType.EXCEPTION:
6076 
      x = TApplicationException()
6077 
      x.read(self._iprot)
6078 
      self._iprot.readMessageEnd()
6079 
      raise x
6031 rajveer 6080 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6081 
    result.read(self._iprot)
6082 
    self._iprot.readMessageEnd()
6083 
    if result.success is not None:
6084 
      return result.success
6031 rajveer 6085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6086 
 
6050 anupam.sin 6087 
  def getRechargeOrdersForTransaction(self, txnId):
6088 
    """
6089 
    Returns a recharge order for a given transactionId
6090 
 
6091 
    Parameters:
6092 
     - txnId
6093 
    """
6094 
    self.send_getRechargeOrdersForTransaction(txnId)
6095 
    return self.recv_getRechargeOrdersForTransaction()
6096 
 
6097 
  def send_getRechargeOrdersForTransaction(self, txnId):
6098 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6099 
    args = getRechargeOrdersForTransaction_args()
6100 
    args.txnId = txnId
6101 
    args.write(self._oprot)
6102 
    self._oprot.writeMessageEnd()
6103 
    self._oprot.trans.flush()
6104 
 
6105 
  def recv_getRechargeOrdersForTransaction(self, ):
6106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6107 
    if mtype == TMessageType.EXCEPTION:
6108 
      x = TApplicationException()
6109 
      x.read(self._iprot)
6110 
      self._iprot.readMessageEnd()
6111 
      raise x
6112 
    result = getRechargeOrdersForTransaction_result()
6113 
    result.read(self._iprot)
6114 
    self._iprot.readMessageEnd()
6115 
    if result.success is not None:
6116 
      return result.success
6117 
    if result.ex is not None:
6118 
      raise result.ex
6119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6120 
 
6206 rajveer 6121 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6122 
    """
6123 
    Parameters:
6124 
     - rechargeType
6206 rajveer 6125 
     - onlyActive
6048 rajveer 6126 
    """
6206 rajveer 6127 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6128 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6129 
 
6206 rajveer 6130 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6131 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6132 
    args = getServiceProviders_args()
6133 
    args.rechargeType = rechargeType
6206 rajveer 6134 
    args.onlyActive = onlyActive
6048 rajveer 6135 
    args.write(self._oprot)
6136 
    self._oprot.writeMessageEnd()
6137 
    self._oprot.trans.flush()
6138 
 
6139 
  def recv_getServiceProviders(self, ):
6140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6141 
    if mtype == TMessageType.EXCEPTION:
6142 
      x = TApplicationException()
6143 
      x.read(self._iprot)
6144 
      self._iprot.readMessageEnd()
6145 
      raise x
6146 
    result = getServiceProviders_result()
6147 
    result.read(self._iprot)
6148 
    self._iprot.readMessageEnd()
6149 
    if result.success is not None:
6150 
      return result.success
6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6152 
 
6049 rajveer 6153 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6154 
    """
6155 
    Parameters:
6049 rajveer 6156 
     - rechargeType
6048 rajveer 6157 
     - deviceNumber
6158 
    """
6049 rajveer 6159 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6160 
    return self.recv_getServiceProviderForDevice()
6161 
 
6049 rajveer 6162 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6163 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6164 
    args = getServiceProviderForDevice_args()
6049 rajveer 6165 
    args.rechargeType = rechargeType
6048 rajveer 6166 
    args.deviceNumber = deviceNumber
6167 
    args.write(self._oprot)
6168 
    self._oprot.writeMessageEnd()
6169 
    self._oprot.trans.flush()
6170 
 
6171 
  def recv_getServiceProviderForDevice(self, ):
6172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6173 
    if mtype == TMessageType.EXCEPTION:
6174 
      x = TApplicationException()
6175 
      x.read(self._iprot)
6176 
      self._iprot.readMessageEnd()
6177 
      raise x
6178 
    result = getServiceProviderForDevice_result()
6179 
    result.read(self._iprot)
6180 
    self._iprot.readMessageEnd()
6181 
    if result.success is not None:
6182 
      return result.success
6183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6184 
 
6336 anupam.sin 6185 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6186 
    """
6187 
    Parameters:
6188 
     - rechargeType
6189 
     - deviceNumber
6307 anupam.sin 6190 
     - userSelectedProviderId
6269 rajveer 6191 
    """
6336 anupam.sin 6192 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId)
6269 rajveer 6193 
    return self.recv_validateRecharge()
6194 
 
6336 anupam.sin 6195 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6196 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6197 
    args = validateRecharge_args()
6198 
    args.rechargeType = rechargeType
6199 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6200 
    args.userSelectedProviderId = userSelectedProviderId
6269 rajveer 6201 
    args.write(self._oprot)
6202 
    self._oprot.writeMessageEnd()
6203 
    self._oprot.trans.flush()
6204 
 
6205 
  def recv_validateRecharge(self, ):
6206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6207 
    if mtype == TMessageType.EXCEPTION:
6208 
      x = TApplicationException()
6209 
      x.read(self._iprot)
6210 
      self._iprot.readMessageEnd()
6211 
      raise x
6212 
    result = validateRecharge_result()
6213 
    result.read(self._iprot)
6214 
    self._iprot.readMessageEnd()
6215 
    if result.success is not None:
6216 
      return result.success
6217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6218 
 
6094 rajveer 6219 
  def getRechargeOrdersForDevice(self, deviceNumber):
6220 
    """
6221 
    Parameters:
6222 
     - deviceNumber
6223 
    """
6224 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6225 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6226 
 
6094 rajveer 6227 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6228 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6229 
    args = getRechargeOrdersForDevice_args()
6230 
    args.deviceNumber = deviceNumber
6231 
    args.write(self._oprot)
6232 
    self._oprot.writeMessageEnd()
6233 
    self._oprot.trans.flush()
6234 
 
6235 
  def recv_getRechargeOrdersForDevice(self, ):
6236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6237 
    if mtype == TMessageType.EXCEPTION:
6238 
      x = TApplicationException()
6239 
      x.read(self._iprot)
6240 
      self._iprot.readMessageEnd()
6241 
      raise x
6242 
    result = getRechargeOrdersForDevice_result()
6243 
    result.read(self._iprot)
6244 
    self._iprot.readMessageEnd()
6245 
    if result.success is not None:
6246 
      return result.success
6247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6248 
 
6249 
  def addAmountToWallet(self, userId, orderId, amount):
6250 
    """
6251 
    Parameters:
6252 
     - userId
6253 
     - orderId
6254 
     - amount
6255 
    """
6256 
    self.send_addAmountToWallet(userId, orderId, amount)
6257 
    self.recv_addAmountToWallet()
6258 
 
6259 
  def send_addAmountToWallet(self, userId, orderId, amount):
6260 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6261 
    args = addAmountToWallet_args()
6262 
    args.userId = userId
6263 
    args.orderId = orderId
6264 
    args.amount = amount
6265 
    args.write(self._oprot)
6266 
    self._oprot.writeMessageEnd()
6267 
    self._oprot.trans.flush()
6268 
 
6269 
  def recv_addAmountToWallet(self, ):
6270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6271 
    if mtype == TMessageType.EXCEPTION:
6272 
      x = TApplicationException()
6273 
      x.read(self._iprot)
6274 
      self._iprot.readMessageEnd()
6275 
      raise x
6276 
    result = addAmountToWallet_result()
6277 
    result.read(self._iprot)
6278 
    self._iprot.readMessageEnd()
6279 
    return
6280 
 
6188 rajveer 6281 
  def getRechargeStatistics(self, ):
6282 
    self.send_getRechargeStatistics()
6283 
    return self.recv_getRechargeStatistics()
6284 
 
6285 
  def send_getRechargeStatistics(self, ):
6286 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6287 
    args = getRechargeStatistics_args()
6288 
    args.write(self._oprot)
6289 
    self._oprot.writeMessageEnd()
6290 
    self._oprot.trans.flush()
6291 
 
6292 
  def recv_getRechargeStatistics(self, ):
6293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6294 
    if mtype == TMessageType.EXCEPTION:
6295 
      x = TApplicationException()
6296 
      x.read(self._iprot)
6297 
      self._iprot.readMessageEnd()
6298 
      raise x
6299 
    result = getRechargeStatistics_result()
6300 
    result.read(self._iprot)
6301 
    self._iprot.readMessageEnd()
6302 
    if result.success is not None:
6303 
      return result.success
6304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6305 
 
6154 rajveer 6306 
  def getRechargeOrdersForStatus(self, status):
6307 
    """
6308 
    Parameters:
6309 
     - status
6310 
    """
6311 
    self.send_getRechargeOrdersForStatus(status)
6312 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6313 
 
6154 rajveer 6314 
  def send_getRechargeOrdersForStatus(self, status):
6315 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6316 
    args = getRechargeOrdersForStatus_args()
6317 
    args.status = status
6318 
    args.write(self._oprot)
6319 
    self._oprot.writeMessageEnd()
6320 
    self._oprot.trans.flush()
6321 
 
6322 
  def recv_getRechargeOrdersForStatus(self, ):
6323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6324 
    if mtype == TMessageType.EXCEPTION:
6325 
      x = TApplicationException()
6326 
      x.read(self._iprot)
6327 
      self._iprot.readMessageEnd()
6328 
      raise x
6329 
    result = getRechargeOrdersForStatus_result()
6330 
    result.read(self._iprot)
6331 
    self._iprot.readMessageEnd()
6332 
    if result.success is not None:
6333 
      return result.success
6334 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6335 
 
6159 rajveer 6336 
  def getPlansForOperator(self, operatorId):
6337 
    """
6338 
    Parameters:
6339 
     - operatorId
6340 
    """
6341 
    self.send_getPlansForOperator(operatorId)
6342 
    return self.recv_getPlansForOperator()
6154 rajveer 6343 
 
6159 rajveer 6344 
  def send_getPlansForOperator(self, operatorId):
6345 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6346 
    args = getPlansForOperator_args()
6347 
    args.operatorId = operatorId
6348 
    args.write(self._oprot)
6349 
    self._oprot.writeMessageEnd()
6350 
    self._oprot.trans.flush()
6351 
 
6352 
  def recv_getPlansForOperator(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 = getPlansForOperator_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, "getPlansForOperator failed: unknown result");
6365 
 
6307 anupam.sin 6366 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6367 
    """
6368 
    Returns denominations for a given operator and circle
6159 rajveer 6369 
 
6289 anupam.sin 6370 
    Parameters:
6371 
     - operatorId
6307 anupam.sin 6372 
     - circleCode
6289 anupam.sin 6373 
     - denominationType
6374 
    """
6307 anupam.sin 6375 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6376 
    return self.recv_getRechargeDenominations()
6377 
 
6307 anupam.sin 6378 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6379 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6380 
    args = getRechargeDenominations_args()
6381 
    args.operatorId = operatorId
6307 anupam.sin 6382 
    args.circleCode = circleCode
6289 anupam.sin 6383 
    args.denominationType = denominationType
6384 
    args.write(self._oprot)
6385 
    self._oprot.writeMessageEnd()
6386 
    self._oprot.trans.flush()
6387 
 
6388 
  def recv_getRechargeDenominations(self, ):
6389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6390 
    if mtype == TMessageType.EXCEPTION:
6391 
      x = TApplicationException()
6392 
      x.read(self._iprot)
6393 
      self._iprot.readMessageEnd()
6394 
      raise x
6395 
    result = getRechargeDenominations_result()
6396 
    result.read(self._iprot)
6397 
    self._iprot.readMessageEnd()
6398 
    if result.success is not None:
6399 
      return result.success
6400 
    if result.ex is not None:
6401 
      raise result.ex
6402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6403 
 
6371 rajveer 6404 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6405 
    """
6406 
    Parameters:
6407 
     - operatorId
6408 
     - circleId
6409 
     - isAvailable
6410 
    """
6411 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6412 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6413 
 
6371 rajveer 6414 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6415 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6416 
    args = updateAvailabilityStatus_args()
6417 
    args.operatorId = operatorId
6418 
    args.circleId = circleId
6419 
    args.isAvailable = isAvailable
6420 
    args.write(self._oprot)
6421 
    self._oprot.writeMessageEnd()
6422 
    self._oprot.trans.flush()
6423 
 
6424 
  def recv_updateAvailabilityStatus(self, ):
6425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6426 
    if mtype == TMessageType.EXCEPTION:
6427 
      x = TApplicationException()
6428 
      x.read(self._iprot)
6429 
      self._iprot.readMessageEnd()
6430 
      raise x
6431 
    result = updateAvailabilityStatus_result()
6432 
    result.read(self._iprot)
6433 
    self._iprot.readMessageEnd()
6434 
    return
6435 
 
6436 
 
3376 rajveer 6437 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6438 
  def __init__(self, handler):
3376 rajveer 6439 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6440 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6441 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6442 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6443 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6444 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6445 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6446 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6447 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6448 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6449 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6450 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6451 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6452 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6453 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6454 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6455 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6456 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6457 
    self._processMap["createOrder"] = Processor.process_createOrder
6458 
    self._processMap["getOrder"] = Processor.process_getOrder
6459 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6460 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6461 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6462 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6463 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6464 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6465 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6466 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6467 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6468 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6469 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6470 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6471 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6472 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6473 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6474 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6475 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6476 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6477 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6478 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6479 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6480 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6481 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6482 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6483 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6484 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6485 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6486 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6487 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6488 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6489 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6490 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6491 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6492 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6493 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6494 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6495 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6496 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6497 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6498 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6499 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6500 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6501 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6502 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6503 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6504 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6505 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6506 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6507 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6508 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6509 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6510 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6511 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6512 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6513 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6514 
    self._processMap["changeItem"] = Processor.process_changeItem
6515 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6516 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6517 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6518 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6519 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6520 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6521 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6522 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6523 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6524 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6525 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6526 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6527 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6528 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6529 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6530 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6531 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6532 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6533 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6534 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6535 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6536 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6537 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6538 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6539 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6540 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6541 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6542 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6543 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6544 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6545 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6546 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6547 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6548 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6549 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6550 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6551 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6552 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6553 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6554 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6555 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6556 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6557 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6558 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6559 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6560 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6561 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6562 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6563 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6564 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6565 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6566 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6567 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6568 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6569 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6570 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6571 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6572 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6573 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6574 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6575 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6576 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6577 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6578 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6579 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6580 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6581 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6582 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6583 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6584 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
94 ashish 6585 
 
6586 
  def process(self, iprot, oprot):
6587 
    (name, type, seqid) = iprot.readMessageBegin()
6588 
    if name not in self._processMap:
6589 
      iprot.skip(TType.STRUCT)
6590 
      iprot.readMessageEnd()
6591 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6592 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6593 
      x.write(oprot)
6594 
      oprot.writeMessageEnd()
6595 
      oprot.trans.flush()
6596 
      return
6597 
    else:
6598 
      self._processMap[name](self, seqid, iprot, oprot)
6599 
    return True
6600 
 
6601 
  def process_createTransaction(self, seqid, iprot, oprot):
6602 
    args = createTransaction_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = createTransaction_result()
6606 
    try:
132 ashish 6607 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6608 
    except TransactionServiceException, ex:
6609 
      result.ex = ex
6610 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
6614 
 
6615 
  def process_getTransaction(self, seqid, iprot, oprot):
6616 
    args = getTransaction_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getTransaction_result()
6620 
    try:
6621 
      result.success = self._handler.getTransaction(args.id)
6622 
    except TransactionServiceException, ex:
6623 
      result.ex = ex
6624 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6625 
    result.write(oprot)
6626 
    oprot.writeMessageEnd()
6627 
    oprot.trans.flush()
6628 
 
6629 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6630 
    args = getTransactionsForCustomer_args()
6631 
    args.read(iprot)
6632 
    iprot.readMessageEnd()
6633 
    result = getTransactionsForCustomer_result()
6634 
    try:
6635 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6636 
    except TransactionServiceException, ex:
6637 
      result.ex = ex
6638 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6639 
    result.write(oprot)
6640 
    oprot.writeMessageEnd()
6641 
    oprot.trans.flush()
6642 
 
132 ashish 6643 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6644 
    args = getTransactionsForShoppingCartId_args()
6645 
    args.read(iprot)
6646 
    iprot.readMessageEnd()
6647 
    result = getTransactionsForShoppingCartId_result()
6648 
    try:
6649 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6650 
    except TransactionServiceException, ex:
6651 
      result.ex = ex
6652 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6653 
    result.write(oprot)
6654 
    oprot.writeMessageEnd()
6655 
    oprot.trans.flush()
6656 
 
94 ashish 6657 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6658 
    args = getTransactionStatus_args()
6659 
    args.read(iprot)
6660 
    iprot.readMessageEnd()
6661 
    result = getTransactionStatus_result()
6662 
    try:
6663 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6664 
    except TransactionServiceException, ex:
6665 
      result.ex = ex
6666 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6667 
    result.write(oprot)
6668 
    oprot.writeMessageEnd()
6669 
    oprot.trans.flush()
6670 
 
6671 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6672 
    args = changeTransactionStatus_args()
6673 
    args.read(iprot)
6674 
    iprot.readMessageEnd()
6675 
    result = changeTransactionStatus_result()
6676 
    try:
5527 anupam.sin 6677 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6678 
    except TransactionServiceException, ex:
6679 
      result.ex = ex
6680 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6681 
    result.write(oprot)
6682 
    oprot.writeMessageEnd()
6683 
    oprot.trans.flush()
6684 
 
1398 varun.gupt 6685 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6686 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6687 
    args.read(iprot)
6688 
    iprot.readMessageEnd()
1398 varun.gupt 6689 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6690 
    try:
1398 varun.gupt 6691 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6692 
    except TransactionServiceException, ex:
6693 
      result.ex = ex
1398 varun.gupt 6694 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6695 
    result.write(oprot)
6696 
    oprot.writeMessageEnd()
6697 
    oprot.trans.flush()
6698 
 
483 rajveer 6699 
  def process_getAllOrders(self, seqid, iprot, oprot):
6700 
    args = getAllOrders_args()
94 ashish 6701 
    args.read(iprot)
6702 
    iprot.readMessageEnd()
483 rajveer 6703 
    result = getAllOrders_result()
94 ashish 6704 
    try:
4801 anupam.sin 6705 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6706 
    except TransactionServiceException, ex:
6707 
      result.ex = ex
483 rajveer 6708 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6709 
    result.write(oprot)
6710 
    oprot.writeMessageEnd()
6711 
    oprot.trans.flush()
6712 
 
4133 chandransh 6713 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6714 
    args = getOrdersInBatch_args()
6715 
    args.read(iprot)
6716 
    iprot.readMessageEnd()
6717 
    result = getOrdersInBatch_result()
6718 
    try:
6719 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6720 
    except TransactionServiceException, ex:
6721 
      result.ex = ex
6722 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6723 
    result.write(oprot)
6724 
    oprot.writeMessageEnd()
6725 
    oprot.trans.flush()
6726 
 
6727 
  def process_getOrderCount(self, seqid, iprot, oprot):
6728 
    args = getOrderCount_args()
6729 
    args.read(iprot)
6730 
    iprot.readMessageEnd()
6731 
    result = getOrderCount_result()
6732 
    try:
6733 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6734 
    except TransactionServiceException, ex:
6735 
      result.ex = ex
6736 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
6740 
 
999 varun.gupt 6741 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6742 
    args = getOrdersByBillingDate_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = getOrdersByBillingDate_result()
6746 
    try:
6747 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6748 
    except TransactionServiceException, ex:
6749 
      result.ex = ex
6750 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
3427 chandransh 6755 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6756 
    args = getOrdersByShippingDate_args()
6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
6759 
    result = getOrdersByShippingDate_result()
6760 
    try:
3451 chandransh 6761 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6762 
    except TransactionServiceException, ex:
6763 
      result.ex = ex
6764 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6765 
    result.write(oprot)
6766 
    oprot.writeMessageEnd()
6767 
    oprot.trans.flush()
6768 
 
1382 varun.gupt 6769 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6770 
    args = getReturnableOrdersForCustomer_args()
6771 
    args.read(iprot)
6772 
    iprot.readMessageEnd()
6773 
    result = getReturnableOrdersForCustomer_result()
6774 
    try:
6775 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6776 
    except TransactionServiceException, ex:
6777 
      result.ex = ex
6778 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6779 
    result.write(oprot)
6780 
    oprot.writeMessageEnd()
6781 
    oprot.trans.flush()
6782 
 
6783 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6784 
    args = getCancellableOrdersForCustomer_args()
6785 
    args.read(iprot)
6786 
    iprot.readMessageEnd()
6787 
    result = getCancellableOrdersForCustomer_result()
6788 
    try:
6789 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6790 
    except TransactionServiceException, ex:
6791 
      result.ex = ex
6792 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6793 
    result.write(oprot)
6794 
    oprot.writeMessageEnd()
6795 
    oprot.trans.flush()
6796 
 
483 rajveer 6797 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6798 
    args = changeOrderStatus_args()
94 ashish 6799 
    args.read(iprot)
6800 
    iprot.readMessageEnd()
483 rajveer 6801 
    result = changeOrderStatus_result()
94 ashish 6802 
    try:
483 rajveer 6803 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6804 
    except TransactionServiceException, ex:
6805 
      result.ex = ex
483 rajveer 6806 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6807 
    result.write(oprot)
6808 
    oprot.writeMessageEnd()
6809 
    oprot.trans.flush()
6810 
 
483 rajveer 6811 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6812 
    args = getOrdersForTransaction_args()
94 ashish 6813 
    args.read(iprot)
6814 
    iprot.readMessageEnd()
483 rajveer 6815 
    result = getOrdersForTransaction_result()
94 ashish 6816 
    try:
1528 ankur.sing 6817 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6818 
    except TransactionServiceException, ex:
6819 
      result.ex = ex
483 rajveer 6820 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6821 
    result.write(oprot)
6822 
    oprot.writeMessageEnd()
6823 
    oprot.trans.flush()
6824 
 
483 rajveer 6825 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6826 
    args = getOrdersForCustomer_args()
94 ashish 6827 
    args.read(iprot)
6828 
    iprot.readMessageEnd()
483 rajveer 6829 
    result = getOrdersForCustomer_result()
94 ashish 6830 
    try:
3014 chandransh 6831 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6832 
    except TransactionServiceException, ex:
6833 
      result.ex = ex
483 rajveer 6834 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6835 
    result.write(oprot)
6836 
    oprot.writeMessageEnd()
6837 
    oprot.trans.flush()
6838 
 
483 rajveer 6839 
  def process_createOrder(self, seqid, iprot, oprot):
6840 
    args = createOrder_args()
94 ashish 6841 
    args.read(iprot)
6842 
    iprot.readMessageEnd()
483 rajveer 6843 
    result = createOrder_result()
94 ashish 6844 
    try:
483 rajveer 6845 
      result.success = self._handler.createOrder(args.order)
94 ashish 6846 
    except TransactionServiceException, ex:
6847 
      result.ex = ex
483 rajveer 6848 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6849 
    result.write(oprot)
6850 
    oprot.writeMessageEnd()
6851 
    oprot.trans.flush()
6852 
 
483 rajveer 6853 
  def process_getOrder(self, seqid, iprot, oprot):
6854 
    args = getOrder_args()
94 ashish 6855 
    args.read(iprot)
6856 
    iprot.readMessageEnd()
483 rajveer 6857 
    result = getOrder_result()
94 ashish 6858 
    try:
483 rajveer 6859 
      result.success = self._handler.getOrder(args.id)
94 ashish 6860 
    except TransactionServiceException, ex:
6861 
      result.ex = ex
483 rajveer 6862 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6863 
    result.write(oprot)
6864 
    oprot.writeMessageEnd()
6865 
    oprot.trans.flush()
6866 
 
483 rajveer 6867 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6868 
    args = getLineItemsForOrder_args()
94 ashish 6869 
    args.read(iprot)
6870 
    iprot.readMessageEnd()
483 rajveer 6871 
    result = getLineItemsForOrder_result()
94 ashish 6872 
    try:
483 rajveer 6873 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6874 
    except TransactionServiceException, ex:
6875 
      result.ex = ex
483 rajveer 6876 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6877 
    result.write(oprot)
6878 
    oprot.writeMessageEnd()
6879 
    oprot.trans.flush()
6880 
 
4999 phani.kuma 6881 
  def process_getOrderList(self, seqid, iprot, oprot):
6882 
    args = getOrderList_args()
6883 
    args.read(iprot)
6884 
    iprot.readMessageEnd()
6885 
    result = getOrderList_result()
6886 
    result.success = self._handler.getOrderList(args.order_ids)
6887 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6888 
    result.write(oprot)
6889 
    oprot.writeMessageEnd()
6890 
    oprot.trans.flush()
6891 
 
5386 phani.kuma 6892 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6893 
    args = getOrderListForVendor_args()
6894 
    args.read(iprot)
6895 
    iprot.readMessageEnd()
6896 
    result = getOrderListForVendor_result()
6897 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6898 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6899 
    result.write(oprot)
6900 
    oprot.writeMessageEnd()
6901 
    oprot.trans.flush()
6902 
 
1528 ankur.sing 6903 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6904 
    args = getOrderForCustomer_args()
6905 
    args.read(iprot)
6906 
    iprot.readMessageEnd()
6907 
    result = getOrderForCustomer_result()
6908 
    try:
6909 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6910 
    except TransactionServiceException, ex:
6911 
      result.ex = ex
6912 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6913 
    result.write(oprot)
6914 
    oprot.writeMessageEnd()
6915 
    oprot.trans.flush()
6916 
 
3064 chandransh 6917 
  def process_getAlerts(self, seqid, iprot, oprot):
6918 
    args = getAlerts_args()
6919 
    args.read(iprot)
6920 
    iprot.readMessageEnd()
6921 
    result = getAlerts_result()
4444 rajveer 6922 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6923 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6924 
    result.write(oprot)
6925 
    oprot.writeMessageEnd()
6926 
    oprot.trans.flush()
6927 
 
4394 rajveer 6928 
  def process_addAlert(self, seqid, iprot, oprot):
6929 
    args = addAlert_args()
3064 chandransh 6930 
    args.read(iprot)
6931 
    iprot.readMessageEnd()
4394 rajveer 6932 
    result = addAlert_result()
4444 rajveer 6933 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6934 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
6938 
 
4444 rajveer 6939 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6940 
    args = markAlertsAsSeen_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = markAlertsAsSeen_result()
6944 
    self._handler.markAlertsAsSeen(args.warehouseId)
6945 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6946 
    result.write(oprot)
6947 
    oprot.writeMessageEnd()
6948 
    oprot.trans.flush()
6949 
 
3064 chandransh 6950 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6951 
    args = getValidOrderCount_args()
6952 
    args.read(iprot)
6953 
    iprot.readMessageEnd()
6954 
    result = getValidOrderCount_result()
6955 
    result.success = self._handler.getValidOrderCount()
6956 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6957 
    result.write(oprot)
6958 
    oprot.writeMessageEnd()
6959 
    oprot.trans.flush()
6960 
 
6961 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6962 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6963 
    args.read(iprot)
6964 
    iprot.readMessageEnd()
6965 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6966 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6967 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6968 
    result.write(oprot)
6969 
    oprot.writeMessageEnd()
6970 
    oprot.trans.flush()
6971 
 
6972 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6973 
    args = getValidOrdersAmountRange_args()
6974 
    args.read(iprot)
6975 
    iprot.readMessageEnd()
6976 
    result = getValidOrdersAmountRange_result()
6977 
    result.success = self._handler.getValidOrdersAmountRange()
6978 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
6983 
  def process_getValidOrders(self, seqid, iprot, oprot):
6984 
    args = getValidOrders_args()
6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
6987 
    result = getValidOrders_result()
5874 rajveer 6988 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6989 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
6993 
 
1220 chandransh 6994 
  def process_batchOrders(self, seqid, iprot, oprot):
6995 
    args = batchOrders_args()
6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
6998 
    result = batchOrders_result()
6999 
    try:
7000 
      result.success = self._handler.batchOrders(args.warehouseId)
7001 
    except TransactionServiceException, ex:
7002 
      result.ex = ex
7003 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
1208 chandransh 7008 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7009 
    args = markOrderAsOutOfStock_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = markOrderAsOutOfStock_result()
7013 
    try:
7014 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7015 
    except TransactionServiceException, ex:
7016 
      result.ex = ex
7017 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7018 
    result.write(oprot)
7019 
    oprot.writeMessageEnd()
7020 
    oprot.trans.flush()
7021 
 
3064 chandransh 7022 
  def process_verifyOrder(self, seqid, iprot, oprot):
7023 
    args = verifyOrder_args()
759 chandransh 7024 
    args.read(iprot)
7025 
    iprot.readMessageEnd()
3064 chandransh 7026 
    result = verifyOrder_result()
759 chandransh 7027 
    try:
3064 chandransh 7028 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7029 
    except TransactionServiceException, ex:
7030 
      result.ex = ex
3064 chandransh 7031 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
3064 chandransh 7036 
  def process_acceptOrder(self, seqid, iprot, oprot):
7037 
    args = acceptOrder_args()
1113 chandransh 7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
3064 chandransh 7040 
    result = acceptOrder_result()
1113 chandransh 7041 
    try:
3064 chandransh 7042 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
3064 chandransh 7045 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
3064 chandransh 7050 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7051 
    args = addBillingDetails_args()
1135 chandransh 7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
3064 chandransh 7054 
    result = addBillingDetails_result()
1135 chandransh 7055 
    try:
5110 mandeep.dh 7056 
      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 7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
3064 chandransh 7059 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
7063 
 
4579 rajveer 7064 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7065 
    args = addInvoiceNumber_args()
7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
7068 
    result = addInvoiceNumber_result()
7069 
    try:
4763 rajveer 7070 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
7073 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
7077 
 
4410 rajveer 7078 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7079 
    args = markOrdersAsShippedFromWarehouse_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = markOrdersAsShippedFromWarehouse_result()
7083 
    try:
4789 rajveer 7084 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7085 
    except TransactionServiceException, ex:
7086 
      result.ex = ex
7087 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
7091 
 
5676 rajveer 7092 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7093 
    args = markOrdersAsReturnedFromStore_args()
7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
7096 
    result = markOrdersAsReturnedFromStore_result()
7097 
    try:
5713 rajveer 7098 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
3064 chandransh 7106 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7107 
    args = markOrdersAsPickedUp_args()
304 ashish 7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
3064 chandransh 7110 
    result = markOrdersAsPickedUp_result()
7111 
    try:
4910 phani.kuma 7112 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7113 
    except TransactionServiceException, ex:
7114 
      result.ex = ex
7115 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
94 ashish 7119 
 
4910 phani.kuma 7120 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7121 
    args = getOrdersNotPickedUp_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getOrdersNotPickedUp_result()
7125 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7126 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
3064 chandransh 7131 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7132 
    args = markOrdersAsDelivered_args()
304 ashish 7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
3064 chandransh 7135 
    result = markOrdersAsDelivered_result()
7136 
    try:
7137 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7138 
    except TransactionServiceException, ex:
7139 
      result.ex = ex
7140 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7141 
    result.write(oprot)
7142 
    oprot.writeMessageEnd()
7143 
    oprot.trans.flush()
7144 
 
4910 phani.kuma 7145 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7146 
    args = markAsRTOrders_args()
1596 ankur.sing 7147 
    args.read(iprot)
7148 
    iprot.readMessageEnd()
4910 phani.kuma 7149 
    result = markAsRTOrders_result()
3064 chandransh 7150 
    try:
4910 phani.kuma 7151 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7152 
    except TransactionServiceException, ex:
7153 
      result.ex = ex
4910 phani.kuma 7154 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7155 
    result.write(oprot)
7156 
    oprot.writeMessageEnd()
7157 
    oprot.trans.flush()
304 ashish 7158 
 
4910 phani.kuma 7159 
  def process_getRTOrders(self, seqid, iprot, oprot):
7160 
    args = getRTOrders_args()
7161 
    args.read(iprot)
7162 
    iprot.readMessageEnd()
7163 
    result = getRTOrders_result()
7164 
    result.success = self._handler.getRTOrders(args.providerId)
7165 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7166 
    result.write(oprot)
7167 
    oprot.writeMessageEnd()
7168 
    oprot.trans.flush()
7169 
 
3064 chandransh 7170 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7171 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7172 
    args.read(iprot)
7173 
    iprot.readMessageEnd()
3064 chandransh 7174 
    result = updateNonDeliveryReason_result()
7175 
    try:
4910 phani.kuma 7176 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7177 
    except TransactionServiceException, ex:
7178 
      result.ex = ex
7179 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7180 
    result.write(oprot)
7181 
    oprot.writeMessageEnd()
7182 
    oprot.trans.flush()
1596 ankur.sing 7183 
 
4910 phani.kuma 7184 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7185 
    args = getNonDeliveredOrdersbyCourier_args()
7186 
    args.read(iprot)
7187 
    iprot.readMessageEnd()
7188 
    result = getNonDeliveredOrdersbyCourier_result()
7189 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7190 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7191 
    result.write(oprot)
7192 
    oprot.writeMessageEnd()
7193 
    oprot.trans.flush()
7194 
 
7195 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7196 
    args = markOrdersAsLocalConnected_args()
7197 
    args.read(iprot)
7198 
    iprot.readMessageEnd()
7199 
    result = markOrdersAsLocalConnected_result()
7200 
    try:
7201 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7202 
    except TransactionServiceException, ex:
7203 
      result.ex = ex
7204 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7205 
    result.write(oprot)
7206 
    oprot.writeMessageEnd()
7207 
    oprot.trans.flush()
7208 
 
7209 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7210 
    args = getOrdersNotLocalConnected_args()
7211 
    args.read(iprot)
7212 
    iprot.readMessageEnd()
7213 
    result = getOrdersNotLocalConnected_result()
7214 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7215 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
7219 
 
7220 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7221 
    args = markOrdersAsDestinationCityReached_args()
7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
7224 
    result = markOrdersAsDestinationCityReached_result()
7225 
    try:
7226 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7227 
    except TransactionServiceException, ex:
7228 
      result.ex = ex
7229 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
7234 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7235 
    args = markOrdersAsFirstDeliveryAttempted_args()
7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
7238 
    result = markOrdersAsFirstDeliveryAttempted_result()
7239 
    try:
7240 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
7243 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
7247 
 
3064 chandransh 7248 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7249 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
3064 chandransh 7252 
    result = getUndeliveredOrders_result()
7253 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7254 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7255 
    result.write(oprot)
7256 
    oprot.writeMessageEnd()
7257 
    oprot.trans.flush()
7258 
 
4783 phani.kuma 7259 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7260 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7261 
    args.read(iprot)
7262 
    iprot.readMessageEnd()
7263 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7264 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7265 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7266 
    result.write(oprot)
7267 
    oprot.writeMessageEnd()
7268 
    oprot.trans.flush()
7269 
 
2536 chandransh 7270 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7271 
    args = toggleDOAFlag_args()
7272 
    args.read(iprot)
7273 
    iprot.readMessageEnd()
7274 
    result = toggleDOAFlag_result()
7275 
    try:
7276 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7277 
    except TransactionServiceException, ex:
7278 
      result.ex = ex
7279 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7280 
    result.write(oprot)
7281 
    oprot.writeMessageEnd()
7282 
    oprot.trans.flush()
1886 ankur.sing 7283 
 
4712 rajveer 7284 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7285 
    args = markOrderAsDelivered_args()
7286 
    args.read(iprot)
7287 
    iprot.readMessageEnd()
7288 
    result = markOrderAsDelivered_result()
7289 
    try:
7290 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7291 
    except TransactionServiceException, ex:
7292 
      result.ex = ex
7293 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7294 
    result.write(oprot)
7295 
    oprot.writeMessageEnd()
7296 
    oprot.trans.flush()
7297 
 
5553 rajveer 7298 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7299 
    args = markOrderAsReceivedAtStore_args()
7300 
    args.read(iprot)
7301 
    iprot.readMessageEnd()
7302 
    result = markOrderAsReceivedAtStore_result()
7303 
    try:
7304 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7305 
    except TransactionServiceException, ex:
7306 
      result.ex = ex
7307 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7308 
    result.write(oprot)
7309 
    oprot.writeMessageEnd()
7310 
    oprot.trans.flush()
7311 
 
4454 rajveer 7312 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7313 
    args = markOrderDoaRequestReceived_args()
7314 
    args.read(iprot)
7315 
    iprot.readMessageEnd()
7316 
    result = markOrderDoaRequestReceived_result()
7317 
    try:
7318 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7319 
    except TransactionServiceException, ex:
7320 
      result.ex = ex
7321 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
7326 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7327 
    args = markOrderDoaRequestAuthorized_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = markOrderDoaRequestAuthorized_result()
7331 
    try:
7332 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7333 
    except TransactionServiceException, ex:
7334 
      result.ex = ex
7335 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
4488 rajveer 7340 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7341 
    args = markOrderReturnRequestReceived_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = markOrderReturnRequestReceived_result()
7345 
    try:
7346 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7347 
    except TransactionServiceException, ex:
7348 
      result.ex = ex
7349 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7350 
    result.write(oprot)
7351 
    oprot.writeMessageEnd()
7352 
    oprot.trans.flush()
7353 
 
7354 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7355 
    args = markOrderReturnRequestAuthorized_args()
7356 
    args.read(iprot)
7357 
    iprot.readMessageEnd()
7358 
    result = markOrderReturnRequestAuthorized_result()
7359 
    try:
7360 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7361 
    except TransactionServiceException, ex:
7362 
      result.ex = ex
7363 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
7367 
 
2536 chandransh 7368 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7369 
    args = requestPickupNumber_args()
7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
7372 
    result = requestPickupNumber_result()
7373 
    try:
4579 rajveer 7374 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7375 
    except TransactionServiceException, ex:
7376 
      result.ex = ex
7377 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7378 
    result.write(oprot)
7379 
    oprot.writeMessageEnd()
7380 
    oprot.trans.flush()
7381 
 
7382 
  def process_authorizePickup(self, seqid, iprot, oprot):
7383 
    args = authorizePickup_args()
7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
7386 
    result = authorizePickup_result()
7387 
    try:
4602 rajveer 7388 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7389 
    except TransactionServiceException, ex:
7390 
      result.ex = ex
7391 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7392 
    result.write(oprot)
7393 
    oprot.writeMessageEnd()
7394 
    oprot.trans.flush()
7395 
 
2764 chandransh 7396 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7397 
    args = markDoasAsPickedUp_args()
7398 
    args.read(iprot)
7399 
    iprot.readMessageEnd()
7400 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7401 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7402 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
4910 phani.kuma 7407 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7408 
    args = getDoasNotPickedUp_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = getDoasNotPickedUp_result()
7412 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7413 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7414 
    result.write(oprot)
7415 
    oprot.writeMessageEnd()
7416 
    oprot.trans.flush()
7417 
 
4741 phani.kuma 7418 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7419 
    args = markReturnOrdersAsPickedUp_args()
7420 
    args.read(iprot)
7421 
    iprot.readMessageEnd()
7422 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7423 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7424 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7425 
    result.write(oprot)
7426 
    oprot.writeMessageEnd()
7427 
    oprot.trans.flush()
7428 
 
4910 phani.kuma 7429 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7430 
    args = getReturnOrdersNotPickedUp_args()
7431 
    args.read(iprot)
7432 
    iprot.readMessageEnd()
7433 
    result = getReturnOrdersNotPickedUp_result()
7434 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7435 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7436 
    result.write(oprot)
7437 
    oprot.writeMessageEnd()
7438 
    oprot.trans.flush()
7439 
 
2616 chandransh 7440 
  def process_receiveReturn(self, seqid, iprot, oprot):
7441 
    args = receiveReturn_args()
2591 chandransh 7442 
    args.read(iprot)
7443 
    iprot.readMessageEnd()
2616 chandransh 7444 
    result = receiveReturn_result()
2591 chandransh 7445 
    try:
4479 rajveer 7446 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7447 
    except TransactionServiceException, ex:
7448 
      result.ex = ex
2616 chandransh 7449 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7450 
    result.write(oprot)
7451 
    oprot.writeMessageEnd()
7452 
    oprot.trans.flush()
2536 chandransh 7453 
 
2591 chandransh 7454 
  def process_validateDoa(self, seqid, iprot, oprot):
7455 
    args = validateDoa_args()
7456 
    args.read(iprot)
7457 
    iprot.readMessageEnd()
7458 
    result = validateDoa_result()
7459 
    try:
7460 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7461 
    except TransactionServiceException, ex:
7462 
      result.ex = ex
7463 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7464 
    result.write(oprot)
7465 
    oprot.writeMessageEnd()
7466 
    oprot.trans.flush()
7467 
 
4495 rajveer 7468 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7469 
    args = validateReturnProduct_args()
7470 
    args.read(iprot)
7471 
    iprot.readMessageEnd()
7472 
    result = validateReturnProduct_result()
7473 
    try:
7474 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7475 
    except TransactionServiceException, ex:
7476 
      result.ex = ex
7477 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7478 
    result.write(oprot)
7479 
    oprot.writeMessageEnd()
7480 
    oprot.trans.flush()
7481 
 
2616 chandransh 7482 
  def process_reshipOrder(self, seqid, iprot, oprot):
7483 
    args = reshipOrder_args()
7484 
    args.read(iprot)
7485 
    iprot.readMessageEnd()
7486 
    result = reshipOrder_result()
7487 
    try:
7488 
      result.success = self._handler.reshipOrder(args.orderId)
7489 
    except TransactionServiceException, ex:
7490 
      result.ex = ex
7491 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
2591 chandransh 7495 
 
2616 chandransh 7496 
  def process_refundOrder(self, seqid, iprot, oprot):
7497 
    args = refundOrder_args()
7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
7500 
    result = refundOrder_result()
7501 
    try:
3226 chandransh 7502 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7503 
    except TransactionServiceException, ex:
7504 
      result.ex = ex
7505 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
7509 
 
2690 chandransh 7510 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7511 
    args = getReturnOrders_args()
7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
7514 
    result = getReturnOrders_result()
7515 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7516 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
2616 chandransh 7520 
 
5481 phani.kuma 7521 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7522 
    args = getAllReturnOrders_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = getAllReturnOrders_result()
7526 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7527 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7528 
    result.write(oprot)
7529 
    oprot.writeMessageEnd()
7530 
    oprot.trans.flush()
7531 
 
2700 chandransh 7532 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7533 
    args = getReturnOrder_args()
7534 
    args.read(iprot)
7535 
    iprot.readMessageEnd()
7536 
    result = getReturnOrder_result()
7537 
    try:
7538 
      result.success = self._handler.getReturnOrder(args.id)
7539 
    except TransactionServiceException, ex:
7540 
      result.ex = ex
7541 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7542 
    result.write(oprot)
7543 
    oprot.writeMessageEnd()
7544 
    oprot.trans.flush()
7545 
 
2690 chandransh 7546 
  def process_processReturn(self, seqid, iprot, oprot):
7547 
    args = processReturn_args()
7548 
    args.read(iprot)
7549 
    iprot.readMessageEnd()
7550 
    result = processReturn_result()
7551 
    try:
7552 
      self._handler.processReturn(args.returnOrderId)
7553 
    except TransactionServiceException, ex:
7554 
      result.ex = ex
7555 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7556 
    result.write(oprot)
7557 
    oprot.writeMessageEnd()
7558 
    oprot.trans.flush()
7559 
 
3451 chandransh 7560 
  def process_updateWeight(self, seqid, iprot, oprot):
7561 
    args = updateWeight_args()
7562 
    args.read(iprot)
7563 
    iprot.readMessageEnd()
7564 
    result = updateWeight_result()
7565 
    try:
7566 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7567 
    except TransactionServiceException, ex:
7568 
      result.ex = ex
7569 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7570 
    result.write(oprot)
7571 
    oprot.writeMessageEnd()
7572 
    oprot.trans.flush()
2819 chandransh 7573 
 
3469 chandransh 7574 
  def process_changeItem(self, seqid, iprot, oprot):
7575 
    args = changeItem_args()
7576 
    args.read(iprot)
7577 
    iprot.readMessageEnd()
7578 
    result = changeItem_result()
7579 
    try:
7580 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7581 
    except TransactionServiceException, ex:
7582 
      result.ex = ex
7583 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
3451 chandransh 7587 
 
3469 chandransh 7588 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7589 
    args = shiftToWarehouse_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = shiftToWarehouse_result()
7593 
    try:
7594 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7595 
    except TransactionServiceException, ex:
7596 
      result.ex = ex
7597 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
7601 
 
3553 chandransh 7602 
  def process_addDelayReason(self, seqid, iprot, oprot):
7603 
    args = addDelayReason_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = addDelayReason_result()
7607 
    try:
4647 rajveer 7608 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7609 
    except TransactionServiceException, ex:
7610 
      result.ex = ex
7611 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7612 
    result.write(oprot)
7613 
    oprot.writeMessageEnd()
7614 
    oprot.trans.flush()
3469 chandransh 7615 
 
3956 chandransh 7616 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7617 
    args = reconcileCodCollection_args()
7618 
    args.read(iprot)
7619 
    iprot.readMessageEnd()
7620 
    result = reconcileCodCollection_result()
7621 
    try:
7622 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7623 
    except TransactionServiceException, ex:
7624 
      result.ex = ex
7625 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7626 
    result.write(oprot)
7627 
    oprot.writeMessageEnd()
7628 
    oprot.trans.flush()
3553 chandransh 7629 
 
4008 mandeep.dh 7630 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7631 
    args = getTransactionsRequiringExtraProcessing_args()
7632 
    args.read(iprot)
7633 
    iprot.readMessageEnd()
7634 
    result = getTransactionsRequiringExtraProcessing_result()
7635 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7636 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7637 
    result.write(oprot)
7638 
    oprot.writeMessageEnd()
7639 
    oprot.trans.flush()
3956 chandransh 7640 
 
4008 mandeep.dh 7641 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7642 
    args = markTransactionAsProcessed_args()
7643 
    args.read(iprot)
7644 
    iprot.readMessageEnd()
7645 
    result = markTransactionAsProcessed_result()
7646 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7647 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7648 
    result.write(oprot)
7649 
    oprot.writeMessageEnd()
7650 
    oprot.trans.flush()
7651 
 
4018 chandransh 7652 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7653 
    args = getItemWiseRiskyOrdersCount_args()
7654 
    args.read(iprot)
7655 
    iprot.readMessageEnd()
7656 
    result = getItemWiseRiskyOrdersCount_result()
7657 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7658 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7659 
    result.write(oprot)
7660 
    oprot.writeMessageEnd()
7661 
    oprot.trans.flush()
4008 mandeep.dh 7662 
 
4295 varun.gupt 7663 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7664 
    args = getOrdersForItemIds_args()
7665 
    args.read(iprot)
7666 
    iprot.readMessageEnd()
7667 
    result = getOrdersForItemIds_result()
7668 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7669 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
4247 rajveer 7674 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7675 
    args = markOrderCancellationRequestReceived_args()
7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
7678 
    result = markOrderCancellationRequestReceived_result()
7679 
    try:
7680 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7681 
    except TransactionServiceException, ex:
7682 
      result.ex = ex
7683 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
4018 chandransh 7687 
 
4247 rajveer 7688 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7689 
    args = markOrderCancellationRequestConfirmed_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = markOrderCancellationRequestConfirmed_result()
7693 
    try:
7694 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7695 
    except TransactionServiceException, ex:
7696 
      result.ex = ex
7697 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7698 
    result.write(oprot)
7699 
    oprot.writeMessageEnd()
7700 
    oprot.trans.flush()
7701 
 
7702 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7703 
    args = markOrderCancellationRequestDenied_args()
7704 
    args.read(iprot)
7705 
    iprot.readMessageEnd()
7706 
    result = markOrderCancellationRequestDenied_result()
7707 
    try:
7708 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7709 
    except TransactionServiceException, ex:
7710 
      result.ex = ex
7711 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
7715 
 
4258 rajveer 7716 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7717 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
4258 rajveer 7720 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7721 
    try:
4258 rajveer 7722 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7723 
    except TransactionServiceException, ex:
7724 
      result.ex = ex
4258 rajveer 7725 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7729 
 
4259 anupam.sin 7730 
  def process_refundTransaction(self, seqid, iprot, oprot):
7731 
    args = refundTransaction_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = refundTransaction_result()
7735 
    try:
7736 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7737 
    except TransactionServiceException, ex:
7738 
      result.ex = ex
7739 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
4247 rajveer 7743 
 
4324 mandeep.dh 7744 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7745 
    args = updateShipmentAddress_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = updateShipmentAddress_result()
7749 
    try:
7750 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7751 
    except TransactionServiceException, ex:
7752 
      result.ex = ex
7753 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
4285 rajveer 7758 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7759 
    args = acceptOrdersForItemId_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = acceptOrdersForItemId_result()
7763 
    try:
7764 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7765 
    except TransactionServiceException, ex:
7766 
      result.ex = ex
7767 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
4259 anupam.sin 7771 
 
4303 rajveer 7772 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7773 
    args = markOrdersAsPORaised_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = markOrdersAsPORaised_result()
7777 
    try:
4369 rajveer 7778 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7779 
    except TransactionServiceException, ex:
7780 
      result.ex = ex
7781 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
4285 rajveer 7785 
 
4303 rajveer 7786 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7787 
    args = markOrdersAsReversalInitiated_args()
7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
7790 
    result = markOrdersAsReversalInitiated_result()
7791 
    try:
4369 rajveer 7792 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7793 
    except TransactionServiceException, ex:
7794 
      result.ex = ex
7795 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
7800 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7801 
    args = markOrdersAsNotAvailabke_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = markOrdersAsNotAvailabke_result()
7805 
    try:
4369 rajveer 7806 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7807 
    except TransactionServiceException, ex:
7808 
      result.ex = ex
7809 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
7813 
 
4369 rajveer 7814 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7815 
    args = markOrdersAsTimeout_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = markOrdersAsTimeout_result()
7819 
    try:
7820 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7821 
    except TransactionServiceException, ex:
7822 
      result.ex = ex
7823 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7824 
    result.write(oprot)
7825 
    oprot.writeMessageEnd()
7826 
    oprot.trans.flush()
4303 rajveer 7827 
 
4662 rajveer 7828 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7829 
    args = markOrderAsLostInTransit_args()
7830 
    args.read(iprot)
7831 
    iprot.readMessageEnd()
7832 
    result = markOrderAsLostInTransit_result()
7833 
    try:
7834 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7835 
    except TransactionServiceException, ex:
7836 
      result.ex = ex
7837 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7838 
    result.write(oprot)
7839 
    oprot.writeMessageEnd()
7840 
    oprot.trans.flush()
7841 
 
4386 anupam.sin 7842 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7843 
    args = getOrderForAwb_args()
7844 
    args.read(iprot)
7845 
    iprot.readMessageEnd()
7846 
    result = getOrderForAwb_result()
7847 
    try:
7848 
      result.success = self._handler.getOrderForAwb(args.awb)
7849 
    except TransactionServiceException, ex:
7850 
      result.ex = ex
7851 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
4369 rajveer 7855 
 
4506 phani.kuma 7856 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7857 
    args = getOrdersForProviderForStatus_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = getOrdersForProviderForStatus_result()
7861 
    try:
4910 phani.kuma 7862 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7863 
    except TransactionServiceException, ex:
7864 
      result.ex = ex
7865 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7866 
    result.write(oprot)
7867 
    oprot.writeMessageEnd()
7868 
    oprot.trans.flush()
4386 anupam.sin 7869 
 
4600 varun.gupt 7870 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7871 
    args = getBilledOrdersForVendor_args()
7872 
    args.read(iprot)
7873 
    iprot.readMessageEnd()
7874 
    result = getBilledOrdersForVendor_result()
7875 
    try:
7876 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7877 
    except TransactionServiceException, ex:
7878 
      result.ex = ex
7879 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7880 
    result.write(oprot)
7881 
    oprot.writeMessageEnd()
7882 
    oprot.trans.flush()
4506 phani.kuma 7883 
 
4607 rajveer 7884 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7885 
    args = getSlippedSippingDateOrders_args()
7886 
    args.read(iprot)
7887 
    iprot.readMessageEnd()
7888 
    result = getSlippedSippingDateOrders_result()
7889 
    try:
7890 
      result.success = self._handler.getSlippedSippingDateOrders()
7891 
    except TransactionServiceException, ex:
7892 
      result.ex = ex
7893 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7894 
    result.write(oprot)
7895 
    oprot.writeMessageEnd()
7896 
    oprot.trans.flush()
7897 
 
4709 rajveer 7898 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7899 
    args = getCancelledOrders_args()
7900 
    args.read(iprot)
7901 
    iprot.readMessageEnd()
7902 
    result = getCancelledOrders_result()
7903 
    try:
7904 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7905 
    except TransactionServiceException, ex:
7906 
      result.ex = ex
7907 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7908 
    result.write(oprot)
7909 
    oprot.writeMessageEnd()
7910 
    oprot.trans.flush()
7911 
 
4600 varun.gupt 7912 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7913 
    args = saveBluedartSettlements_args()
7914 
    args.read(iprot)
7915 
    iprot.readMessageEnd()
7916 
    result = saveBluedartSettlements_result()
7917 
    try:
7918 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7919 
    except TransactionServiceException, ex:
7920 
      result.ex = ex
7921 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7922 
    result.write(oprot)
7923 
    oprot.writeMessageEnd()
7924 
    oprot.trans.flush()
7925 
 
7926 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7927 
    args = savePaymentSettlements_args()
7928 
    args.read(iprot)
7929 
    iprot.readMessageEnd()
7930 
    result = savePaymentSettlements_result()
7931 
    try:
4905 varun.gupt 7932 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7933 
    except TransactionServiceException, ex:
7934 
      result.ex = ex
7935 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
7939 
 
7940 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7941 
    args = saveEBSSettlementSummary_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = saveEBSSettlementSummary_result()
7945 
    try:
7946 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7947 
    except TransactionServiceException, ex:
7948 
      result.ex = ex
7949 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7950 
    result.write(oprot)
7951 
    oprot.writeMessageEnd()
7952 
    oprot.trans.flush()
7953 
 
5386 phani.kuma 7954 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7955 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7956 
    args.read(iprot)
7957 
    iprot.readMessageEnd()
5386 phani.kuma 7958 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7959 
    try:
5386 phani.kuma 7960 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7961 
    except TransactionServiceException, ex:
7962 
      result.ex = ex
5386 phani.kuma 7963 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
7967 
 
5386 phani.kuma 7968 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7969 
    args = getSettlementForCod_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = getSettlementForCod_result()
7973 
    try:
7974 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7975 
    except TransactionServiceException, ex:
7976 
      result.ex = ex
7977 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7978 
    result.write(oprot)
7979 
    oprot.writeMessageEnd()
7980 
    oprot.trans.flush()
7981 
 
4600 varun.gupt 7982 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7983 
    args = getEBSSettlementSummaries_args()
7984 
    args.read(iprot)
7985 
    iprot.readMessageEnd()
7986 
    result = getEBSSettlementSummaries_result()
7987 
    try:
7988 
      result.success = self._handler.getEBSSettlementSummaries()
7989 
    except TransactionServiceException, ex:
7990 
      result.ex = ex
7991 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7992 
    result.write(oprot)
7993 
    oprot.writeMessageEnd()
7994 
    oprot.trans.flush()
7995 
 
7996 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7997 
    args = markEBSSettlementUploaded_args()
7998 
    args.read(iprot)
7999 
    iprot.readMessageEnd()
8000 
    result = markEBSSettlementUploaded_result()
8001 
    try:
8002 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8003 
    except TransactionServiceException, ex:
8004 
      result.ex = ex
8005 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8006 
    result.write(oprot)
8007 
    oprot.writeMessageEnd()
8008 
    oprot.trans.flush()
8009 
 
8010 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8011 
    args = getEBSSettlementDate_args()
8012 
    args.read(iprot)
8013 
    iprot.readMessageEnd()
8014 
    result = getEBSSettlementDate_result()
8015 
    try:
8016 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8017 
    except TransactionServiceException, ex:
8018 
      result.ex = ex
8019 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8020 
    result.write(oprot)
8021 
    oprot.writeMessageEnd()
8022 
    oprot.trans.flush()
8023 
 
4715 varun.gupt 8024 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8025 
    args = getSettlementsByDate_args()
8026 
    args.read(iprot)
8027 
    iprot.readMessageEnd()
8028 
    result = getSettlementsByDate_result()
8029 
    try:
8030 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8031 
    except TransactionServiceException, ex:
8032 
      result.ex = ex
8033 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8034 
    result.write(oprot)
8035 
    oprot.writeMessageEnd()
8036 
    oprot.trans.flush()
4600 varun.gupt 8037 
 
4715 varun.gupt 8038 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8039 
    args = getReshippedOrderIds_args()
8040 
    args.read(iprot)
8041 
    iprot.readMessageEnd()
8042 
    result = getReshippedOrderIds_result()
8043 
    try:
8044 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8045 
    except TransactionServiceException, ex:
8046 
      result.ex = ex
8047 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8048 
    result.write(oprot)
8049 
    oprot.writeMessageEnd()
8050 
    oprot.trans.flush()
8051 
 
5481 phani.kuma 8052 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8053 
    args = getBilledOrders_args()
4875 varun.gupt 8054 
    args.read(iprot)
8055 
    iprot.readMessageEnd()
5481 phani.kuma 8056 
    result = getBilledOrders_result()
4875 varun.gupt 8057 
    try:
5481 phani.kuma 8058 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8059 
    except TransactionServiceException, ex:
8060 
      result.ex = ex
5481 phani.kuma 8061 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8062 
    result.write(oprot)
8063 
    oprot.writeMessageEnd()
8064 
    oprot.trans.flush()
4757 mandeep.dh 8065 
 
5031 varun.gupt 8066 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8067 
    args = getStatusDistributionOfOrders_args()
8068 
    args.read(iprot)
8069 
    iprot.readMessageEnd()
8070 
    result = getStatusDistributionOfOrders_result()
8071 
    try:
8072 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8073 
    except TransactionServiceException, ex:
8074 
      result.ex = ex
8075 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8076 
    result.write(oprot)
8077 
    oprot.writeMessageEnd()
8078 
    oprot.trans.flush()
4875 varun.gupt 8079 
 
5067 varun.gupt 8080 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8081 
    args = getOrderIdsForStatus_args()
8082 
    args.read(iprot)
8083 
    iprot.readMessageEnd()
8084 
    result = getOrderIdsForStatus_result()
8085 
    try:
8086 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8087 
    except TransactionServiceException, ex:
8088 
      result.ex = ex
8089 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8090 
    result.write(oprot)
8091 
    oprot.writeMessageEnd()
8092 
    oprot.trans.flush()
5031 varun.gupt 8093 
 
5348 anupam.sin 8094 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8095 
    args = updateCODAgent_args()
8096 
    args.read(iprot)
8097 
    iprot.readMessageEnd()
8098 
    result = updateCODAgent_result()
8099 
    try:
8100 
      self._handler.updateCODAgent(args.agent, args.orderId)
8101 
    except TransactionServiceException, ex:
8102 
      result.ex = ex
8103 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8104 
    result.write(oprot)
8105 
    oprot.writeMessageEnd()
8106 
    oprot.trans.flush()
8107 
 
5099 varun.gupt 8108 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8109 
    args = updateOrderAsPaidToVendor_args()
8110 
    args.read(iprot)
8111 
    iprot.readMessageEnd()
8112 
    result = updateOrderAsPaidToVendor_result()
8113 
    try:
8114 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8115 
    except TransactionServiceException, ex:
8116 
      result.ex = ex
8117 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8118 
    result.write(oprot)
8119 
    oprot.writeMessageEnd()
8120 
    oprot.trans.flush()
5067 varun.gupt 8121 
 
5386 phani.kuma 8122 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8123 
    args = updateOrderOnlyAsPaidToVendor_args()
8124 
    args.read(iprot)
8125 
    iprot.readMessageEnd()
8126 
    result = updateOrderOnlyAsPaidToVendor_result()
8127 
    try:
8128 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8129 
    except TransactionServiceException, ex:
8130 
      result.ex = ex
8131 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8132 
    result.write(oprot)
8133 
    oprot.writeMessageEnd()
8134 
    oprot.trans.flush()
8135 
 
5208 varun.gupt 8136 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8137 
    args = getRefundedOrdersMarkedPaid_args()
8138 
    args.read(iprot)
8139 
    iprot.readMessageEnd()
8140 
    result = getRefundedOrdersMarkedPaid_result()
8141 
    try:
8142 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8143 
    except TransactionServiceException, ex:
8144 
      result.ex = ex
8145 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8146 
    result.write(oprot)
8147 
    oprot.writeMessageEnd()
8148 
    oprot.trans.flush()
5099 varun.gupt 8149 
 
5447 anupam.sin 8150 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8151 
    args = getAllVerificationAgents_args()
8152 
    args.read(iprot)
8153 
    iprot.readMessageEnd()
8154 
    result = getAllVerificationAgents_result()
8155 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8156 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8157 
    result.write(oprot)
8158 
    oprot.writeMessageEnd()
8159 
    oprot.trans.flush()
5208 varun.gupt 8160 
 
5527 anupam.sin 8161 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8162 
    args = getAllAttributesForOrderId_args()
8163 
    args.read(iprot)
8164 
    iprot.readMessageEnd()
8165 
    result = getAllAttributesForOrderId_result()
8166 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8167 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8168 
    result.write(oprot)
8169 
    oprot.writeMessageEnd()
8170 
    oprot.trans.flush()
5447 anupam.sin 8171 
 
5676 rajveer 8172 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8173 
    args = setOrderAttributes_args()
8174 
    args.read(iprot)
8175 
    iprot.readMessageEnd()
8176 
    result = setOrderAttributes_result()
8177 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8178 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8179 
    result.write(oprot)
8180 
    oprot.writeMessageEnd()
8181 
    oprot.trans.flush()
8182 
 
5527 anupam.sin 8183 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8184 
    args = setOrderAttributeForTransaction_args()
8185 
    args.read(iprot)
8186 
    iprot.readMessageEnd()
8187 
    result = setOrderAttributeForTransaction_result()
8188 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8189 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8190 
    result.write(oprot)
8191 
    oprot.writeMessageEnd()
8192 
    oprot.trans.flush()
8193 
 
5553 rajveer 8194 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8195 
    args = getReceivePendingOrders_args()
8196 
    args.read(iprot)
8197 
    iprot.readMessageEnd()
8198 
    result = getReceivePendingOrders_result()
8199 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8200 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8201 
    result.write(oprot)
8202 
    oprot.writeMessageEnd()
8203 
    oprot.trans.flush()
5527 anupam.sin 8204 
 
5553 rajveer 8205 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8206 
    args = getReceivedAtStoreOrders_args()
8207 
    args.read(iprot)
8208 
    iprot.readMessageEnd()
8209 
    result = getReceivedAtStoreOrders_result()
8210 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8211 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8212 
    result.write(oprot)
8213 
    oprot.writeMessageEnd()
8214 
    oprot.trans.flush()
8215 
 
5713 rajveer 8216 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8217 
    args = getOrdersCollectionAtStore_args()
8218 
    args.read(iprot)
8219 
    iprot.readMessageEnd()
8220 
    result = getOrdersCollectionAtStore_result()
8221 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8222 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8223 
    result.write(oprot)
8224 
    oprot.writeMessageEnd()
8225 
    oprot.trans.flush()
8226 
 
5833 rajveer 8227 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8228 
    args = getOrderAttributeValue_args()
8229 
    args.read(iprot)
8230 
    iprot.readMessageEnd()
8231 
    result = getOrderAttributeValue_result()
8232 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8233 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
8237 
 
6019 rajveer 8238 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8239 
    args = changeJacketNumber_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = changeJacketNumber_result()
8243 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8244 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8245 
    result.write(oprot)
8246 
    oprot.writeMessageEnd()
8247 
    oprot.trans.flush()
8248 
 
8249 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8250 
    args = markOrderAsRtoInTransit_args()
8251 
    args.read(iprot)
8252 
    iprot.readMessageEnd()
8253 
    result = markOrderAsRtoInTransit_result()
8254 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8255 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8256 
    result.write(oprot)
8257 
    oprot.writeMessageEnd()
8258 
    oprot.trans.flush()
8259 
 
5593 mandeep.dh 8260 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8261 
    args = acceptOrderForItem_args()
8262 
    args.read(iprot)
8263 
    iprot.readMessageEnd()
8264 
    result = acceptOrderForItem_result()
8265 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8266 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
5553 rajveer 8270 
 
6000 mandeep.dh 8271 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8272 
    args = createRechargeOrder_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = createRechargeOrder_result()
8276 
    try:
8277 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8278 
    except TransactionServiceException, ex:
8279 
      result.ex = ex
8280 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8281 
    result.write(oprot)
8282 
    oprot.writeMessageEnd()
8283 
    oprot.trans.flush()
5593 mandeep.dh 8284 
 
6031 rajveer 8285 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8286 
    args = getRechargeOrder_args()
8287 
    args.read(iprot)
8288 
    iprot.readMessageEnd()
8289 
    result = getRechargeOrder_result()
8290 
    try:
8291 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8292 
    except TransactionServiceException, ex:
8293 
      result.ex = ex
8294 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8295 
    result.write(oprot)
8296 
    oprot.writeMessageEnd()
8297 
    oprot.trans.flush()
8298 
 
8299 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8300 
    args = getRechargeOrders_args()
8301 
    args.read(iprot)
8302 
    iprot.readMessageEnd()
8303 
    result = getRechargeOrders_result()
8304 
    result.success = self._handler.getRechargeOrders(args.userId)
8305 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8306 
    result.write(oprot)
8307 
    oprot.writeMessageEnd()
8308 
    oprot.trans.flush()
8309 
 
6000 mandeep.dh 8310 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8311 
    args = updateRechargeOrderStatus_args()
8312 
    args.read(iprot)
8313 
    iprot.readMessageEnd()
8314 
    result = updateRechargeOrderStatus_result()
8315 
    try:
6031 rajveer 8316 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8317 
    except TransactionServiceException, ex:
8318 
      result.ex = ex
8319 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8320 
    result.write(oprot)
8321 
    oprot.writeMessageEnd()
8322 
    oprot.trans.flush()
8323 
 
8324 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8325 
    args = activateRechargeTxn_args()
8326 
    args.read(iprot)
8327 
    iprot.readMessageEnd()
8328 
    result = activateRechargeTxn_result()
8329 
    try:
6031 rajveer 8330 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8331 
    except TransactionServiceException, ex:
8332 
      result.ex = ex
8333 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8334 
    result.write(oprot)
8335 
    oprot.writeMessageEnd()
8336 
    oprot.trans.flush()
8337 
 
6031 rajveer 8338 
  def process_getUserWallet(self, seqid, iprot, oprot):
8339 
    args = getUserWallet_args()
6000 mandeep.dh 8340 
    args.read(iprot)
8341 
    iprot.readMessageEnd()
6031 rajveer 8342 
    result = getUserWallet_result()
8343 
    result.success = self._handler.getUserWallet(args.userId)
8344 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8345 
    result.write(oprot)
8346 
    oprot.writeMessageEnd()
8347 
    oprot.trans.flush()
8348 
 
6031 rajveer 8349 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8350 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8351 
    args.read(iprot)
8352 
    iprot.readMessageEnd()
6031 rajveer 8353 
    result = getUserWalletHistory_result()
8354 
    result.success = self._handler.getUserWalletHistory(args.userId)
8355 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8356 
    result.write(oprot)
8357 
    oprot.writeMessageEnd()
8358 
    oprot.trans.flush()
8359 
 
6050 anupam.sin 8360 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8361 
    args = getRechargeOrdersForTransaction_args()
8362 
    args.read(iprot)
8363 
    iprot.readMessageEnd()
8364 
    result = getRechargeOrdersForTransaction_result()
8365 
    try:
8366 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8367 
    except TransactionServiceException, ex:
8368 
      result.ex = ex
8369 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8370 
    result.write(oprot)
8371 
    oprot.writeMessageEnd()
8372 
    oprot.trans.flush()
8373 
 
6048 rajveer 8374 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8375 
    args = getServiceProviders_args()
8376 
    args.read(iprot)
8377 
    iprot.readMessageEnd()
8378 
    result = getServiceProviders_result()
6206 rajveer 8379 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8380 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8381 
    result.write(oprot)
8382 
    oprot.writeMessageEnd()
8383 
    oprot.trans.flush()
6000 mandeep.dh 8384 
 
6048 rajveer 8385 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8386 
    args = getServiceProviderForDevice_args()
8387 
    args.read(iprot)
8388 
    iprot.readMessageEnd()
8389 
    result = getServiceProviderForDevice_result()
6049 rajveer 8390 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8391 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8392 
    result.write(oprot)
8393 
    oprot.writeMessageEnd()
8394 
    oprot.trans.flush()
8395 
 
6269 rajveer 8396 
  def process_validateRecharge(self, seqid, iprot, oprot):
8397 
    args = validateRecharge_args()
8398 
    args.read(iprot)
8399 
    iprot.readMessageEnd()
8400 
    result = validateRecharge_result()
6336 anupam.sin 8401 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId)
6269 rajveer 8402 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8403 
    result.write(oprot)
8404 
    oprot.writeMessageEnd()
8405 
    oprot.trans.flush()
8406 
 
6094 rajveer 8407 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8408 
    args = getRechargeOrdersForDevice_args()
8409 
    args.read(iprot)
8410 
    iprot.readMessageEnd()
8411 
    result = getRechargeOrdersForDevice_result()
8412 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8413 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8414 
    result.write(oprot)
8415 
    oprot.writeMessageEnd()
8416 
    oprot.trans.flush()
6048 rajveer 8417 
 
6094 rajveer 8418 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8419 
    args = addAmountToWallet_args()
8420 
    args.read(iprot)
8421 
    iprot.readMessageEnd()
8422 
    result = addAmountToWallet_result()
8423 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8424 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8425 
    result.write(oprot)
8426 
    oprot.writeMessageEnd()
8427 
    oprot.trans.flush()
8428 
 
6188 rajveer 8429 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8430 
    args = getRechargeStatistics_args()
8431 
    args.read(iprot)
8432 
    iprot.readMessageEnd()
8433 
    result = getRechargeStatistics_result()
8434 
    result.success = self._handler.getRechargeStatistics()
8435 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8436 
    result.write(oprot)
8437 
    oprot.writeMessageEnd()
8438 
    oprot.trans.flush()
8439 
 
6154 rajveer 8440 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8441 
    args = getRechargeOrdersForStatus_args()
8442 
    args.read(iprot)
8443 
    iprot.readMessageEnd()
8444 
    result = getRechargeOrdersForStatus_result()
8445 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8446 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8447 
    result.write(oprot)
8448 
    oprot.writeMessageEnd()
8449 
    oprot.trans.flush()
6094 rajveer 8450 
 
6159 rajveer 8451 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8452 
    args = getPlansForOperator_args()
8453 
    args.read(iprot)
8454 
    iprot.readMessageEnd()
8455 
    result = getPlansForOperator_result()
8456 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8457 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8458 
    result.write(oprot)
8459 
    oprot.writeMessageEnd()
8460 
    oprot.trans.flush()
6154 rajveer 8461 
 
6289 anupam.sin 8462 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8463 
    args = getRechargeDenominations_args()
8464 
    args.read(iprot)
8465 
    iprot.readMessageEnd()
8466 
    result = getRechargeDenominations_result()
8467 
    try:
6307 anupam.sin 8468 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8469 
    except TransactionServiceException, ex:
8470 
      result.ex = ex
8471 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8472 
    result.write(oprot)
8473 
    oprot.writeMessageEnd()
8474 
    oprot.trans.flush()
6159 rajveer 8475 
 
6371 rajveer 8476 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8477 
    args = updateAvailabilityStatus_args()
8478 
    args.read(iprot)
8479 
    iprot.readMessageEnd()
8480 
    result = updateAvailabilityStatus_result()
8481 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8482 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8483 
    result.write(oprot)
8484 
    oprot.writeMessageEnd()
8485 
    oprot.trans.flush()
6289 anupam.sin 8486 
 
6371 rajveer 8487 
 
94 ashish 8488 
# HELPER FUNCTIONS AND STRUCTURES
8489 
 
8490 
class createTransaction_args:
8491 
  """
8492 
  Attributes:
8493 
   - transaction
8494 
  """
8495 
 
8496 
  thrift_spec = (
8497 
    None, # 0
8498 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8499 
  )
8500 
 
8501 
  def __init__(self, transaction=None,):
8502 
    self.transaction = transaction
8503 
 
8504 
  def read(self, iprot):
8505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8507 
      return
8508 
    iprot.readStructBegin()
8509 
    while True:
8510 
      (fname, ftype, fid) = iprot.readFieldBegin()
8511 
      if ftype == TType.STOP:
8512 
        break
8513 
      if fid == 1:
8514 
        if ftype == TType.STRUCT:
8515 
          self.transaction = Transaction()
8516 
          self.transaction.read(iprot)
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      else:
8520 
        iprot.skip(ftype)
8521 
      iprot.readFieldEnd()
8522 
    iprot.readStructEnd()
8523 
 
8524 
  def write(self, oprot):
8525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8527 
      return
8528 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8529 
    if self.transaction is not None:
94 ashish 8530 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8531 
      self.transaction.write(oprot)
8532 
      oprot.writeFieldEnd()
8533 
    oprot.writeFieldStop()
8534 
    oprot.writeStructEnd()
8535 
 
3431 rajveer 8536 
  def validate(self):
8537 
    return
8538 
 
8539 
 
94 ashish 8540 
  def __repr__(self):
8541 
    L = ['%s=%r' % (key, value)
8542 
      for key, value in self.__dict__.iteritems()]
8543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8544 
 
8545 
  def __eq__(self, other):
8546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8547 
 
8548 
  def __ne__(self, other):
8549 
    return not (self == other)
8550 
 
8551 
class createTransaction_result:
8552 
  """
8553 
  Attributes:
132 ashish 8554 
   - success
94 ashish 8555 
   - ex
8556 
  """
8557 
 
8558 
  thrift_spec = (
132 ashish 8559 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8561 
  )
8562 
 
132 ashish 8563 
  def __init__(self, success=None, ex=None,):
8564 
    self.success = success
94 ashish 8565 
    self.ex = ex
8566 
 
8567 
  def read(self, iprot):
8568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8570 
      return
8571 
    iprot.readStructBegin()
8572 
    while True:
8573 
      (fname, ftype, fid) = iprot.readFieldBegin()
8574 
      if ftype == TType.STOP:
8575 
        break
132 ashish 8576 
      if fid == 0:
8577 
        if ftype == TType.I64:
8578 
          self.success = iprot.readI64();
8579 
        else:
8580 
          iprot.skip(ftype)
8581 
      elif fid == 1:
94 ashish 8582 
        if ftype == TType.STRUCT:
8583 
          self.ex = TransactionServiceException()
8584 
          self.ex.read(iprot)
8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      else:
8588 
        iprot.skip(ftype)
8589 
      iprot.readFieldEnd()
8590 
    iprot.readStructEnd()
8591 
 
8592 
  def write(self, oprot):
8593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8595 
      return
8596 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8597 
    if self.success is not None:
132 ashish 8598 
      oprot.writeFieldBegin('success', TType.I64, 0)
8599 
      oprot.writeI64(self.success)
8600 
      oprot.writeFieldEnd()
3431 rajveer 8601 
    if self.ex is not None:
94 ashish 8602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8603 
      self.ex.write(oprot)
8604 
      oprot.writeFieldEnd()
8605 
    oprot.writeFieldStop()
8606 
    oprot.writeStructEnd()
8607 
 
3431 rajveer 8608 
  def validate(self):
8609 
    return
8610 
 
8611 
 
94 ashish 8612 
  def __repr__(self):
8613 
    L = ['%s=%r' % (key, value)
8614 
      for key, value in self.__dict__.iteritems()]
8615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8616 
 
8617 
  def __eq__(self, other):
8618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8619 
 
8620 
  def __ne__(self, other):
8621 
    return not (self == other)
8622 
 
8623 
class getTransaction_args:
8624 
  """
8625 
  Attributes:
8626 
   - id
8627 
  """
8628 
 
8629 
  thrift_spec = (
8630 
    None, # 0
8631 
    (1, TType.I64, 'id', None, None, ), # 1
8632 
  )
8633 
 
8634 
  def __init__(self, id=None,):
8635 
    self.id = id
8636 
 
8637 
  def read(self, iprot):
8638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8640 
      return
8641 
    iprot.readStructBegin()
8642 
    while True:
8643 
      (fname, ftype, fid) = iprot.readFieldBegin()
8644 
      if ftype == TType.STOP:
8645 
        break
8646 
      if fid == 1:
8647 
        if ftype == TType.I64:
8648 
          self.id = iprot.readI64();
8649 
        else:
8650 
          iprot.skip(ftype)
8651 
      else:
8652 
        iprot.skip(ftype)
8653 
      iprot.readFieldEnd()
8654 
    iprot.readStructEnd()
8655 
 
8656 
  def write(self, oprot):
8657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8659 
      return
8660 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8661 
    if self.id is not None:
94 ashish 8662 
      oprot.writeFieldBegin('id', TType.I64, 1)
8663 
      oprot.writeI64(self.id)
8664 
      oprot.writeFieldEnd()
8665 
    oprot.writeFieldStop()
8666 
    oprot.writeStructEnd()
8667 
 
3431 rajveer 8668 
  def validate(self):
8669 
    return
8670 
 
8671 
 
94 ashish 8672 
  def __repr__(self):
8673 
    L = ['%s=%r' % (key, value)
8674 
      for key, value in self.__dict__.iteritems()]
8675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8676 
 
8677 
  def __eq__(self, other):
8678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8679 
 
8680 
  def __ne__(self, other):
8681 
    return not (self == other)
8682 
 
8683 
class getTransaction_result:
8684 
  """
8685 
  Attributes:
8686 
   - success
8687 
   - ex
8688 
  """
8689 
 
8690 
  thrift_spec = (
8691 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8693 
  )
8694 
 
8695 
  def __init__(self, success=None, ex=None,):
8696 
    self.success = success
8697 
    self.ex = ex
8698 
 
8699 
  def read(self, iprot):
8700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8702 
      return
8703 
    iprot.readStructBegin()
8704 
    while True:
8705 
      (fname, ftype, fid) = iprot.readFieldBegin()
8706 
      if ftype == TType.STOP:
8707 
        break
8708 
      if fid == 0:
8709 
        if ftype == TType.STRUCT:
8710 
          self.success = Transaction()
8711 
          self.success.read(iprot)
8712 
        else:
8713 
          iprot.skip(ftype)
8714 
      elif fid == 1:
8715 
        if ftype == TType.STRUCT:
8716 
          self.ex = TransactionServiceException()
8717 
          self.ex.read(iprot)
8718 
        else:
8719 
          iprot.skip(ftype)
8720 
      else:
8721 
        iprot.skip(ftype)
8722 
      iprot.readFieldEnd()
8723 
    iprot.readStructEnd()
8724 
 
8725 
  def write(self, oprot):
8726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8728 
      return
8729 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8730 
    if self.success is not None:
94 ashish 8731 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8732 
      self.success.write(oprot)
8733 
      oprot.writeFieldEnd()
3431 rajveer 8734 
    if self.ex is not None:
94 ashish 8735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8736 
      self.ex.write(oprot)
8737 
      oprot.writeFieldEnd()
8738 
    oprot.writeFieldStop()
8739 
    oprot.writeStructEnd()
8740 
 
3431 rajveer 8741 
  def validate(self):
8742 
    return
8743 
 
8744 
 
94 ashish 8745 
  def __repr__(self):
8746 
    L = ['%s=%r' % (key, value)
8747 
      for key, value in self.__dict__.iteritems()]
8748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8749 
 
8750 
  def __eq__(self, other):
8751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8752 
 
8753 
  def __ne__(self, other):
8754 
    return not (self == other)
8755 
 
8756 
class getTransactionsForCustomer_args:
8757 
  """
8758 
  Attributes:
8759 
   - customerId
8760 
   - from_date
8761 
   - to_date
8762 
   - status
8763 
  """
8764 
 
8765 
  thrift_spec = (
8766 
    None, # 0
8767 
    (1, TType.I64, 'customerId', None, None, ), # 1
8768 
    (2, TType.I64, 'from_date', None, None, ), # 2
8769 
    (3, TType.I64, 'to_date', None, None, ), # 3
8770 
    (4, TType.I32, 'status', None, None, ), # 4
8771 
  )
8772 
 
8773 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8774 
    self.customerId = customerId
8775 
    self.from_date = from_date
8776 
    self.to_date = to_date
8777 
    self.status = status
8778 
 
8779 
  def read(self, iprot):
8780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8782 
      return
8783 
    iprot.readStructBegin()
8784 
    while True:
8785 
      (fname, ftype, fid) = iprot.readFieldBegin()
8786 
      if ftype == TType.STOP:
8787 
        break
8788 
      if fid == 1:
8789 
        if ftype == TType.I64:
8790 
          self.customerId = iprot.readI64();
8791 
        else:
8792 
          iprot.skip(ftype)
8793 
      elif fid == 2:
8794 
        if ftype == TType.I64:
8795 
          self.from_date = iprot.readI64();
8796 
        else:
8797 
          iprot.skip(ftype)
8798 
      elif fid == 3:
8799 
        if ftype == TType.I64:
8800 
          self.to_date = iprot.readI64();
8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      elif fid == 4:
8804 
        if ftype == TType.I32:
8805 
          self.status = iprot.readI32();
8806 
        else:
8807 
          iprot.skip(ftype)
8808 
      else:
8809 
        iprot.skip(ftype)
8810 
      iprot.readFieldEnd()
8811 
    iprot.readStructEnd()
8812 
 
8813 
  def write(self, oprot):
8814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8816 
      return
8817 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8818 
    if self.customerId is not None:
94 ashish 8819 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8820 
      oprot.writeI64(self.customerId)
8821 
      oprot.writeFieldEnd()
3431 rajveer 8822 
    if self.from_date is not None:
94 ashish 8823 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8824 
      oprot.writeI64(self.from_date)
8825 
      oprot.writeFieldEnd()
3431 rajveer 8826 
    if self.to_date is not None:
94 ashish 8827 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8828 
      oprot.writeI64(self.to_date)
8829 
      oprot.writeFieldEnd()
3431 rajveer 8830 
    if self.status is not None:
94 ashish 8831 
      oprot.writeFieldBegin('status', TType.I32, 4)
8832 
      oprot.writeI32(self.status)
8833 
      oprot.writeFieldEnd()
8834 
    oprot.writeFieldStop()
8835 
    oprot.writeStructEnd()
8836 
 
3431 rajveer 8837 
  def validate(self):
8838 
    return
8839 
 
8840 
 
94 ashish 8841 
  def __repr__(self):
8842 
    L = ['%s=%r' % (key, value)
8843 
      for key, value in self.__dict__.iteritems()]
8844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8845 
 
8846 
  def __eq__(self, other):
8847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8848 
 
8849 
  def __ne__(self, other):
8850 
    return not (self == other)
8851 
 
8852 
class getTransactionsForCustomer_result:
8853 
  """
8854 
  Attributes:
8855 
   - success
8856 
   - ex
8857 
  """
8858 
 
8859 
  thrift_spec = (
8860 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8861 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8862 
  )
8863 
 
8864 
  def __init__(self, success=None, ex=None,):
8865 
    self.success = success
8866 
    self.ex = ex
8867 
 
8868 
  def read(self, iprot):
8869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8871 
      return
8872 
    iprot.readStructBegin()
8873 
    while True:
8874 
      (fname, ftype, fid) = iprot.readFieldBegin()
8875 
      if ftype == TType.STOP:
8876 
        break
8877 
      if fid == 0:
8878 
        if ftype == TType.LIST:
8879 
          self.success = []
6188 rajveer 8880 
          (_etype109, _size106) = iprot.readListBegin()
8881 
          for _i110 in xrange(_size106):
8882 
            _elem111 = Transaction()
8883 
            _elem111.read(iprot)
8884 
            self.success.append(_elem111)
94 ashish 8885 
          iprot.readListEnd()
8886 
        else:
8887 
          iprot.skip(ftype)
8888 
      elif fid == 1:
8889 
        if ftype == TType.STRUCT:
8890 
          self.ex = TransactionServiceException()
8891 
          self.ex.read(iprot)
8892 
        else:
8893 
          iprot.skip(ftype)
8894 
      else:
8895 
        iprot.skip(ftype)
8896 
      iprot.readFieldEnd()
8897 
    iprot.readStructEnd()
8898 
 
8899 
  def write(self, oprot):
8900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8902 
      return
8903 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8904 
    if self.success is not None:
94 ashish 8905 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8906 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8907 
      for iter112 in self.success:
8908 
        iter112.write(oprot)
94 ashish 8909 
      oprot.writeListEnd()
8910 
      oprot.writeFieldEnd()
3431 rajveer 8911 
    if self.ex is not None:
94 ashish 8912 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8913 
      self.ex.write(oprot)
8914 
      oprot.writeFieldEnd()
8915 
    oprot.writeFieldStop()
8916 
    oprot.writeStructEnd()
8917 
 
3431 rajveer 8918 
  def validate(self):
8919 
    return
8920 
 
8921 
 
94 ashish 8922 
  def __repr__(self):
8923 
    L = ['%s=%r' % (key, value)
8924 
      for key, value in self.__dict__.iteritems()]
8925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8926 
 
8927 
  def __eq__(self, other):
8928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8929 
 
8930 
  def __ne__(self, other):
8931 
    return not (self == other)
8932 
 
132 ashish 8933 
class getTransactionsForShoppingCartId_args:
8934 
  """
8935 
  Attributes:
8936 
   - shoppingCartId
8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    None, # 0
8941 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8942 
  )
8943 
 
8944 
  def __init__(self, shoppingCartId=None,):
8945 
    self.shoppingCartId = shoppingCartId
8946 
 
8947 
  def read(self, iprot):
8948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8950 
      return
8951 
    iprot.readStructBegin()
8952 
    while True:
8953 
      (fname, ftype, fid) = iprot.readFieldBegin()
8954 
      if ftype == TType.STOP:
8955 
        break
8956 
      if fid == 1:
8957 
        if ftype == TType.I64:
8958 
          self.shoppingCartId = iprot.readI64();
8959 
        else:
8960 
          iprot.skip(ftype)
8961 
      else:
8962 
        iprot.skip(ftype)
8963 
      iprot.readFieldEnd()
8964 
    iprot.readStructEnd()
8965 
 
8966 
  def write(self, oprot):
8967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8969 
      return
8970 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8971 
    if self.shoppingCartId is not None:
132 ashish 8972 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8973 
      oprot.writeI64(self.shoppingCartId)
8974 
      oprot.writeFieldEnd()
8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
3431 rajveer 8978 
  def validate(self):
8979 
    return
8980 
 
8981 
 
132 ashish 8982 
  def __repr__(self):
8983 
    L = ['%s=%r' % (key, value)
8984 
      for key, value in self.__dict__.iteritems()]
8985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8986 
 
8987 
  def __eq__(self, other):
8988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8989 
 
8990 
  def __ne__(self, other):
8991 
    return not (self == other)
8992 
 
8993 
class getTransactionsForShoppingCartId_result:
8994 
  """
8995 
  Attributes:
8996 
   - success
8997 
   - ex
8998 
  """
8999 
 
9000 
  thrift_spec = (
9001 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9002 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9003 
  )
9004 
 
9005 
  def __init__(self, success=None, ex=None,):
9006 
    self.success = success
9007 
    self.ex = ex
9008 
 
9009 
  def read(self, iprot):
9010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9012 
      return
9013 
    iprot.readStructBegin()
9014 
    while True:
9015 
      (fname, ftype, fid) = iprot.readFieldBegin()
9016 
      if ftype == TType.STOP:
9017 
        break
9018 
      if fid == 0:
9019 
        if ftype == TType.LIST:
9020 
          self.success = []
6188 rajveer 9021 
          (_etype116, _size113) = iprot.readListBegin()
9022 
          for _i117 in xrange(_size113):
9023 
            _elem118 = Transaction()
9024 
            _elem118.read(iprot)
9025 
            self.success.append(_elem118)
132 ashish 9026 
          iprot.readListEnd()
9027 
        else:
9028 
          iprot.skip(ftype)
9029 
      elif fid == 1:
9030 
        if ftype == TType.STRUCT:
9031 
          self.ex = TransactionServiceException()
9032 
          self.ex.read(iprot)
9033 
        else:
9034 
          iprot.skip(ftype)
9035 
      else:
9036 
        iprot.skip(ftype)
9037 
      iprot.readFieldEnd()
9038 
    iprot.readStructEnd()
9039 
 
9040 
  def write(self, oprot):
9041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9043 
      return
9044 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9045 
    if self.success is not None:
132 ashish 9046 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9047 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9048 
      for iter119 in self.success:
9049 
        iter119.write(oprot)
132 ashish 9050 
      oprot.writeListEnd()
9051 
      oprot.writeFieldEnd()
3431 rajveer 9052 
    if self.ex is not None:
132 ashish 9053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9054 
      self.ex.write(oprot)
9055 
      oprot.writeFieldEnd()
9056 
    oprot.writeFieldStop()
9057 
    oprot.writeStructEnd()
9058 
 
3431 rajveer 9059 
  def validate(self):
9060 
    return
9061 
 
9062 
 
132 ashish 9063 
  def __repr__(self):
9064 
    L = ['%s=%r' % (key, value)
9065 
      for key, value in self.__dict__.iteritems()]
9066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9067 
 
9068 
  def __eq__(self, other):
9069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9070 
 
9071 
  def __ne__(self, other):
9072 
    return not (self == other)
9073 
 
94 ashish 9074 
class getTransactionStatus_args:
9075 
  """
9076 
  Attributes:
9077 
   - transactionId
9078 
  """
9079 
 
9080 
  thrift_spec = (
9081 
    None, # 0
9082 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9083 
  )
9084 
 
9085 
  def __init__(self, transactionId=None,):
9086 
    self.transactionId = transactionId
9087 
 
9088 
  def read(self, iprot):
9089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9091 
      return
9092 
    iprot.readStructBegin()
9093 
    while True:
9094 
      (fname, ftype, fid) = iprot.readFieldBegin()
9095 
      if ftype == TType.STOP:
9096 
        break
9097 
      if fid == 1:
9098 
        if ftype == TType.I64:
9099 
          self.transactionId = iprot.readI64();
9100 
        else:
9101 
          iprot.skip(ftype)
9102 
      else:
9103 
        iprot.skip(ftype)
9104 
      iprot.readFieldEnd()
9105 
    iprot.readStructEnd()
9106 
 
9107 
  def write(self, oprot):
9108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9110 
      return
9111 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9112 
    if self.transactionId is not None:
94 ashish 9113 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9114 
      oprot.writeI64(self.transactionId)
9115 
      oprot.writeFieldEnd()
9116 
    oprot.writeFieldStop()
9117 
    oprot.writeStructEnd()
9118 
 
3431 rajveer 9119 
  def validate(self):
9120 
    return
9121 
 
9122 
 
94 ashish 9123 
  def __repr__(self):
9124 
    L = ['%s=%r' % (key, value)
9125 
      for key, value in self.__dict__.iteritems()]
9126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9127 
 
9128 
  def __eq__(self, other):
9129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9130 
 
9131 
  def __ne__(self, other):
9132 
    return not (self == other)
9133 
 
9134 
class getTransactionStatus_result:
9135 
  """
9136 
  Attributes:
9137 
   - success
9138 
   - ex
9139 
  """
9140 
 
9141 
  thrift_spec = (
9142 
    (0, TType.I32, 'success', None, None, ), # 0
9143 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9144 
  )
9145 
 
9146 
  def __init__(self, success=None, ex=None,):
9147 
    self.success = success
9148 
    self.ex = ex
9149 
 
9150 
  def read(self, iprot):
9151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9153 
      return
9154 
    iprot.readStructBegin()
9155 
    while True:
9156 
      (fname, ftype, fid) = iprot.readFieldBegin()
9157 
      if ftype == TType.STOP:
9158 
        break
9159 
      if fid == 0:
9160 
        if ftype == TType.I32:
9161 
          self.success = iprot.readI32();
9162 
        else:
9163 
          iprot.skip(ftype)
9164 
      elif fid == 1:
9165 
        if ftype == TType.STRUCT:
9166 
          self.ex = TransactionServiceException()
9167 
          self.ex.read(iprot)
9168 
        else:
9169 
          iprot.skip(ftype)
9170 
      else:
9171 
        iprot.skip(ftype)
9172 
      iprot.readFieldEnd()
9173 
    iprot.readStructEnd()
9174 
 
9175 
  def write(self, oprot):
9176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9178 
      return
9179 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9180 
    if self.success is not None:
94 ashish 9181 
      oprot.writeFieldBegin('success', TType.I32, 0)
9182 
      oprot.writeI32(self.success)
9183 
      oprot.writeFieldEnd()
3431 rajveer 9184 
    if self.ex is not None:
94 ashish 9185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9186 
      self.ex.write(oprot)
9187 
      oprot.writeFieldEnd()
9188 
    oprot.writeFieldStop()
9189 
    oprot.writeStructEnd()
9190 
 
3431 rajveer 9191 
  def validate(self):
9192 
    return
9193 
 
9194 
 
94 ashish 9195 
  def __repr__(self):
9196 
    L = ['%s=%r' % (key, value)
9197 
      for key, value in self.__dict__.iteritems()]
9198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9199 
 
9200 
  def __eq__(self, other):
9201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9202 
 
9203 
  def __ne__(self, other):
9204 
    return not (self == other)
9205 
 
9206 
class changeTransactionStatus_args:
9207 
  """
9208 
  Attributes:
9209 
   - transactionId
9210 
   - status
9211 
   - description
5527 anupam.sin 9212 
   - pickUp
9213 
   - orderType
94 ashish 9214 
  """
9215 
 
9216 
  thrift_spec = (
9217 
    None, # 0
9218 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9219 
    (2, TType.I32, 'status', None, None, ), # 2
9220 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9221 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9222 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9223 
  )
9224 
 
5527 anupam.sin 9225 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9226 
    self.transactionId = transactionId
9227 
    self.status = status
9228 
    self.description = description
5527 anupam.sin 9229 
    self.pickUp = pickUp
9230 
    self.orderType = orderType
94 ashish 9231 
 
9232 
  def read(self, iprot):
9233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9235 
      return
9236 
    iprot.readStructBegin()
9237 
    while True:
9238 
      (fname, ftype, fid) = iprot.readFieldBegin()
9239 
      if ftype == TType.STOP:
9240 
        break
9241 
      if fid == 1:
9242 
        if ftype == TType.I64:
9243 
          self.transactionId = iprot.readI64();
9244 
        else:
9245 
          iprot.skip(ftype)
9246 
      elif fid == 2:
9247 
        if ftype == TType.I32:
9248 
          self.status = iprot.readI32();
9249 
        else:
9250 
          iprot.skip(ftype)
9251 
      elif fid == 3:
9252 
        if ftype == TType.STRING:
9253 
          self.description = iprot.readString();
9254 
        else:
9255 
          iprot.skip(ftype)
5387 rajveer 9256 
      elif fid == 4:
5527 anupam.sin 9257 
        if ftype == TType.I64:
9258 
          self.pickUp = iprot.readI64();
5387 rajveer 9259 
        else:
9260 
          iprot.skip(ftype)
5527 anupam.sin 9261 
      elif fid == 5:
9262 
        if ftype == TType.I32:
9263 
          self.orderType = iprot.readI32();
9264 
        else:
9265 
          iprot.skip(ftype)
94 ashish 9266 
      else:
9267 
        iprot.skip(ftype)
9268 
      iprot.readFieldEnd()
9269 
    iprot.readStructEnd()
9270 
 
9271 
  def write(self, oprot):
9272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9274 
      return
9275 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9276 
    if self.transactionId is not None:
94 ashish 9277 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9278 
      oprot.writeI64(self.transactionId)
9279 
      oprot.writeFieldEnd()
3431 rajveer 9280 
    if self.status is not None:
94 ashish 9281 
      oprot.writeFieldBegin('status', TType.I32, 2)
9282 
      oprot.writeI32(self.status)
9283 
      oprot.writeFieldEnd()
3431 rajveer 9284 
    if self.description is not None:
94 ashish 9285 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9286 
      oprot.writeString(self.description)
9287 
      oprot.writeFieldEnd()
5527 anupam.sin 9288 
    if self.pickUp is not None:
9289 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9290 
      oprot.writeI64(self.pickUp)
5387 rajveer 9291 
      oprot.writeFieldEnd()
5527 anupam.sin 9292 
    if self.orderType is not None:
9293 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9294 
      oprot.writeI32(self.orderType)
9295 
      oprot.writeFieldEnd()
94 ashish 9296 
    oprot.writeFieldStop()
9297 
    oprot.writeStructEnd()
9298 
 
3431 rajveer 9299 
  def validate(self):
9300 
    return
9301 
 
9302 
 
94 ashish 9303 
  def __repr__(self):
9304 
    L = ['%s=%r' % (key, value)
9305 
      for key, value in self.__dict__.iteritems()]
9306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9307 
 
9308 
  def __eq__(self, other):
9309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9310 
 
9311 
  def __ne__(self, other):
9312 
    return not (self == other)
9313 
 
9314 
class changeTransactionStatus_result:
9315 
  """
9316 
  Attributes:
9317 
   - success
9318 
   - ex
9319 
  """
9320 
 
9321 
  thrift_spec = (
9322 
    (0, TType.BOOL, 'success', None, None, ), # 0
9323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9324 
  )
9325 
 
9326 
  def __init__(self, success=None, ex=None,):
9327 
    self.success = success
9328 
    self.ex = ex
9329 
 
9330 
  def read(self, iprot):
9331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9333 
      return
9334 
    iprot.readStructBegin()
9335 
    while True:
9336 
      (fname, ftype, fid) = iprot.readFieldBegin()
9337 
      if ftype == TType.STOP:
9338 
        break
9339 
      if fid == 0:
9340 
        if ftype == TType.BOOL:
9341 
          self.success = iprot.readBool();
9342 
        else:
9343 
          iprot.skip(ftype)
9344 
      elif fid == 1:
9345 
        if ftype == TType.STRUCT:
9346 
          self.ex = TransactionServiceException()
9347 
          self.ex.read(iprot)
9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      else:
9351 
        iprot.skip(ftype)
9352 
      iprot.readFieldEnd()
9353 
    iprot.readStructEnd()
9354 
 
9355 
  def write(self, oprot):
9356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9358 
      return
9359 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9360 
    if self.success is not None:
94 ashish 9361 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9362 
      oprot.writeBool(self.success)
9363 
      oprot.writeFieldEnd()
3431 rajveer 9364 
    if self.ex is not None:
94 ashish 9365 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9366 
      self.ex.write(oprot)
9367 
      oprot.writeFieldEnd()
9368 
    oprot.writeFieldStop()
9369 
    oprot.writeStructEnd()
9370 
 
3431 rajveer 9371 
  def validate(self):
9372 
    return
9373 
 
9374 
 
94 ashish 9375 
  def __repr__(self):
9376 
    L = ['%s=%r' % (key, value)
9377 
      for key, value in self.__dict__.iteritems()]
9378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9379 
 
9380 
  def __eq__(self, other):
9381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9382 
 
9383 
  def __ne__(self, other):
9384 
    return not (self == other)
9385 
 
1398 varun.gupt 9386 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9387 
  """
9388 
  Attributes:
9389 
   - transactionId
9390 
  """
9391 
 
9392 
  thrift_spec = (
9393 
    None, # 0
9394 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9395 
  )
9396 
 
9397 
  def __init__(self, transactionId=None,):
9398 
    self.transactionId = transactionId
9399 
 
9400 
  def read(self, iprot):
9401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9403 
      return
9404 
    iprot.readStructBegin()
9405 
    while True:
9406 
      (fname, ftype, fid) = iprot.readFieldBegin()
9407 
      if ftype == TType.STOP:
9408 
        break
9409 
      if fid == 1:
9410 
        if ftype == TType.I64:
9411 
          self.transactionId = iprot.readI64();
9412 
        else:
9413 
          iprot.skip(ftype)
9414 
      else:
9415 
        iprot.skip(ftype)
9416 
      iprot.readFieldEnd()
9417 
    iprot.readStructEnd()
9418 
 
9419 
  def write(self, oprot):
9420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9422 
      return
1398 varun.gupt 9423 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9424 
    if self.transactionId is not None:
1382 varun.gupt 9425 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9426 
      oprot.writeI64(self.transactionId)
9427 
      oprot.writeFieldEnd()
9428 
    oprot.writeFieldStop()
9429 
    oprot.writeStructEnd()
9430 
 
3431 rajveer 9431 
  def validate(self):
9432 
    return
9433 
 
9434 
 
1382 varun.gupt 9435 
  def __repr__(self):
9436 
    L = ['%s=%r' % (key, value)
9437 
      for key, value in self.__dict__.iteritems()]
9438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9439 
 
9440 
  def __eq__(self, other):
9441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9442 
 
9443 
  def __ne__(self, other):
9444 
    return not (self == other)
9445 
 
1398 varun.gupt 9446 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9447 
  """
9448 
  Attributes:
9449 
   - success
9450 
   - ex
9451 
  """
9452 
 
9453 
  thrift_spec = (
9454 
    (0, TType.BOOL, 'success', None, None, ), # 0
9455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9456 
  )
9457 
 
9458 
  def __init__(self, success=None, ex=None,):
9459 
    self.success = success
9460 
    self.ex = ex
9461 
 
9462 
  def read(self, iprot):
9463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9465 
      return
9466 
    iprot.readStructBegin()
9467 
    while True:
9468 
      (fname, ftype, fid) = iprot.readFieldBegin()
9469 
      if ftype == TType.STOP:
9470 
        break
9471 
      if fid == 0:
9472 
        if ftype == TType.BOOL:
9473 
          self.success = iprot.readBool();
9474 
        else:
9475 
          iprot.skip(ftype)
9476 
      elif fid == 1:
9477 
        if ftype == TType.STRUCT:
9478 
          self.ex = TransactionServiceException()
9479 
          self.ex.read(iprot)
9480 
        else:
9481 
          iprot.skip(ftype)
9482 
      else:
9483 
        iprot.skip(ftype)
9484 
      iprot.readFieldEnd()
9485 
    iprot.readStructEnd()
9486 
 
9487 
  def write(self, oprot):
9488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9490 
      return
1398 varun.gupt 9491 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9492 
    if self.success is not None:
1382 varun.gupt 9493 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9494 
      oprot.writeBool(self.success)
9495 
      oprot.writeFieldEnd()
3431 rajveer 9496 
    if self.ex is not None:
1382 varun.gupt 9497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9498 
      self.ex.write(oprot)
9499 
      oprot.writeFieldEnd()
9500 
    oprot.writeFieldStop()
9501 
    oprot.writeStructEnd()
9502 
 
3431 rajveer 9503 
  def validate(self):
9504 
    return
9505 
 
9506 
 
1382 varun.gupt 9507 
  def __repr__(self):
9508 
    L = ['%s=%r' % (key, value)
9509 
      for key, value in self.__dict__.iteritems()]
9510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9511 
 
9512 
  def __eq__(self, other):
9513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9514 
 
9515 
  def __ne__(self, other):
9516 
    return not (self == other)
9517 
 
483 rajveer 9518 
class getAllOrders_args:
94 ashish 9519 
  """
9520 
  Attributes:
4801 anupam.sin 9521 
   - statuses
483 rajveer 9522 
   - from_date
9523 
   - to_date
9524 
   - warehouse_id
94 ashish 9525 
  """
9526 
 
9527 
  thrift_spec = (
9528 
    None, # 0
4801 anupam.sin 9529 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9530 
    (2, TType.I64, 'from_date', None, None, ), # 2
9531 
    (3, TType.I64, 'to_date', None, None, ), # 3
9532 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9533 
  )
9534 
 
4801 anupam.sin 9535 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9536 
    self.statuses = statuses
483 rajveer 9537 
    self.from_date = from_date
9538 
    self.to_date = to_date
9539 
    self.warehouse_id = warehouse_id
94 ashish 9540 
 
9541 
  def read(self, iprot):
9542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9544 
      return
9545 
    iprot.readStructBegin()
9546 
    while True:
9547 
      (fname, ftype, fid) = iprot.readFieldBegin()
9548 
      if ftype == TType.STOP:
9549 
        break
9550 
      if fid == 1:
4801 anupam.sin 9551 
        if ftype == TType.LIST:
9552 
          self.statuses = []
6188 rajveer 9553 
          (_etype123, _size120) = iprot.readListBegin()
9554 
          for _i124 in xrange(_size120):
9555 
            _elem125 = iprot.readI32();
9556 
            self.statuses.append(_elem125)
4801 anupam.sin 9557 
          iprot.readListEnd()
94 ashish 9558 
        else:
9559 
          iprot.skip(ftype)
483 rajveer 9560 
      elif fid == 2:
9561 
        if ftype == TType.I64:
9562 
          self.from_date = iprot.readI64();
94 ashish 9563 
        else:
9564 
          iprot.skip(ftype)
483 rajveer 9565 
      elif fid == 3:
9566 
        if ftype == TType.I64:
9567 
          self.to_date = iprot.readI64();
94 ashish 9568 
        else:
9569 
          iprot.skip(ftype)
483 rajveer 9570 
      elif fid == 4:
94 ashish 9571 
        if ftype == TType.I64:
483 rajveer 9572 
          self.warehouse_id = iprot.readI64();
94 ashish 9573 
        else:
9574 
          iprot.skip(ftype)
9575 
      else:
9576 
        iprot.skip(ftype)
9577 
      iprot.readFieldEnd()
9578 
    iprot.readStructEnd()
9579 
 
9580 
  def write(self, oprot):
9581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9583 
      return
483 rajveer 9584 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9585 
    if self.statuses is not None:
9586 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9587 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9588 
      for iter126 in self.statuses:
9589 
        oprot.writeI32(iter126)
4801 anupam.sin 9590 
      oprot.writeListEnd()
94 ashish 9591 
      oprot.writeFieldEnd()
3431 rajveer 9592 
    if self.from_date is not None:
483 rajveer 9593 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9594 
      oprot.writeI64(self.from_date)
94 ashish 9595 
      oprot.writeFieldEnd()
3431 rajveer 9596 
    if self.to_date is not None:
483 rajveer 9597 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9598 
      oprot.writeI64(self.to_date)
94 ashish 9599 
      oprot.writeFieldEnd()
3431 rajveer 9600 
    if self.warehouse_id is not None:
483 rajveer 9601 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9602 
      oprot.writeI64(self.warehouse_id)
94 ashish 9603 
      oprot.writeFieldEnd()
9604 
    oprot.writeFieldStop()
9605 
    oprot.writeStructEnd()
9606 
 
3431 rajveer 9607 
  def validate(self):
9608 
    return
9609 
 
9610 
 
94 ashish 9611 
  def __repr__(self):
9612 
    L = ['%s=%r' % (key, value)
9613 
      for key, value in self.__dict__.iteritems()]
9614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9615 
 
9616 
  def __eq__(self, other):
9617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9618 
 
9619 
  def __ne__(self, other):
9620 
    return not (self == other)
9621 
 
483 rajveer 9622 
class getAllOrders_result:
94 ashish 9623 
  """
9624 
  Attributes:
9625 
   - success
9626 
   - ex
9627 
  """
9628 
 
9629 
  thrift_spec = (
483 rajveer 9630 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9631 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9632 
  )
9633 
 
9634 
  def __init__(self, success=None, ex=None,):
9635 
    self.success = success
9636 
    self.ex = ex
9637 
 
9638 
  def read(self, iprot):
9639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9641 
      return
9642 
    iprot.readStructBegin()
9643 
    while True:
9644 
      (fname, ftype, fid) = iprot.readFieldBegin()
9645 
      if ftype == TType.STOP:
9646 
        break
9647 
      if fid == 0:
483 rajveer 9648 
        if ftype == TType.LIST:
9649 
          self.success = []
6188 rajveer 9650 
          (_etype130, _size127) = iprot.readListBegin()
9651 
          for _i131 in xrange(_size127):
9652 
            _elem132 = Order()
9653 
            _elem132.read(iprot)
9654 
            self.success.append(_elem132)
483 rajveer 9655 
          iprot.readListEnd()
94 ashish 9656 
        else:
9657 
          iprot.skip(ftype)
9658 
      elif fid == 1:
9659 
        if ftype == TType.STRUCT:
9660 
          self.ex = TransactionServiceException()
9661 
          self.ex.read(iprot)
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      else:
9665 
        iprot.skip(ftype)
9666 
      iprot.readFieldEnd()
9667 
    iprot.readStructEnd()
9668 
 
9669 
  def write(self, oprot):
9670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9672 
      return
483 rajveer 9673 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9674 
    if self.success is not None:
483 rajveer 9675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9676 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9677 
      for iter133 in self.success:
9678 
        iter133.write(oprot)
483 rajveer 9679 
      oprot.writeListEnd()
94 ashish 9680 
      oprot.writeFieldEnd()
3431 rajveer 9681 
    if self.ex is not None:
94 ashish 9682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9683 
      self.ex.write(oprot)
9684 
      oprot.writeFieldEnd()
9685 
    oprot.writeFieldStop()
9686 
    oprot.writeStructEnd()
9687 
 
3431 rajveer 9688 
  def validate(self):
9689 
    return
9690 
 
9691 
 
94 ashish 9692 
  def __repr__(self):
9693 
    L = ['%s=%r' % (key, value)
9694 
      for key, value in self.__dict__.iteritems()]
9695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9696 
 
9697 
  def __eq__(self, other):
9698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9699 
 
9700 
  def __ne__(self, other):
9701 
    return not (self == other)
9702 
 
4133 chandransh 9703 
class getOrdersInBatch_args:
9704 
  """
9705 
  Attributes:
9706 
   - statuses
9707 
   - offset
9708 
   - limit
9709 
   - warehouse_id
9710 
  """
9711 
 
9712 
  thrift_spec = (
9713 
    None, # 0
9714 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9715 
    (2, TType.I64, 'offset', None, None, ), # 2
9716 
    (3, TType.I64, 'limit', None, None, ), # 3
9717 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9718 
  )
9719 
 
9720 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9721 
    self.statuses = statuses
9722 
    self.offset = offset
9723 
    self.limit = limit
9724 
    self.warehouse_id = warehouse_id
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 1:
9736 
        if ftype == TType.LIST:
9737 
          self.statuses = []
6188 rajveer 9738 
          (_etype137, _size134) = iprot.readListBegin()
9739 
          for _i138 in xrange(_size134):
9740 
            _elem139 = iprot.readI32();
9741 
            self.statuses.append(_elem139)
4133 chandransh 9742 
          iprot.readListEnd()
9743 
        else:
9744 
          iprot.skip(ftype)
9745 
      elif fid == 2:
9746 
        if ftype == TType.I64:
9747 
          self.offset = iprot.readI64();
9748 
        else:
9749 
          iprot.skip(ftype)
9750 
      elif fid == 3:
9751 
        if ftype == TType.I64:
9752 
          self.limit = iprot.readI64();
9753 
        else:
9754 
          iprot.skip(ftype)
9755 
      elif fid == 4:
9756 
        if ftype == TType.I64:
9757 
          self.warehouse_id = iprot.readI64();
9758 
        else:
9759 
          iprot.skip(ftype)
9760 
      else:
9761 
        iprot.skip(ftype)
9762 
      iprot.readFieldEnd()
9763 
    iprot.readStructEnd()
9764 
 
9765 
  def write(self, oprot):
9766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9768 
      return
9769 
    oprot.writeStructBegin('getOrdersInBatch_args')
9770 
    if self.statuses is not None:
9771 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9772 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9773 
      for iter140 in self.statuses:
9774 
        oprot.writeI32(iter140)
4133 chandransh 9775 
      oprot.writeListEnd()
9776 
      oprot.writeFieldEnd()
9777 
    if self.offset is not None:
9778 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9779 
      oprot.writeI64(self.offset)
9780 
      oprot.writeFieldEnd()
9781 
    if self.limit is not None:
9782 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9783 
      oprot.writeI64(self.limit)
9784 
      oprot.writeFieldEnd()
9785 
    if self.warehouse_id is not None:
9786 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9787 
      oprot.writeI64(self.warehouse_id)
9788 
      oprot.writeFieldEnd()
9789 
    oprot.writeFieldStop()
9790 
    oprot.writeStructEnd()
9791 
 
9792 
  def validate(self):
9793 
    return
9794 
 
9795 
 
9796 
  def __repr__(self):
9797 
    L = ['%s=%r' % (key, value)
9798 
      for key, value in self.__dict__.iteritems()]
9799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9800 
 
9801 
  def __eq__(self, other):
9802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9803 
 
9804 
  def __ne__(self, other):
9805 
    return not (self == other)
9806 
 
9807 
class getOrdersInBatch_result:
9808 
  """
9809 
  Attributes:
9810 
   - success
9811 
   - ex
9812 
  """
9813 
 
9814 
  thrift_spec = (
9815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9817 
  )
9818 
 
9819 
  def __init__(self, success=None, ex=None,):
9820 
    self.success = success
9821 
    self.ex = ex
9822 
 
9823 
  def read(self, iprot):
9824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9826 
      return
9827 
    iprot.readStructBegin()
9828 
    while True:
9829 
      (fname, ftype, fid) = iprot.readFieldBegin()
9830 
      if ftype == TType.STOP:
9831 
        break
9832 
      if fid == 0:
9833 
        if ftype == TType.LIST:
9834 
          self.success = []
6188 rajveer 9835 
          (_etype144, _size141) = iprot.readListBegin()
9836 
          for _i145 in xrange(_size141):
9837 
            _elem146 = Order()
9838 
            _elem146.read(iprot)
9839 
            self.success.append(_elem146)
4133 chandransh 9840 
          iprot.readListEnd()
9841 
        else:
9842 
          iprot.skip(ftype)
9843 
      elif fid == 1:
9844 
        if ftype == TType.STRUCT:
9845 
          self.ex = TransactionServiceException()
9846 
          self.ex.read(iprot)
9847 
        else:
9848 
          iprot.skip(ftype)
9849 
      else:
9850 
        iprot.skip(ftype)
9851 
      iprot.readFieldEnd()
9852 
    iprot.readStructEnd()
9853 
 
9854 
  def write(self, oprot):
9855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9857 
      return
9858 
    oprot.writeStructBegin('getOrdersInBatch_result')
9859 
    if self.success is not None:
9860 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9861 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9862 
      for iter147 in self.success:
9863 
        iter147.write(oprot)
4133 chandransh 9864 
      oprot.writeListEnd()
9865 
      oprot.writeFieldEnd()
9866 
    if self.ex is not None:
9867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9868 
      self.ex.write(oprot)
9869 
      oprot.writeFieldEnd()
9870 
    oprot.writeFieldStop()
9871 
    oprot.writeStructEnd()
9872 
 
9873 
  def validate(self):
9874 
    return
9875 
 
9876 
 
9877 
  def __repr__(self):
9878 
    L = ['%s=%r' % (key, value)
9879 
      for key, value in self.__dict__.iteritems()]
9880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9881 
 
9882 
  def __eq__(self, other):
9883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9884 
 
9885 
  def __ne__(self, other):
9886 
    return not (self == other)
9887 
 
9888 
class getOrderCount_args:
9889 
  """
9890 
  Attributes:
9891 
   - statuses
9892 
   - warehouseId
9893 
  """
9894 
 
9895 
  thrift_spec = (
9896 
    None, # 0
9897 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9898 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9899 
  )
9900 
 
9901 
  def __init__(self, statuses=None, warehouseId=None,):
9902 
    self.statuses = statuses
9903 
    self.warehouseId = warehouseId
9904 
 
9905 
  def read(self, iprot):
9906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9908 
      return
9909 
    iprot.readStructBegin()
9910 
    while True:
9911 
      (fname, ftype, fid) = iprot.readFieldBegin()
9912 
      if ftype == TType.STOP:
9913 
        break
9914 
      if fid == 1:
9915 
        if ftype == TType.LIST:
9916 
          self.statuses = []
6188 rajveer 9917 
          (_etype151, _size148) = iprot.readListBegin()
9918 
          for _i152 in xrange(_size148):
9919 
            _elem153 = iprot.readI32();
9920 
            self.statuses.append(_elem153)
4133 chandransh 9921 
          iprot.readListEnd()
9922 
        else:
9923 
          iprot.skip(ftype)
9924 
      elif fid == 2:
9925 
        if ftype == TType.I64:
9926 
          self.warehouseId = iprot.readI64();
9927 
        else:
9928 
          iprot.skip(ftype)
9929 
      else:
9930 
        iprot.skip(ftype)
9931 
      iprot.readFieldEnd()
9932 
    iprot.readStructEnd()
9933 
 
9934 
  def write(self, oprot):
9935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9937 
      return
9938 
    oprot.writeStructBegin('getOrderCount_args')
9939 
    if self.statuses is not None:
9940 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9941 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9942 
      for iter154 in self.statuses:
9943 
        oprot.writeI32(iter154)
4133 chandransh 9944 
      oprot.writeListEnd()
9945 
      oprot.writeFieldEnd()
9946 
    if self.warehouseId is not None:
9947 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9948 
      oprot.writeI64(self.warehouseId)
9949 
      oprot.writeFieldEnd()
9950 
    oprot.writeFieldStop()
9951 
    oprot.writeStructEnd()
9952 
 
9953 
  def validate(self):
9954 
    return
9955 
 
9956 
 
9957 
  def __repr__(self):
9958 
    L = ['%s=%r' % (key, value)
9959 
      for key, value in self.__dict__.iteritems()]
9960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9961 
 
9962 
  def __eq__(self, other):
9963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9964 
 
9965 
  def __ne__(self, other):
9966 
    return not (self == other)
9967 
 
9968 
class getOrderCount_result:
9969 
  """
9970 
  Attributes:
9971 
   - success
9972 
   - ex
9973 
  """
9974 
 
9975 
  thrift_spec = (
9976 
    (0, TType.I32, 'success', None, None, ), # 0
9977 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9978 
  )
9979 
 
9980 
  def __init__(self, success=None, ex=None,):
9981 
    self.success = success
9982 
    self.ex = ex
9983 
 
9984 
  def read(self, iprot):
9985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9987 
      return
9988 
    iprot.readStructBegin()
9989 
    while True:
9990 
      (fname, ftype, fid) = iprot.readFieldBegin()
9991 
      if ftype == TType.STOP:
9992 
        break
9993 
      if fid == 0:
9994 
        if ftype == TType.I32:
9995 
          self.success = iprot.readI32();
9996 
        else:
9997 
          iprot.skip(ftype)
9998 
      elif fid == 1:
9999 
        if ftype == TType.STRUCT:
10000 
          self.ex = TransactionServiceException()
10001 
          self.ex.read(iprot)
10002 
        else:
10003 
          iprot.skip(ftype)
10004 
      else:
10005 
        iprot.skip(ftype)
10006 
      iprot.readFieldEnd()
10007 
    iprot.readStructEnd()
10008 
 
10009 
  def write(self, oprot):
10010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10012 
      return
10013 
    oprot.writeStructBegin('getOrderCount_result')
10014 
    if self.success is not None:
10015 
      oprot.writeFieldBegin('success', TType.I32, 0)
10016 
      oprot.writeI32(self.success)
10017 
      oprot.writeFieldEnd()
10018 
    if self.ex is not None:
10019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10020 
      self.ex.write(oprot)
10021 
      oprot.writeFieldEnd()
10022 
    oprot.writeFieldStop()
10023 
    oprot.writeStructEnd()
10024 
 
10025 
  def validate(self):
10026 
    return
10027 
 
10028 
 
10029 
  def __repr__(self):
10030 
    L = ['%s=%r' % (key, value)
10031 
      for key, value in self.__dict__.iteritems()]
10032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10033 
 
10034 
  def __eq__(self, other):
10035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10036 
 
10037 
  def __ne__(self, other):
10038 
    return not (self == other)
10039 
 
999 varun.gupt 10040 
class getOrdersByBillingDate_args:
10041 
  """
10042 
  Attributes:
10043 
   - status
10044 
   - start_billing_date
10045 
   - end_billing_date
10046 
   - warehouse_id
10047 
  """
10048 
 
10049 
  thrift_spec = (
10050 
    None, # 0
10051 
    (1, TType.I32, 'status', None, None, ), # 1
10052 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10053 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10054 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10055 
  )
10056 
 
10057 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10058 
    self.status = status
10059 
    self.start_billing_date = start_billing_date
10060 
    self.end_billing_date = end_billing_date
10061 
    self.warehouse_id = warehouse_id
10062 
 
10063 
  def read(self, iprot):
10064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10066 
      return
10067 
    iprot.readStructBegin()
10068 
    while True:
10069 
      (fname, ftype, fid) = iprot.readFieldBegin()
10070 
      if ftype == TType.STOP:
10071 
        break
10072 
      if fid == 1:
10073 
        if ftype == TType.I32:
10074 
          self.status = iprot.readI32();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      elif fid == 2:
10078 
        if ftype == TType.I64:
10079 
          self.start_billing_date = iprot.readI64();
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      elif fid == 3:
10083 
        if ftype == TType.I64:
10084 
          self.end_billing_date = iprot.readI64();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 4:
10088 
        if ftype == TType.I64:
10089 
          self.warehouse_id = iprot.readI64();
10090 
        else:
10091 
          iprot.skip(ftype)
10092 
      else:
10093 
        iprot.skip(ftype)
10094 
      iprot.readFieldEnd()
10095 
    iprot.readStructEnd()
10096 
 
10097 
  def write(self, oprot):
10098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10100 
      return
10101 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10102 
    if self.status is not None:
999 varun.gupt 10103 
      oprot.writeFieldBegin('status', TType.I32, 1)
10104 
      oprot.writeI32(self.status)
10105 
      oprot.writeFieldEnd()
3431 rajveer 10106 
    if self.start_billing_date is not None:
999 varun.gupt 10107 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10108 
      oprot.writeI64(self.start_billing_date)
10109 
      oprot.writeFieldEnd()
3431 rajveer 10110 
    if self.end_billing_date is not None:
999 varun.gupt 10111 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10112 
      oprot.writeI64(self.end_billing_date)
10113 
      oprot.writeFieldEnd()
3431 rajveer 10114 
    if self.warehouse_id is not None:
999 varun.gupt 10115 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10116 
      oprot.writeI64(self.warehouse_id)
10117 
      oprot.writeFieldEnd()
10118 
    oprot.writeFieldStop()
10119 
    oprot.writeStructEnd()
10120 
 
3431 rajveer 10121 
  def validate(self):
10122 
    return
10123 
 
10124 
 
999 varun.gupt 10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
10136 
class getOrdersByBillingDate_result:
10137 
  """
10138 
  Attributes:
10139 
   - success
10140 
   - ex
10141 
  """
10142 
 
10143 
  thrift_spec = (
10144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10146 
  )
10147 
 
10148 
  def __init__(self, success=None, ex=None,):
10149 
    self.success = success
10150 
    self.ex = ex
10151 
 
10152 
  def read(self, iprot):
10153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10155 
      return
10156 
    iprot.readStructBegin()
10157 
    while True:
10158 
      (fname, ftype, fid) = iprot.readFieldBegin()
10159 
      if ftype == TType.STOP:
10160 
        break
10161 
      if fid == 0:
10162 
        if ftype == TType.LIST:
10163 
          self.success = []
6188 rajveer 10164 
          (_etype158, _size155) = iprot.readListBegin()
10165 
          for _i159 in xrange(_size155):
10166 
            _elem160 = Order()
10167 
            _elem160.read(iprot)
10168 
            self.success.append(_elem160)
999 varun.gupt 10169 
          iprot.readListEnd()
10170 
        else:
10171 
          iprot.skip(ftype)
10172 
      elif fid == 1:
10173 
        if ftype == TType.STRUCT:
10174 
          self.ex = TransactionServiceException()
10175 
          self.ex.read(iprot)
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10188 
    if self.success is not None:
999 varun.gupt 10189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10191 
      for iter161 in self.success:
10192 
        iter161.write(oprot)
999 varun.gupt 10193 
      oprot.writeListEnd()
10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.ex is not None:
999 varun.gupt 10196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10197 
      self.ex.write(oprot)
10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
3431 rajveer 10202 
  def validate(self):
10203 
    return
10204 
 
10205 
 
999 varun.gupt 10206 
  def __repr__(self):
10207 
    L = ['%s=%r' % (key, value)
10208 
      for key, value in self.__dict__.iteritems()]
10209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10210 
 
10211 
  def __eq__(self, other):
10212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10213 
 
10214 
  def __ne__(self, other):
10215 
    return not (self == other)
10216 
 
3427 chandransh 10217 
class getOrdersByShippingDate_args:
10218 
  """
10219 
  Attributes:
10220 
   - fromShippingDate
10221 
   - toShippingDate
10222 
   - providerId
10223 
   - warehouseId
3451 chandransh 10224 
   - cod
3427 chandransh 10225 
  """
10226 
 
10227 
  thrift_spec = (
10228 
    None, # 0
10229 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10230 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10231 
    (3, TType.I64, 'providerId', None, None, ), # 3
10232 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10233 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10234 
  )
10235 
 
3451 chandransh 10236 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10237 
    self.fromShippingDate = fromShippingDate
10238 
    self.toShippingDate = toShippingDate
10239 
    self.providerId = providerId
10240 
    self.warehouseId = warehouseId
3451 chandransh 10241 
    self.cod = cod
3427 chandransh 10242 
 
10243 
  def read(self, iprot):
10244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10246 
      return
10247 
    iprot.readStructBegin()
10248 
    while True:
10249 
      (fname, ftype, fid) = iprot.readFieldBegin()
10250 
      if ftype == TType.STOP:
10251 
        break
10252 
      if fid == 1:
10253 
        if ftype == TType.I64:
10254 
          self.fromShippingDate = iprot.readI64();
10255 
        else:
10256 
          iprot.skip(ftype)
10257 
      elif fid == 2:
10258 
        if ftype == TType.I64:
10259 
          self.toShippingDate = iprot.readI64();
10260 
        else:
10261 
          iprot.skip(ftype)
10262 
      elif fid == 3:
10263 
        if ftype == TType.I64:
10264 
          self.providerId = iprot.readI64();
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      elif fid == 4:
10268 
        if ftype == TType.I64:
10269 
          self.warehouseId = iprot.readI64();
10270 
        else:
10271 
          iprot.skip(ftype)
3451 chandransh 10272 
      elif fid == 5:
10273 
        if ftype == TType.BOOL:
10274 
          self.cod = iprot.readBool();
10275 
        else:
10276 
          iprot.skip(ftype)
3427 chandransh 10277 
      else:
10278 
        iprot.skip(ftype)
10279 
      iprot.readFieldEnd()
10280 
    iprot.readStructEnd()
10281 
 
10282 
  def write(self, oprot):
10283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10285 
      return
10286 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10287 
    if self.fromShippingDate is not None:
3427 chandransh 10288 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10289 
      oprot.writeI64(self.fromShippingDate)
10290 
      oprot.writeFieldEnd()
3431 rajveer 10291 
    if self.toShippingDate is not None:
3427 chandransh 10292 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10293 
      oprot.writeI64(self.toShippingDate)
10294 
      oprot.writeFieldEnd()
3431 rajveer 10295 
    if self.providerId is not None:
3427 chandransh 10296 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10297 
      oprot.writeI64(self.providerId)
10298 
      oprot.writeFieldEnd()
3431 rajveer 10299 
    if self.warehouseId is not None:
3427 chandransh 10300 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10301 
      oprot.writeI64(self.warehouseId)
10302 
      oprot.writeFieldEnd()
3451 chandransh 10303 
    if self.cod is not None:
10304 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10305 
      oprot.writeBool(self.cod)
10306 
      oprot.writeFieldEnd()
3427 chandransh 10307 
    oprot.writeFieldStop()
10308 
    oprot.writeStructEnd()
10309 
 
3431 rajveer 10310 
  def validate(self):
10311 
    return
10312 
 
10313 
 
3427 chandransh 10314 
  def __repr__(self):
10315 
    L = ['%s=%r' % (key, value)
10316 
      for key, value in self.__dict__.iteritems()]
10317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10318 
 
10319 
  def __eq__(self, other):
10320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10321 
 
10322 
  def __ne__(self, other):
10323 
    return not (self == other)
10324 
 
10325 
class getOrdersByShippingDate_result:
10326 
  """
10327 
  Attributes:
10328 
   - success
10329 
   - ex
10330 
  """
10331 
 
10332 
  thrift_spec = (
10333 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10335 
  )
10336 
 
10337 
  def __init__(self, success=None, ex=None,):
10338 
    self.success = success
10339 
    self.ex = ex
10340 
 
10341 
  def read(self, iprot):
10342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10344 
      return
10345 
    iprot.readStructBegin()
10346 
    while True:
10347 
      (fname, ftype, fid) = iprot.readFieldBegin()
10348 
      if ftype == TType.STOP:
10349 
        break
10350 
      if fid == 0:
10351 
        if ftype == TType.LIST:
10352 
          self.success = []
6188 rajveer 10353 
          (_etype165, _size162) = iprot.readListBegin()
10354 
          for _i166 in xrange(_size162):
10355 
            _elem167 = Order()
10356 
            _elem167.read(iprot)
10357 
            self.success.append(_elem167)
3427 chandransh 10358 
          iprot.readListEnd()
10359 
        else:
10360 
          iprot.skip(ftype)
10361 
      elif fid == 1:
10362 
        if ftype == TType.STRUCT:
10363 
          self.ex = TransactionServiceException()
10364 
          self.ex.read(iprot)
10365 
        else:
10366 
          iprot.skip(ftype)
10367 
      else:
10368 
        iprot.skip(ftype)
10369 
      iprot.readFieldEnd()
10370 
    iprot.readStructEnd()
10371 
 
10372 
  def write(self, oprot):
10373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10375 
      return
10376 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10377 
    if self.success is not None:
3427 chandransh 10378 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10379 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10380 
      for iter168 in self.success:
10381 
        iter168.write(oprot)
3427 chandransh 10382 
      oprot.writeListEnd()
10383 
      oprot.writeFieldEnd()
3431 rajveer 10384 
    if self.ex is not None:
3427 chandransh 10385 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10386 
      self.ex.write(oprot)
10387 
      oprot.writeFieldEnd()
10388 
    oprot.writeFieldStop()
10389 
    oprot.writeStructEnd()
10390 
 
3431 rajveer 10391 
  def validate(self):
10392 
    return
10393 
 
10394 
 
3427 chandransh 10395 
  def __repr__(self):
10396 
    L = ['%s=%r' % (key, value)
10397 
      for key, value in self.__dict__.iteritems()]
10398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10399 
 
10400 
  def __eq__(self, other):
10401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10402 
 
10403 
  def __ne__(self, other):
10404 
    return not (self == other)
10405 
 
1382 varun.gupt 10406 
class getReturnableOrdersForCustomer_args:
10407 
  """
10408 
  Attributes:
10409 
   - customer_id
10410 
   - limit
10411 
  """
10412 
 
10413 
  thrift_spec = (
10414 
    None, # 0
10415 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10416 
    (2, TType.I64, 'limit', None, None, ), # 2
10417 
  )
10418 
 
10419 
  def __init__(self, customer_id=None, limit=None,):
10420 
    self.customer_id = customer_id
10421 
    self.limit = limit
10422 
 
10423 
  def read(self, iprot):
10424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10426 
      return
10427 
    iprot.readStructBegin()
10428 
    while True:
10429 
      (fname, ftype, fid) = iprot.readFieldBegin()
10430 
      if ftype == TType.STOP:
10431 
        break
10432 
      if fid == 1:
10433 
        if ftype == TType.I64:
10434 
          self.customer_id = iprot.readI64();
10435 
        else:
10436 
          iprot.skip(ftype)
10437 
      elif fid == 2:
10438 
        if ftype == TType.I64:
10439 
          self.limit = iprot.readI64();
10440 
        else:
10441 
          iprot.skip(ftype)
10442 
      else:
10443 
        iprot.skip(ftype)
10444 
      iprot.readFieldEnd()
10445 
    iprot.readStructEnd()
10446 
 
10447 
  def write(self, oprot):
10448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10450 
      return
10451 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10452 
    if self.customer_id is not None:
1382 varun.gupt 10453 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10454 
      oprot.writeI64(self.customer_id)
10455 
      oprot.writeFieldEnd()
3431 rajveer 10456 
    if self.limit is not None:
1382 varun.gupt 10457 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10458 
      oprot.writeI64(self.limit)
10459 
      oprot.writeFieldEnd()
10460 
    oprot.writeFieldStop()
10461 
    oprot.writeStructEnd()
10462 
 
3431 rajveer 10463 
  def validate(self):
10464 
    return
10465 
 
10466 
 
1382 varun.gupt 10467 
  def __repr__(self):
10468 
    L = ['%s=%r' % (key, value)
10469 
      for key, value in self.__dict__.iteritems()]
10470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10471 
 
10472 
  def __eq__(self, other):
10473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10474 
 
10475 
  def __ne__(self, other):
10476 
    return not (self == other)
10477 
 
10478 
class getReturnableOrdersForCustomer_result:
10479 
  """
10480 
  Attributes:
10481 
   - success
10482 
   - ex
10483 
  """
10484 
 
10485 
  thrift_spec = (
10486 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10488 
  )
10489 
 
10490 
  def __init__(self, success=None, ex=None,):
10491 
    self.success = success
10492 
    self.ex = ex
10493 
 
10494 
  def read(self, iprot):
10495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10497 
      return
10498 
    iprot.readStructBegin()
10499 
    while True:
10500 
      (fname, ftype, fid) = iprot.readFieldBegin()
10501 
      if ftype == TType.STOP:
10502 
        break
10503 
      if fid == 0:
10504 
        if ftype == TType.LIST:
10505 
          self.success = []
6188 rajveer 10506 
          (_etype172, _size169) = iprot.readListBegin()
10507 
          for _i173 in xrange(_size169):
10508 
            _elem174 = iprot.readI64();
10509 
            self.success.append(_elem174)
1382 varun.gupt 10510 
          iprot.readListEnd()
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      elif fid == 1:
10514 
        if ftype == TType.STRUCT:
10515 
          self.ex = TransactionServiceException()
10516 
          self.ex.read(iprot)
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      else:
10520 
        iprot.skip(ftype)
10521 
      iprot.readFieldEnd()
10522 
    iprot.readStructEnd()
10523 
 
10524 
  def write(self, oprot):
10525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10527 
      return
10528 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10529 
    if self.success is not None:
1382 varun.gupt 10530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10531 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10532 
      for iter175 in self.success:
10533 
        oprot.writeI64(iter175)
1382 varun.gupt 10534 
      oprot.writeListEnd()
10535 
      oprot.writeFieldEnd()
3431 rajveer 10536 
    if self.ex is not None:
1382 varun.gupt 10537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10538 
      self.ex.write(oprot)
10539 
      oprot.writeFieldEnd()
10540 
    oprot.writeFieldStop()
10541 
    oprot.writeStructEnd()
10542 
 
3431 rajveer 10543 
  def validate(self):
10544 
    return
10545 
 
10546 
 
1382 varun.gupt 10547 
  def __repr__(self):
10548 
    L = ['%s=%r' % (key, value)
10549 
      for key, value in self.__dict__.iteritems()]
10550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10551 
 
10552 
  def __eq__(self, other):
10553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10554 
 
10555 
  def __ne__(self, other):
10556 
    return not (self == other)
10557 
 
10558 
class getCancellableOrdersForCustomer_args:
10559 
  """
10560 
  Attributes:
10561 
   - customer_id
10562 
   - limit
10563 
  """
10564 
 
10565 
  thrift_spec = (
10566 
    None, # 0
10567 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10568 
    (2, TType.I64, 'limit', None, None, ), # 2
10569 
  )
10570 
 
10571 
  def __init__(self, customer_id=None, limit=None,):
10572 
    self.customer_id = customer_id
10573 
    self.limit = limit
10574 
 
10575 
  def read(self, iprot):
10576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10578 
      return
10579 
    iprot.readStructBegin()
10580 
    while True:
10581 
      (fname, ftype, fid) = iprot.readFieldBegin()
10582 
      if ftype == TType.STOP:
10583 
        break
10584 
      if fid == 1:
10585 
        if ftype == TType.I64:
10586 
          self.customer_id = iprot.readI64();
10587 
        else:
10588 
          iprot.skip(ftype)
10589 
      elif fid == 2:
10590 
        if ftype == TType.I64:
10591 
          self.limit = iprot.readI64();
10592 
        else:
10593 
          iprot.skip(ftype)
10594 
      else:
10595 
        iprot.skip(ftype)
10596 
      iprot.readFieldEnd()
10597 
    iprot.readStructEnd()
10598 
 
10599 
  def write(self, oprot):
10600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10602 
      return
10603 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10604 
    if self.customer_id is not None:
1382 varun.gupt 10605 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10606 
      oprot.writeI64(self.customer_id)
10607 
      oprot.writeFieldEnd()
3431 rajveer 10608 
    if self.limit is not None:
1382 varun.gupt 10609 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10610 
      oprot.writeI64(self.limit)
10611 
      oprot.writeFieldEnd()
10612 
    oprot.writeFieldStop()
10613 
    oprot.writeStructEnd()
10614 
 
3431 rajveer 10615 
  def validate(self):
10616 
    return
10617 
 
10618 
 
1382 varun.gupt 10619 
  def __repr__(self):
10620 
    L = ['%s=%r' % (key, value)
10621 
      for key, value in self.__dict__.iteritems()]
10622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10623 
 
10624 
  def __eq__(self, other):
10625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10626 
 
10627 
  def __ne__(self, other):
10628 
    return not (self == other)
10629 
 
10630 
class getCancellableOrdersForCustomer_result:
10631 
  """
10632 
  Attributes:
10633 
   - success
10634 
   - ex
10635 
  """
10636 
 
10637 
  thrift_spec = (
10638 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10640 
  )
10641 
 
10642 
  def __init__(self, success=None, ex=None,):
10643 
    self.success = success
10644 
    self.ex = ex
10645 
 
10646 
  def read(self, iprot):
10647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10649 
      return
10650 
    iprot.readStructBegin()
10651 
    while True:
10652 
      (fname, ftype, fid) = iprot.readFieldBegin()
10653 
      if ftype == TType.STOP:
10654 
        break
10655 
      if fid == 0:
10656 
        if ftype == TType.LIST:
10657 
          self.success = []
6188 rajveer 10658 
          (_etype179, _size176) = iprot.readListBegin()
10659 
          for _i180 in xrange(_size176):
10660 
            _elem181 = iprot.readI64();
10661 
            self.success.append(_elem181)
1382 varun.gupt 10662 
          iprot.readListEnd()
10663 
        else:
10664 
          iprot.skip(ftype)
10665 
      elif fid == 1:
10666 
        if ftype == TType.STRUCT:
10667 
          self.ex = TransactionServiceException()
10668 
          self.ex.read(iprot)
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      else:
10672 
        iprot.skip(ftype)
10673 
      iprot.readFieldEnd()
10674 
    iprot.readStructEnd()
10675 
 
10676 
  def write(self, oprot):
10677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10679 
      return
10680 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10681 
    if self.success is not None:
1382 varun.gupt 10682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10683 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10684 
      for iter182 in self.success:
10685 
        oprot.writeI64(iter182)
1382 varun.gupt 10686 
      oprot.writeListEnd()
10687 
      oprot.writeFieldEnd()
3431 rajveer 10688 
    if self.ex is not None:
1382 varun.gupt 10689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10690 
      self.ex.write(oprot)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
3431 rajveer 10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
1382 varun.gupt 10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
483 rajveer 10710 
class changeOrderStatus_args:
94 ashish 10711 
  """
10712 
  Attributes:
483 rajveer 10713 
   - orderId
10714 
   - status
10715 
   - description
94 ashish 10716 
  """
10717 
 
10718 
  thrift_spec = (
10719 
    None, # 0
483 rajveer 10720 
    (1, TType.I64, 'orderId', None, None, ), # 1
10721 
    (2, TType.I32, 'status', None, None, ), # 2
10722 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10723 
  )
10724 
 
483 rajveer 10725 
  def __init__(self, orderId=None, status=None, description=None,):
10726 
    self.orderId = orderId
10727 
    self.status = status
10728 
    self.description = description
94 ashish 10729 
 
10730 
  def read(self, iprot):
10731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10733 
      return
10734 
    iprot.readStructBegin()
10735 
    while True:
10736 
      (fname, ftype, fid) = iprot.readFieldBegin()
10737 
      if ftype == TType.STOP:
10738 
        break
10739 
      if fid == 1:
10740 
        if ftype == TType.I64:
483 rajveer 10741 
          self.orderId = iprot.readI64();
94 ashish 10742 
        else:
10743 
          iprot.skip(ftype)
10744 
      elif fid == 2:
483 rajveer 10745 
        if ftype == TType.I32:
10746 
          self.status = iprot.readI32();
94 ashish 10747 
        else:
10748 
          iprot.skip(ftype)
483 rajveer 10749 
      elif fid == 3:
10750 
        if ftype == TType.STRING:
10751 
          self.description = iprot.readString();
10752 
        else:
10753 
          iprot.skip(ftype)
94 ashish 10754 
      else:
10755 
        iprot.skip(ftype)
10756 
      iprot.readFieldEnd()
10757 
    iprot.readStructEnd()
10758 
 
10759 
  def write(self, oprot):
10760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10762 
      return
483 rajveer 10763 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10764 
    if self.orderId is not None:
483 rajveer 10765 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10766 
      oprot.writeI64(self.orderId)
94 ashish 10767 
      oprot.writeFieldEnd()
3431 rajveer 10768 
    if self.status is not None:
483 rajveer 10769 
      oprot.writeFieldBegin('status', TType.I32, 2)
10770 
      oprot.writeI32(self.status)
94 ashish 10771 
      oprot.writeFieldEnd()
3431 rajveer 10772 
    if self.description is not None:
483 rajveer 10773 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10774 
      oprot.writeString(self.description)
10775 
      oprot.writeFieldEnd()
94 ashish 10776 
    oprot.writeFieldStop()
10777 
    oprot.writeStructEnd()
10778 
 
3431 rajveer 10779 
  def validate(self):
10780 
    return
10781 
 
10782 
 
94 ashish 10783 
  def __repr__(self):
10784 
    L = ['%s=%r' % (key, value)
10785 
      for key, value in self.__dict__.iteritems()]
10786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10787 
 
10788 
  def __eq__(self, other):
10789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10790 
 
10791 
  def __ne__(self, other):
10792 
    return not (self == other)
10793 
 
483 rajveer 10794 
class changeOrderStatus_result:
94 ashish 10795 
  """
10796 
  Attributes:
10797 
   - success
10798 
   - ex
10799 
  """
10800 
 
10801 
  thrift_spec = (
10802 
    (0, TType.BOOL, 'success', None, None, ), # 0
10803 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10804 
  )
10805 
 
10806 
  def __init__(self, success=None, ex=None,):
10807 
    self.success = success
10808 
    self.ex = ex
10809 
 
10810 
  def read(self, iprot):
10811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10813 
      return
10814 
    iprot.readStructBegin()
10815 
    while True:
10816 
      (fname, ftype, fid) = iprot.readFieldBegin()
10817 
      if ftype == TType.STOP:
10818 
        break
10819 
      if fid == 0:
10820 
        if ftype == TType.BOOL:
10821 
          self.success = iprot.readBool();
10822 
        else:
10823 
          iprot.skip(ftype)
10824 
      elif fid == 1:
10825 
        if ftype == TType.STRUCT:
10826 
          self.ex = TransactionServiceException()
10827 
          self.ex.read(iprot)
10828 
        else:
10829 
          iprot.skip(ftype)
10830 
      else:
10831 
        iprot.skip(ftype)
10832 
      iprot.readFieldEnd()
10833 
    iprot.readStructEnd()
10834 
 
10835 
  def write(self, oprot):
10836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10838 
      return
483 rajveer 10839 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10840 
    if self.success is not None:
94 ashish 10841 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10842 
      oprot.writeBool(self.success)
10843 
      oprot.writeFieldEnd()
3431 rajveer 10844 
    if self.ex is not None:
94 ashish 10845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10846 
      self.ex.write(oprot)
10847 
      oprot.writeFieldEnd()
10848 
    oprot.writeFieldStop()
10849 
    oprot.writeStructEnd()
10850 
 
3431 rajveer 10851 
  def validate(self):
10852 
    return
10853 
 
10854 
 
94 ashish 10855 
  def __repr__(self):
10856 
    L = ['%s=%r' % (key, value)
10857 
      for key, value in self.__dict__.iteritems()]
10858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10859 
 
10860 
  def __eq__(self, other):
10861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10862 
 
10863 
  def __ne__(self, other):
10864 
    return not (self == other)
10865 
 
3064 chandransh 10866 
class getOrdersForTransaction_args:
494 rajveer 10867 
  """
10868 
  Attributes:
3064 chandransh 10869 
   - transactionId
10870 
   - customerId
494 rajveer 10871 
  """
10872 
 
10873 
  thrift_spec = (
10874 
    None, # 0
3064 chandransh 10875 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10876 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10877 
  )
10878 
 
3064 chandransh 10879 
  def __init__(self, transactionId=None, customerId=None,):
10880 
    self.transactionId = transactionId
10881 
    self.customerId = customerId
494 rajveer 10882 
 
10883 
  def read(self, iprot):
10884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10886 
      return
10887 
    iprot.readStructBegin()
10888 
    while True:
10889 
      (fname, ftype, fid) = iprot.readFieldBegin()
10890 
      if ftype == TType.STOP:
10891 
        break
10892 
      if fid == 1:
10893 
        if ftype == TType.I64:
3064 chandransh 10894 
          self.transactionId = iprot.readI64();
494 rajveer 10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      elif fid == 2:
3064 chandransh 10898 
        if ftype == TType.I64:
10899 
          self.customerId = iprot.readI64();
494 rajveer 10900 
        else:
10901 
          iprot.skip(ftype)
10902 
      else:
10903 
        iprot.skip(ftype)
10904 
      iprot.readFieldEnd()
10905 
    iprot.readStructEnd()
10906 
 
10907 
  def write(self, oprot):
10908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10910 
      return
3064 chandransh 10911 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10912 
    if self.transactionId is not None:
3064 chandransh 10913 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10914 
      oprot.writeI64(self.transactionId)
494 rajveer 10915 
      oprot.writeFieldEnd()
3431 rajveer 10916 
    if self.customerId is not None:
3064 chandransh 10917 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10918 
      oprot.writeI64(self.customerId)
494 rajveer 10919 
      oprot.writeFieldEnd()
10920 
    oprot.writeFieldStop()
10921 
    oprot.writeStructEnd()
10922 
 
3431 rajveer 10923 
  def validate(self):
10924 
    return
10925 
 
10926 
 
494 rajveer 10927 
  def __repr__(self):
10928 
    L = ['%s=%r' % (key, value)
10929 
      for key, value in self.__dict__.iteritems()]
10930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10931 
 
10932 
  def __eq__(self, other):
10933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10934 
 
10935 
  def __ne__(self, other):
10936 
    return not (self == other)
10937 
 
3064 chandransh 10938 
class getOrdersForTransaction_result:
494 rajveer 10939 
  """
10940 
  Attributes:
10941 
   - success
10942 
   - ex
10943 
  """
10944 
 
10945 
  thrift_spec = (
3064 chandransh 10946 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10947 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10948 
  )
10949 
 
10950 
  def __init__(self, success=None, ex=None,):
10951 
    self.success = success
10952 
    self.ex = ex
10953 
 
10954 
  def read(self, iprot):
10955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10957 
      return
10958 
    iprot.readStructBegin()
10959 
    while True:
10960 
      (fname, ftype, fid) = iprot.readFieldBegin()
10961 
      if ftype == TType.STOP:
10962 
        break
10963 
      if fid == 0:
3064 chandransh 10964 
        if ftype == TType.LIST:
10965 
          self.success = []
6188 rajveer 10966 
          (_etype186, _size183) = iprot.readListBegin()
10967 
          for _i187 in xrange(_size183):
10968 
            _elem188 = Order()
10969 
            _elem188.read(iprot)
10970 
            self.success.append(_elem188)
3064 chandransh 10971 
          iprot.readListEnd()
494 rajveer 10972 
        else:
10973 
          iprot.skip(ftype)
10974 
      elif fid == 1:
10975 
        if ftype == TType.STRUCT:
10976 
          self.ex = TransactionServiceException()
10977 
          self.ex.read(iprot)
10978 
        else:
10979 
          iprot.skip(ftype)
10980 
      else:
10981 
        iprot.skip(ftype)
10982 
      iprot.readFieldEnd()
10983 
    iprot.readStructEnd()
10984 
 
10985 
  def write(self, oprot):
10986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10988 
      return
3064 chandransh 10989 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10990 
    if self.success is not None:
3064 chandransh 10991 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10992 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10993 
      for iter189 in self.success:
10994 
        iter189.write(oprot)
3064 chandransh 10995 
      oprot.writeListEnd()
494 rajveer 10996 
      oprot.writeFieldEnd()
3431 rajveer 10997 
    if self.ex is not None:
494 rajveer 10998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10999 
      self.ex.write(oprot)
11000 
      oprot.writeFieldEnd()
11001 
    oprot.writeFieldStop()
11002 
    oprot.writeStructEnd()
11003 
 
3431 rajveer 11004 
  def validate(self):
11005 
    return
11006 
 
11007 
 
494 rajveer 11008 
  def __repr__(self):
11009 
    L = ['%s=%r' % (key, value)
11010 
      for key, value in self.__dict__.iteritems()]
11011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11012 
 
11013 
  def __eq__(self, other):
11014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11015 
 
11016 
  def __ne__(self, other):
11017 
    return not (self == other)
11018 
 
3064 chandransh 11019 
class getOrdersForCustomer_args:
1149 chandransh 11020 
  """
11021 
  Attributes:
3064 chandransh 11022 
   - customerId
11023 
   - from_date
11024 
   - to_date
11025 
   - statuses
1149 chandransh 11026 
  """
11027 
 
11028 
  thrift_spec = (
11029 
    None, # 0
3064 chandransh 11030 
    (1, TType.I64, 'customerId', None, None, ), # 1
11031 
    (2, TType.I64, 'from_date', None, None, ), # 2
11032 
    (3, TType.I64, 'to_date', None, None, ), # 3
11033 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11034 
  )
11035 
 
3064 chandransh 11036 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11037 
    self.customerId = customerId
11038 
    self.from_date = from_date
11039 
    self.to_date = to_date
11040 
    self.statuses = statuses
1149 chandransh 11041 
 
11042 
  def read(self, iprot):
11043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11045 
      return
11046 
    iprot.readStructBegin()
11047 
    while True:
11048 
      (fname, ftype, fid) = iprot.readFieldBegin()
11049 
      if ftype == TType.STOP:
11050 
        break
11051 
      if fid == 1:
11052 
        if ftype == TType.I64:
3064 chandransh 11053 
          self.customerId = iprot.readI64();
1149 chandransh 11054 
        else:
11055 
          iprot.skip(ftype)
11056 
      elif fid == 2:
11057 
        if ftype == TType.I64:
3064 chandransh 11058 
          self.from_date = iprot.readI64();
1149 chandransh 11059 
        else:
11060 
          iprot.skip(ftype)
2783 chandransh 11061 
      elif fid == 3:
11062 
        if ftype == TType.I64:
3064 chandransh 11063 
          self.to_date = iprot.readI64();
2783 chandransh 11064 
        else:
11065 
          iprot.skip(ftype)
11066 
      elif fid == 4:
3064 chandransh 11067 
        if ftype == TType.LIST:
11068 
          self.statuses = []
6188 rajveer 11069 
          (_etype193, _size190) = iprot.readListBegin()
11070 
          for _i194 in xrange(_size190):
11071 
            _elem195 = iprot.readI32();
11072 
            self.statuses.append(_elem195)
3064 chandransh 11073 
          iprot.readListEnd()
2783 chandransh 11074 
        else:
11075 
          iprot.skip(ftype)
1149 chandransh 11076 
      else:
11077 
        iprot.skip(ftype)
11078 
      iprot.readFieldEnd()
11079 
    iprot.readStructEnd()
11080 
 
11081 
  def write(self, oprot):
11082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11084 
      return
3064 chandransh 11085 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11086 
    if self.customerId is not None:
3064 chandransh 11087 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11088 
      oprot.writeI64(self.customerId)
1149 chandransh 11089 
      oprot.writeFieldEnd()
3431 rajveer 11090 
    if self.from_date is not None:
3064 chandransh 11091 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11092 
      oprot.writeI64(self.from_date)
1149 chandransh 11093 
      oprot.writeFieldEnd()
3431 rajveer 11094 
    if self.to_date is not None:
3064 chandransh 11095 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11096 
      oprot.writeI64(self.to_date)
2783 chandransh 11097 
      oprot.writeFieldEnd()
3431 rajveer 11098 
    if self.statuses is not None:
3064 chandransh 11099 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11100 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11101 
      for iter196 in self.statuses:
11102 
        oprot.writeI32(iter196)
3064 chandransh 11103 
      oprot.writeListEnd()
2783 chandransh 11104 
      oprot.writeFieldEnd()
1149 chandransh 11105 
    oprot.writeFieldStop()
11106 
    oprot.writeStructEnd()
11107 
 
3431 rajveer 11108 
  def validate(self):
11109 
    return
11110 
 
11111 
 
1149 chandransh 11112 
  def __repr__(self):
11113 
    L = ['%s=%r' % (key, value)
11114 
      for key, value in self.__dict__.iteritems()]
11115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11116 
 
11117 
  def __eq__(self, other):
11118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11119 
 
11120 
  def __ne__(self, other):
11121 
    return not (self == other)
11122 
 
3064 chandransh 11123 
class getOrdersForCustomer_result:
1149 chandransh 11124 
  """
11125 
  Attributes:
11126 
   - success
11127 
   - ex
11128 
  """
11129 
 
11130 
  thrift_spec = (
3064 chandransh 11131 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11133 
  )
11134 
 
11135 
  def __init__(self, success=None, ex=None,):
11136 
    self.success = success
11137 
    self.ex = ex
11138 
 
11139 
  def read(self, iprot):
11140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11142 
      return
11143 
    iprot.readStructBegin()
11144 
    while True:
11145 
      (fname, ftype, fid) = iprot.readFieldBegin()
11146 
      if ftype == TType.STOP:
11147 
        break
11148 
      if fid == 0:
3064 chandransh 11149 
        if ftype == TType.LIST:
11150 
          self.success = []
6188 rajveer 11151 
          (_etype200, _size197) = iprot.readListBegin()
11152 
          for _i201 in xrange(_size197):
11153 
            _elem202 = Order()
11154 
            _elem202.read(iprot)
11155 
            self.success.append(_elem202)
3064 chandransh 11156 
          iprot.readListEnd()
1149 chandransh 11157 
        else:
11158 
          iprot.skip(ftype)
11159 
      elif fid == 1:
11160 
        if ftype == TType.STRUCT:
11161 
          self.ex = TransactionServiceException()
11162 
          self.ex.read(iprot)
11163 
        else:
11164 
          iprot.skip(ftype)
11165 
      else:
11166 
        iprot.skip(ftype)
11167 
      iprot.readFieldEnd()
11168 
    iprot.readStructEnd()
11169 
 
11170 
  def write(self, oprot):
11171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11173 
      return
3064 chandransh 11174 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11175 
    if self.success is not None:
3064 chandransh 11176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11178 
      for iter203 in self.success:
11179 
        iter203.write(oprot)
3064 chandransh 11180 
      oprot.writeListEnd()
1149 chandransh 11181 
      oprot.writeFieldEnd()
3431 rajveer 11182 
    if self.ex is not None:
1149 chandransh 11183 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11184 
      self.ex.write(oprot)
11185 
      oprot.writeFieldEnd()
11186 
    oprot.writeFieldStop()
11187 
    oprot.writeStructEnd()
11188 
 
3431 rajveer 11189 
  def validate(self):
11190 
    return
11191 
 
11192 
 
1149 chandransh 11193 
  def __repr__(self):
11194 
    L = ['%s=%r' % (key, value)
11195 
      for key, value in self.__dict__.iteritems()]
11196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11197 
 
11198 
  def __eq__(self, other):
11199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11200 
 
11201 
  def __ne__(self, other):
11202 
    return not (self == other)
11203 
 
3064 chandransh 11204 
class createOrder_args:
921 rajveer 11205 
  """
11206 
  Attributes:
3064 chandransh 11207 
   - order
921 rajveer 11208 
  """
11209 
 
11210 
  thrift_spec = (
11211 
    None, # 0
3064 chandransh 11212 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11213 
  )
11214 
 
3064 chandransh 11215 
  def __init__(self, order=None,):
11216 
    self.order = order
921 rajveer 11217 
 
11218 
  def read(self, iprot):
11219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11221 
      return
11222 
    iprot.readStructBegin()
11223 
    while True:
11224 
      (fname, ftype, fid) = iprot.readFieldBegin()
11225 
      if ftype == TType.STOP:
11226 
        break
11227 
      if fid == 1:
3064 chandransh 11228 
        if ftype == TType.STRUCT:
11229 
          self.order = Order()
11230 
          self.order.read(iprot)
921 rajveer 11231 
        else:
11232 
          iprot.skip(ftype)
11233 
      else:
11234 
        iprot.skip(ftype)
11235 
      iprot.readFieldEnd()
11236 
    iprot.readStructEnd()
11237 
 
11238 
  def write(self, oprot):
11239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11241 
      return
3064 chandransh 11242 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11243 
    if self.order is not None:
3064 chandransh 11244 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11245 
      self.order.write(oprot)
921 rajveer 11246 
      oprot.writeFieldEnd()
11247 
    oprot.writeFieldStop()
11248 
    oprot.writeStructEnd()
11249 
 
3431 rajveer 11250 
  def validate(self):
11251 
    return
11252 
 
11253 
 
921 rajveer 11254 
  def __repr__(self):
11255 
    L = ['%s=%r' % (key, value)
11256 
      for key, value in self.__dict__.iteritems()]
11257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11258 
 
11259 
  def __eq__(self, other):
11260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11261 
 
11262 
  def __ne__(self, other):
11263 
    return not (self == other)
11264 
 
3064 chandransh 11265 
class createOrder_result:
921 rajveer 11266 
  """
11267 
  Attributes:
11268 
   - success
11269 
   - ex
11270 
  """
11271 
 
11272 
  thrift_spec = (
3064 chandransh 11273 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11275 
  )
11276 
 
11277 
  def __init__(self, success=None, ex=None,):
11278 
    self.success = success
11279 
    self.ex = ex
11280 
 
11281 
  def read(self, iprot):
11282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11284 
      return
11285 
    iprot.readStructBegin()
11286 
    while True:
11287 
      (fname, ftype, fid) = iprot.readFieldBegin()
11288 
      if ftype == TType.STOP:
11289 
        break
11290 
      if fid == 0:
3064 chandransh 11291 
        if ftype == TType.I64:
11292 
          self.success = iprot.readI64();
921 rajveer 11293 
        else:
11294 
          iprot.skip(ftype)
11295 
      elif fid == 1:
11296 
        if ftype == TType.STRUCT:
11297 
          self.ex = TransactionServiceException()
11298 
          self.ex.read(iprot)
11299 
        else:
11300 
          iprot.skip(ftype)
11301 
      else:
11302 
        iprot.skip(ftype)
11303 
      iprot.readFieldEnd()
11304 
    iprot.readStructEnd()
11305 
 
11306 
  def write(self, oprot):
11307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11309 
      return
3064 chandransh 11310 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11311 
    if self.success is not None:
3064 chandransh 11312 
      oprot.writeFieldBegin('success', TType.I64, 0)
11313 
      oprot.writeI64(self.success)
921 rajveer 11314 
      oprot.writeFieldEnd()
3431 rajveer 11315 
    if self.ex is not None:
921 rajveer 11316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11317 
      self.ex.write(oprot)
11318 
      oprot.writeFieldEnd()
11319 
    oprot.writeFieldStop()
11320 
    oprot.writeStructEnd()
11321 
 
3431 rajveer 11322 
  def validate(self):
11323 
    return
11324 
 
11325 
 
921 rajveer 11326 
  def __repr__(self):
11327 
    L = ['%s=%r' % (key, value)
11328 
      for key, value in self.__dict__.iteritems()]
11329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11330 
 
11331 
  def __eq__(self, other):
11332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11333 
 
11334 
  def __ne__(self, other):
11335 
    return not (self == other)
11336 
 
3064 chandransh 11337 
class getOrder_args:
921 rajveer 11338 
  """
11339 
  Attributes:
3064 chandransh 11340 
   - id
921 rajveer 11341 
  """
11342 
 
11343 
  thrift_spec = (
11344 
    None, # 0
3064 chandransh 11345 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11346 
  )
11347 
 
3064 chandransh 11348 
  def __init__(self, id=None,):
11349 
    self.id = id
921 rajveer 11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      if fid == 1:
11361 
        if ftype == TType.I64:
3064 chandransh 11362 
          self.id = iprot.readI64();
921 rajveer 11363 
        else:
11364 
          iprot.skip(ftype)
11365 
      else:
11366 
        iprot.skip(ftype)
11367 
      iprot.readFieldEnd()
11368 
    iprot.readStructEnd()
11369 
 
11370 
  def write(self, oprot):
11371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11373 
      return
3064 chandransh 11374 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11375 
    if self.id is not None:
3064 chandransh 11376 
      oprot.writeFieldBegin('id', TType.I64, 1)
11377 
      oprot.writeI64(self.id)
921 rajveer 11378 
      oprot.writeFieldEnd()
11379 
    oprot.writeFieldStop()
11380 
    oprot.writeStructEnd()
11381 
 
3431 rajveer 11382 
  def validate(self):
11383 
    return
11384 
 
11385 
 
921 rajveer 11386 
  def __repr__(self):
11387 
    L = ['%s=%r' % (key, value)
11388 
      for key, value in self.__dict__.iteritems()]
11389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11390 
 
11391 
  def __eq__(self, other):
11392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11393 
 
11394 
  def __ne__(self, other):
11395 
    return not (self == other)
11396 
 
3064 chandransh 11397 
class getOrder_result:
921 rajveer 11398 
  """
11399 
  Attributes:
11400 
   - success
11401 
   - ex
11402 
  """
11403 
 
11404 
  thrift_spec = (
3064 chandransh 11405 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11406 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11407 
  )
11408 
 
11409 
  def __init__(self, success=None, ex=None,):
11410 
    self.success = success
11411 
    self.ex = ex
11412 
 
11413 
  def read(self, iprot):
11414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11416 
      return
11417 
    iprot.readStructBegin()
11418 
    while True:
11419 
      (fname, ftype, fid) = iprot.readFieldBegin()
11420 
      if ftype == TType.STOP:
11421 
        break
11422 
      if fid == 0:
3064 chandransh 11423 
        if ftype == TType.STRUCT:
11424 
          self.success = Order()
11425 
          self.success.read(iprot)
921 rajveer 11426 
        else:
11427 
          iprot.skip(ftype)
11428 
      elif fid == 1:
11429 
        if ftype == TType.STRUCT:
11430 
          self.ex = TransactionServiceException()
11431 
          self.ex.read(iprot)
11432 
        else:
11433 
          iprot.skip(ftype)
11434 
      else:
11435 
        iprot.skip(ftype)
11436 
      iprot.readFieldEnd()
11437 
    iprot.readStructEnd()
11438 
 
11439 
  def write(self, oprot):
11440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11442 
      return
3064 chandransh 11443 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11444 
    if self.success is not None:
3064 chandransh 11445 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11446 
      self.success.write(oprot)
921 rajveer 11447 
      oprot.writeFieldEnd()
3431 rajveer 11448 
    if self.ex is not None:
921 rajveer 11449 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11450 
      self.ex.write(oprot)
11451 
      oprot.writeFieldEnd()
11452 
    oprot.writeFieldStop()
11453 
    oprot.writeStructEnd()
11454 
 
3431 rajveer 11455 
  def validate(self):
11456 
    return
11457 
 
11458 
 
921 rajveer 11459 
  def __repr__(self):
11460 
    L = ['%s=%r' % (key, value)
11461 
      for key, value in self.__dict__.iteritems()]
11462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11463 
 
11464 
  def __eq__(self, other):
11465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11466 
 
11467 
  def __ne__(self, other):
11468 
    return not (self == other)
11469 
 
3064 chandransh 11470 
class getLineItemsForOrder_args:
94 ashish 11471 
  """
11472 
  Attributes:
3064 chandransh 11473 
   - orderId
94 ashish 11474 
  """
11475 
 
11476 
  thrift_spec = (
11477 
    None, # 0
3064 chandransh 11478 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11479 
  )
11480 
 
3064 chandransh 11481 
  def __init__(self, orderId=None,):
11482 
    self.orderId = orderId
94 ashish 11483 
 
11484 
  def read(self, iprot):
11485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11487 
      return
11488 
    iprot.readStructBegin()
11489 
    while True:
11490 
      (fname, ftype, fid) = iprot.readFieldBegin()
11491 
      if ftype == TType.STOP:
11492 
        break
11493 
      if fid == 1:
11494 
        if ftype == TType.I64:
3064 chandransh 11495 
          self.orderId = iprot.readI64();
94 ashish 11496 
        else:
11497 
          iprot.skip(ftype)
11498 
      else:
11499 
        iprot.skip(ftype)
11500 
      iprot.readFieldEnd()
11501 
    iprot.readStructEnd()
11502 
 
11503 
  def write(self, oprot):
11504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11506 
      return
3064 chandransh 11507 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11508 
    if self.orderId is not None:
3064 chandransh 11509 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11510 
      oprot.writeI64(self.orderId)
94 ashish 11511 
      oprot.writeFieldEnd()
11512 
    oprot.writeFieldStop()
11513 
    oprot.writeStructEnd()
11514 
 
3431 rajveer 11515 
  def validate(self):
11516 
    return
11517 
 
11518 
 
94 ashish 11519 
  def __repr__(self):
11520 
    L = ['%s=%r' % (key, value)
11521 
      for key, value in self.__dict__.iteritems()]
11522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11523 
 
11524 
  def __eq__(self, other):
11525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11526 
 
11527 
  def __ne__(self, other):
11528 
    return not (self == other)
11529 
 
3064 chandransh 11530 
class getLineItemsForOrder_result:
94 ashish 11531 
  """
11532 
  Attributes:
11533 
   - success
11534 
   - ex
11535 
  """
11536 
 
11537 
  thrift_spec = (
3064 chandransh 11538 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11540 
  )
11541 
 
11542 
  def __init__(self, success=None, ex=None,):
11543 
    self.success = success
11544 
    self.ex = ex
11545 
 
11546 
  def read(self, iprot):
11547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11549 
      return
11550 
    iprot.readStructBegin()
11551 
    while True:
11552 
      (fname, ftype, fid) = iprot.readFieldBegin()
11553 
      if ftype == TType.STOP:
11554 
        break
11555 
      if fid == 0:
483 rajveer 11556 
        if ftype == TType.LIST:
11557 
          self.success = []
6188 rajveer 11558 
          (_etype207, _size204) = iprot.readListBegin()
11559 
          for _i208 in xrange(_size204):
11560 
            _elem209 = LineItem()
11561 
            _elem209.read(iprot)
11562 
            self.success.append(_elem209)
483 rajveer 11563 
          iprot.readListEnd()
94 ashish 11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      elif fid == 1:
11567 
        if ftype == TType.STRUCT:
11568 
          self.ex = TransactionServiceException()
11569 
          self.ex.read(iprot)
11570 
        else:
11571 
          iprot.skip(ftype)
11572 
      else:
11573 
        iprot.skip(ftype)
11574 
      iprot.readFieldEnd()
11575 
    iprot.readStructEnd()
11576 
 
11577 
  def write(self, oprot):
11578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11580 
      return
3064 chandransh 11581 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11582 
    if self.success is not None:
483 rajveer 11583 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11584 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11585 
      for iter210 in self.success:
11586 
        iter210.write(oprot)
483 rajveer 11587 
      oprot.writeListEnd()
94 ashish 11588 
      oprot.writeFieldEnd()
3431 rajveer 11589 
    if self.ex is not None:
94 ashish 11590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11591 
      self.ex.write(oprot)
11592 
      oprot.writeFieldEnd()
11593 
    oprot.writeFieldStop()
11594 
    oprot.writeStructEnd()
11595 
 
3431 rajveer 11596 
  def validate(self):
11597 
    return
11598 
 
11599 
 
94 ashish 11600 
  def __repr__(self):
11601 
    L = ['%s=%r' % (key, value)
11602 
      for key, value in self.__dict__.iteritems()]
11603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11604 
 
11605 
  def __eq__(self, other):
11606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11607 
 
11608 
  def __ne__(self, other):
11609 
    return not (self == other)
11610 
 
4999 phani.kuma 11611 
class getOrderList_args:
11612 
  """
11613 
  Attributes:
11614 
   - order_ids
11615 
  """
11616 
 
11617 
  thrift_spec = (
11618 
    None, # 0
11619 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11620 
  )
11621 
 
11622 
  def __init__(self, order_ids=None,):
11623 
    self.order_ids = order_ids
11624 
 
11625 
  def read(self, iprot):
11626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11628 
      return
11629 
    iprot.readStructBegin()
11630 
    while True:
11631 
      (fname, ftype, fid) = iprot.readFieldBegin()
11632 
      if ftype == TType.STOP:
11633 
        break
11634 
      if fid == 1:
11635 
        if ftype == TType.LIST:
11636 
          self.order_ids = []
6188 rajveer 11637 
          (_etype214, _size211) = iprot.readListBegin()
11638 
          for _i215 in xrange(_size211):
11639 
            _elem216 = iprot.readI64();
11640 
            self.order_ids.append(_elem216)
4999 phani.kuma 11641 
          iprot.readListEnd()
11642 
        else:
11643 
          iprot.skip(ftype)
11644 
      else:
11645 
        iprot.skip(ftype)
11646 
      iprot.readFieldEnd()
11647 
    iprot.readStructEnd()
11648 
 
11649 
  def write(self, oprot):
11650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11652 
      return
11653 
    oprot.writeStructBegin('getOrderList_args')
11654 
    if self.order_ids is not None:
11655 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11656 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11657 
      for iter217 in self.order_ids:
11658 
        oprot.writeI64(iter217)
4999 phani.kuma 11659 
      oprot.writeListEnd()
11660 
      oprot.writeFieldEnd()
11661 
    oprot.writeFieldStop()
11662 
    oprot.writeStructEnd()
11663 
 
11664 
  def validate(self):
11665 
    return
11666 
 
11667 
 
11668 
  def __repr__(self):
11669 
    L = ['%s=%r' % (key, value)
11670 
      for key, value in self.__dict__.iteritems()]
11671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11672 
 
11673 
  def __eq__(self, other):
11674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11675 
 
11676 
  def __ne__(self, other):
11677 
    return not (self == other)
11678 
 
11679 
class getOrderList_result:
11680 
  """
11681 
  Attributes:
11682 
   - success
11683 
  """
11684 
 
11685 
  thrift_spec = (
11686 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11687 
  )
11688 
 
11689 
  def __init__(self, success=None,):
11690 
    self.success = success
11691 
 
11692 
  def read(self, iprot):
11693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11695 
      return
11696 
    iprot.readStructBegin()
11697 
    while True:
11698 
      (fname, ftype, fid) = iprot.readFieldBegin()
11699 
      if ftype == TType.STOP:
11700 
        break
11701 
      if fid == 0:
11702 
        if ftype == TType.LIST:
11703 
          self.success = []
6188 rajveer 11704 
          (_etype221, _size218) = iprot.readListBegin()
11705 
          for _i222 in xrange(_size218):
11706 
            _elem223 = Order()
11707 
            _elem223.read(iprot)
11708 
            self.success.append(_elem223)
4999 phani.kuma 11709 
          iprot.readListEnd()
11710 
        else:
11711 
          iprot.skip(ftype)
11712 
      else:
11713 
        iprot.skip(ftype)
11714 
      iprot.readFieldEnd()
11715 
    iprot.readStructEnd()
11716 
 
11717 
  def write(self, oprot):
11718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11720 
      return
11721 
    oprot.writeStructBegin('getOrderList_result')
11722 
    if self.success is not None:
11723 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11724 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11725 
      for iter224 in self.success:
11726 
        iter224.write(oprot)
4999 phani.kuma 11727 
      oprot.writeListEnd()
11728 
      oprot.writeFieldEnd()
11729 
    oprot.writeFieldStop()
11730 
    oprot.writeStructEnd()
11731 
 
11732 
  def validate(self):
11733 
    return
11734 
 
11735 
 
11736 
  def __repr__(self):
11737 
    L = ['%s=%r' % (key, value)
11738 
      for key, value in self.__dict__.iteritems()]
11739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11740 
 
11741 
  def __eq__(self, other):
11742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11743 
 
11744 
  def __ne__(self, other):
11745 
    return not (self == other)
11746 
 
5386 phani.kuma 11747 
class getOrderListForVendor_args:
11748 
  """
11749 
  Attributes:
11750 
   - order_ids
11751 
   - vendorId
11752 
  """
11753 
 
11754 
  thrift_spec = (
11755 
    None, # 0
11756 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11757 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11758 
  )
11759 
 
11760 
  def __init__(self, order_ids=None, vendorId=None,):
11761 
    self.order_ids = order_ids
11762 
    self.vendorId = vendorId
11763 
 
11764 
  def read(self, iprot):
11765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11767 
      return
11768 
    iprot.readStructBegin()
11769 
    while True:
11770 
      (fname, ftype, fid) = iprot.readFieldBegin()
11771 
      if ftype == TType.STOP:
11772 
        break
11773 
      if fid == 1:
11774 
        if ftype == TType.LIST:
11775 
          self.order_ids = []
6188 rajveer 11776 
          (_etype228, _size225) = iprot.readListBegin()
11777 
          for _i229 in xrange(_size225):
11778 
            _elem230 = iprot.readI64();
11779 
            self.order_ids.append(_elem230)
5386 phani.kuma 11780 
          iprot.readListEnd()
11781 
        else:
11782 
          iprot.skip(ftype)
11783 
      elif fid == 2:
11784 
        if ftype == TType.I64:
11785 
          self.vendorId = iprot.readI64();
11786 
        else:
11787 
          iprot.skip(ftype)
11788 
      else:
11789 
        iprot.skip(ftype)
11790 
      iprot.readFieldEnd()
11791 
    iprot.readStructEnd()
11792 
 
11793 
  def write(self, oprot):
11794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11796 
      return
11797 
    oprot.writeStructBegin('getOrderListForVendor_args')
11798 
    if self.order_ids is not None:
11799 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11800 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11801 
      for iter231 in self.order_ids:
11802 
        oprot.writeI64(iter231)
5386 phani.kuma 11803 
      oprot.writeListEnd()
11804 
      oprot.writeFieldEnd()
11805 
    if self.vendorId is not None:
11806 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11807 
      oprot.writeI64(self.vendorId)
11808 
      oprot.writeFieldEnd()
11809 
    oprot.writeFieldStop()
11810 
    oprot.writeStructEnd()
11811 
 
11812 
  def validate(self):
11813 
    return
11814 
 
11815 
 
11816 
  def __repr__(self):
11817 
    L = ['%s=%r' % (key, value)
11818 
      for key, value in self.__dict__.iteritems()]
11819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11820 
 
11821 
  def __eq__(self, other):
11822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11823 
 
11824 
  def __ne__(self, other):
11825 
    return not (self == other)
11826 
 
11827 
class getOrderListForVendor_result:
11828 
  """
11829 
  Attributes:
11830 
   - success
11831 
  """
11832 
 
11833 
  thrift_spec = (
11834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11835 
  )
11836 
 
11837 
  def __init__(self, success=None,):
11838 
    self.success = success
11839 
 
11840 
  def read(self, iprot):
11841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11843 
      return
11844 
    iprot.readStructBegin()
11845 
    while True:
11846 
      (fname, ftype, fid) = iprot.readFieldBegin()
11847 
      if ftype == TType.STOP:
11848 
        break
11849 
      if fid == 0:
11850 
        if ftype == TType.LIST:
11851 
          self.success = []
6188 rajveer 11852 
          (_etype235, _size232) = iprot.readListBegin()
11853 
          for _i236 in xrange(_size232):
11854 
            _elem237 = Order()
11855 
            _elem237.read(iprot)
11856 
            self.success.append(_elem237)
5386 phani.kuma 11857 
          iprot.readListEnd()
11858 
        else:
11859 
          iprot.skip(ftype)
11860 
      else:
11861 
        iprot.skip(ftype)
11862 
      iprot.readFieldEnd()
11863 
    iprot.readStructEnd()
11864 
 
11865 
  def write(self, oprot):
11866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11868 
      return
11869 
    oprot.writeStructBegin('getOrderListForVendor_result')
11870 
    if self.success is not None:
11871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11873 
      for iter238 in self.success:
11874 
        iter238.write(oprot)
5386 phani.kuma 11875 
      oprot.writeListEnd()
11876 
      oprot.writeFieldEnd()
11877 
    oprot.writeFieldStop()
11878 
    oprot.writeStructEnd()
11879 
 
11880 
  def validate(self):
11881 
    return
11882 
 
11883 
 
11884 
  def __repr__(self):
11885 
    L = ['%s=%r' % (key, value)
11886 
      for key, value in self.__dict__.iteritems()]
11887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11888 
 
11889 
  def __eq__(self, other):
11890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11891 
 
11892 
  def __ne__(self, other):
11893 
    return not (self == other)
11894 
 
3064 chandransh 11895 
class getOrderForCustomer_args:
94 ashish 11896 
  """
11897 
  Attributes:
3064 chandransh 11898 
   - orderId
483 rajveer 11899 
   - customerId
94 ashish 11900 
  """
11901 
 
11902 
  thrift_spec = (
11903 
    None, # 0
3064 chandransh 11904 
    (1, TType.I64, 'orderId', None, None, ), # 1
11905 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11906 
  )
11907 
 
3064 chandransh 11908 
  def __init__(self, orderId=None, customerId=None,):
11909 
    self.orderId = orderId
483 rajveer 11910 
    self.customerId = customerId
94 ashish 11911 
 
11912 
  def read(self, iprot):
11913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11915 
      return
11916 
    iprot.readStructBegin()
11917 
    while True:
11918 
      (fname, ftype, fid) = iprot.readFieldBegin()
11919 
      if ftype == TType.STOP:
11920 
        break
11921 
      if fid == 1:
11922 
        if ftype == TType.I64:
3064 chandransh 11923 
          self.orderId = iprot.readI64();
94 ashish 11924 
        else:
11925 
          iprot.skip(ftype)
11926 
      elif fid == 2:
11927 
        if ftype == TType.I64:
3064 chandransh 11928 
          self.customerId = iprot.readI64();
94 ashish 11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      else:
11932 
        iprot.skip(ftype)
11933 
      iprot.readFieldEnd()
11934 
    iprot.readStructEnd()
11935 
 
11936 
  def write(self, oprot):
11937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11939 
      return
3064 chandransh 11940 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11941 
    if self.orderId is not None:
3064 chandransh 11942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11943 
      oprot.writeI64(self.orderId)
11944 
      oprot.writeFieldEnd()
3431 rajveer 11945 
    if self.customerId is not None:
3064 chandransh 11946 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11947 
      oprot.writeI64(self.customerId)
94 ashish 11948 
      oprot.writeFieldEnd()
11949 
    oprot.writeFieldStop()
11950 
    oprot.writeStructEnd()
11951 
 
3431 rajveer 11952 
  def validate(self):
11953 
    return
11954 
 
11955 
 
94 ashish 11956 
  def __repr__(self):
11957 
    L = ['%s=%r' % (key, value)
11958 
      for key, value in self.__dict__.iteritems()]
11959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11960 
 
11961 
  def __eq__(self, other):
11962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11963 
 
11964 
  def __ne__(self, other):
11965 
    return not (self == other)
11966 
 
3064 chandransh 11967 
class getOrderForCustomer_result:
94 ashish 11968 
  """
11969 
  Attributes:
11970 
   - success
11971 
   - ex
11972 
  """
11973 
 
11974 
  thrift_spec = (
3064 chandransh 11975 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11977 
  )
11978 
 
11979 
  def __init__(self, success=None, ex=None,):
11980 
    self.success = success
11981 
    self.ex = ex
11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      if fid == 0:
3064 chandransh 11993 
        if ftype == TType.STRUCT:
11994 
          self.success = Order()
11995 
          self.success.read(iprot)
94 ashish 11996 
        else:
11997 
          iprot.skip(ftype)
11998 
      elif fid == 1:
11999 
        if ftype == TType.STRUCT:
12000 
          self.ex = TransactionServiceException()
12001 
          self.ex.read(iprot)
12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      else:
12005 
        iprot.skip(ftype)
12006 
      iprot.readFieldEnd()
12007 
    iprot.readStructEnd()
12008 
 
12009 
  def write(self, oprot):
12010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12012 
      return
3064 chandransh 12013 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12014 
    if self.success is not None:
3064 chandransh 12015 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12016 
      self.success.write(oprot)
94 ashish 12017 
      oprot.writeFieldEnd()
3431 rajveer 12018 
    if self.ex is not None:
94 ashish 12019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12020 
      self.ex.write(oprot)
12021 
      oprot.writeFieldEnd()
12022 
    oprot.writeFieldStop()
12023 
    oprot.writeStructEnd()
12024 
 
3431 rajveer 12025 
  def validate(self):
12026 
    return
12027 
 
12028 
 
94 ashish 12029 
  def __repr__(self):
12030 
    L = ['%s=%r' % (key, value)
12031 
      for key, value in self.__dict__.iteritems()]
12032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12033 
 
12034 
  def __eq__(self, other):
12035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12036 
 
12037 
  def __ne__(self, other):
12038 
    return not (self == other)
12039 
 
3064 chandransh 12040 
class getAlerts_args:
94 ashish 12041 
  """
12042 
  Attributes:
4394 rajveer 12043 
   - type
4444 rajveer 12044 
   - warehouseId
4394 rajveer 12045 
   - status
12046 
   - timestamp
94 ashish 12047 
  """
12048 
 
12049 
  thrift_spec = (
12050 
    None, # 0
4394 rajveer 12051 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12052 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12053 
    (3, TType.I64, 'status', None, None, ), # 3
12054 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12055 
  )
12056 
 
4444 rajveer 12057 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12058 
    self.type = type
4444 rajveer 12059 
    self.warehouseId = warehouseId
4394 rajveer 12060 
    self.status = status
12061 
    self.timestamp = timestamp
94 ashish 12062 
 
12063 
  def read(self, iprot):
12064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12066 
      return
12067 
    iprot.readStructBegin()
12068 
    while True:
12069 
      (fname, ftype, fid) = iprot.readFieldBegin()
12070 
      if ftype == TType.STOP:
12071 
        break
12072 
      if fid == 1:
3064 chandransh 12073 
        if ftype == TType.I64:
4394 rajveer 12074 
          self.type = iprot.readI64();
94 ashish 12075 
        else:
12076 
          iprot.skip(ftype)
3064 chandransh 12077 
      elif fid == 2:
4394 rajveer 12078 
        if ftype == TType.I64:
4444 rajveer 12079 
          self.warehouseId = iprot.readI64();
3064 chandransh 12080 
        else:
12081 
          iprot.skip(ftype)
4394 rajveer 12082 
      elif fid == 3:
12083 
        if ftype == TType.I64:
4444 rajveer 12084 
          self.status = iprot.readI64();
12085 
        else:
12086 
          iprot.skip(ftype)
12087 
      elif fid == 4:
12088 
        if ftype == TType.I64:
4394 rajveer 12089 
          self.timestamp = iprot.readI64();
12090 
        else:
12091 
          iprot.skip(ftype)
94 ashish 12092 
      else:
12093 
        iprot.skip(ftype)
12094 
      iprot.readFieldEnd()
12095 
    iprot.readStructEnd()
12096 
 
12097 
  def write(self, oprot):
12098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12100 
      return
3064 chandransh 12101 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12102 
    if self.type is not None:
12103 
      oprot.writeFieldBegin('type', TType.I64, 1)
12104 
      oprot.writeI64(self.type)
94 ashish 12105 
      oprot.writeFieldEnd()
4444 rajveer 12106 
    if self.warehouseId is not None:
12107 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12108 
      oprot.writeI64(self.warehouseId)
12109 
      oprot.writeFieldEnd()
4394 rajveer 12110 
    if self.status is not None:
4444 rajveer 12111 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12112 
      oprot.writeI64(self.status)
3064 chandransh 12113 
      oprot.writeFieldEnd()
4394 rajveer 12114 
    if self.timestamp is not None:
4444 rajveer 12115 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12116 
      oprot.writeI64(self.timestamp)
12117 
      oprot.writeFieldEnd()
94 ashish 12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
3431 rajveer 12121 
  def validate(self):
12122 
    return
12123 
 
12124 
 
94 ashish 12125 
  def __repr__(self):
12126 
    L = ['%s=%r' % (key, value)
12127 
      for key, value in self.__dict__.iteritems()]
12128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12129 
 
12130 
  def __eq__(self, other):
12131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12132 
 
12133 
  def __ne__(self, other):
12134 
    return not (self == other)
12135 
 
3064 chandransh 12136 
class getAlerts_result:
94 ashish 12137 
  """
12138 
  Attributes:
12139 
   - success
12140 
  """
12141 
 
12142 
  thrift_spec = (
3064 chandransh 12143 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12144 
  )
12145 
 
3064 chandransh 12146 
  def __init__(self, success=None,):
94 ashish 12147 
    self.success = success
12148 
 
12149 
  def read(self, iprot):
12150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12152 
      return
12153 
    iprot.readStructBegin()
12154 
    while True:
12155 
      (fname, ftype, fid) = iprot.readFieldBegin()
12156 
      if ftype == TType.STOP:
12157 
        break
12158 
      if fid == 0:
3064 chandransh 12159 
        if ftype == TType.LIST:
12160 
          self.success = []
6188 rajveer 12161 
          (_etype242, _size239) = iprot.readListBegin()
12162 
          for _i243 in xrange(_size239):
12163 
            _elem244 = Alert()
12164 
            _elem244.read(iprot)
12165 
            self.success.append(_elem244)
3064 chandransh 12166 
          iprot.readListEnd()
94 ashish 12167 
        else:
12168 
          iprot.skip(ftype)
12169 
      else:
12170 
        iprot.skip(ftype)
12171 
      iprot.readFieldEnd()
12172 
    iprot.readStructEnd()
12173 
 
12174 
  def write(self, oprot):
12175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12177 
      return
3064 chandransh 12178 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12179 
    if self.success is not None:
3064 chandransh 12180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12182 
      for iter245 in self.success:
12183 
        iter245.write(oprot)
3064 chandransh 12184 
      oprot.writeListEnd()
94 ashish 12185 
      oprot.writeFieldEnd()
12186 
    oprot.writeFieldStop()
12187 
    oprot.writeStructEnd()
12188 
 
3431 rajveer 12189 
  def validate(self):
12190 
    return
12191 
 
12192 
 
94 ashish 12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
4394 rajveer 12204 
class addAlert_args:
94 ashish 12205 
  """
12206 
  Attributes:
3064 chandransh 12207 
   - type
4444 rajveer 12208 
   - warehouseId
4394 rajveer 12209 
   - description
94 ashish 12210 
  """
12211 
 
12212 
  thrift_spec = (
12213 
    None, # 0
4394 rajveer 12214 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12215 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12216 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12217 
  )
12218 
 
4444 rajveer 12219 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12220 
    self.type = type
4444 rajveer 12221 
    self.warehouseId = warehouseId
4394 rajveer 12222 
    self.description = description
94 ashish 12223 
 
12224 
  def read(self, iprot):
12225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12227 
      return
12228 
    iprot.readStructBegin()
12229 
    while True:
12230 
      (fname, ftype, fid) = iprot.readFieldBegin()
12231 
      if ftype == TType.STOP:
12232 
        break
12233 
      if fid == 1:
12234 
        if ftype == TType.I64:
4394 rajveer 12235 
          self.type = iprot.readI64();
94 ashish 12236 
        else:
12237 
          iprot.skip(ftype)
3064 chandransh 12238 
      elif fid == 2:
4444 rajveer 12239 
        if ftype == TType.I64:
12240 
          self.warehouseId = iprot.readI64();
12241 
        else:
12242 
          iprot.skip(ftype)
12243 
      elif fid == 3:
3064 chandransh 12244 
        if ftype == TType.STRING:
4394 rajveer 12245 
          self.description = iprot.readString();
3064 chandransh 12246 
        else:
12247 
          iprot.skip(ftype)
94 ashish 12248 
      else:
12249 
        iprot.skip(ftype)
12250 
      iprot.readFieldEnd()
12251 
    iprot.readStructEnd()
12252 
 
12253 
  def write(self, oprot):
12254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12256 
      return
4394 rajveer 12257 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12258 
    if self.type is not None:
4394 rajveer 12259 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12260 
      oprot.writeI64(self.type)
12261 
      oprot.writeFieldEnd()
4444 rajveer 12262 
    if self.warehouseId is not None:
12263 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12264 
      oprot.writeI64(self.warehouseId)
12265 
      oprot.writeFieldEnd()
4394 rajveer 12266 
    if self.description is not None:
4444 rajveer 12267 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12268 
      oprot.writeString(self.description)
3064 chandransh 12269 
      oprot.writeFieldEnd()
94 ashish 12270 
    oprot.writeFieldStop()
12271 
    oprot.writeStructEnd()
12272 
 
3431 rajveer 12273 
  def validate(self):
12274 
    return
12275 
 
12276 
 
94 ashish 12277 
  def __repr__(self):
12278 
    L = ['%s=%r' % (key, value)
12279 
      for key, value in self.__dict__.iteritems()]
12280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12281 
 
12282 
  def __eq__(self, other):
12283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12284 
 
12285 
  def __ne__(self, other):
12286 
    return not (self == other)
12287 
 
4394 rajveer 12288 
class addAlert_result:
3064 chandransh 12289 
 
12290 
  thrift_spec = (
12291 
  )
12292 
 
12293 
  def read(self, iprot):
12294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12296 
      return
12297 
    iprot.readStructBegin()
12298 
    while True:
12299 
      (fname, ftype, fid) = iprot.readFieldBegin()
12300 
      if ftype == TType.STOP:
12301 
        break
12302 
      else:
12303 
        iprot.skip(ftype)
12304 
      iprot.readFieldEnd()
12305 
    iprot.readStructEnd()
12306 
 
12307 
  def write(self, oprot):
12308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12310 
      return
4394 rajveer 12311 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12312 
    oprot.writeFieldStop()
12313 
    oprot.writeStructEnd()
12314 
 
3431 rajveer 12315 
  def validate(self):
12316 
    return
12317 
 
12318 
 
3064 chandransh 12319 
  def __repr__(self):
12320 
    L = ['%s=%r' % (key, value)
12321 
      for key, value in self.__dict__.iteritems()]
12322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12323 
 
12324 
  def __eq__(self, other):
12325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12326 
 
12327 
  def __ne__(self, other):
12328 
    return not (self == other)
12329 
 
4444 rajveer 12330 
class markAlertsAsSeen_args:
12331 
  """
12332 
  Attributes:
12333 
   - warehouseId
12334 
  """
12335 
 
12336 
  thrift_spec = (
12337 
    None, # 0
12338 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12339 
  )
12340 
 
12341 
  def __init__(self, warehouseId=None,):
12342 
    self.warehouseId = warehouseId
12343 
 
12344 
  def read(self, iprot):
12345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12347 
      return
12348 
    iprot.readStructBegin()
12349 
    while True:
12350 
      (fname, ftype, fid) = iprot.readFieldBegin()
12351 
      if ftype == TType.STOP:
12352 
        break
12353 
      if fid == 1:
12354 
        if ftype == TType.I64:
12355 
          self.warehouseId = iprot.readI64();
12356 
        else:
12357 
          iprot.skip(ftype)
12358 
      else:
12359 
        iprot.skip(ftype)
12360 
      iprot.readFieldEnd()
12361 
    iprot.readStructEnd()
12362 
 
12363 
  def write(self, oprot):
12364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12366 
      return
12367 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12368 
    if self.warehouseId is not None:
12369 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12370 
      oprot.writeI64(self.warehouseId)
12371 
      oprot.writeFieldEnd()
12372 
    oprot.writeFieldStop()
12373 
    oprot.writeStructEnd()
12374 
 
12375 
  def validate(self):
12376 
    return
12377 
 
12378 
 
12379 
  def __repr__(self):
12380 
    L = ['%s=%r' % (key, value)
12381 
      for key, value in self.__dict__.iteritems()]
12382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12383 
 
12384 
  def __eq__(self, other):
12385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12386 
 
12387 
  def __ne__(self, other):
12388 
    return not (self == other)
12389 
 
12390 
class markAlertsAsSeen_result:
12391 
 
12392 
  thrift_spec = (
12393 
  )
12394 
 
12395 
  def read(self, iprot):
12396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12398 
      return
12399 
    iprot.readStructBegin()
12400 
    while True:
12401 
      (fname, ftype, fid) = iprot.readFieldBegin()
12402 
      if ftype == TType.STOP:
12403 
        break
12404 
      else:
12405 
        iprot.skip(ftype)
12406 
      iprot.readFieldEnd()
12407 
    iprot.readStructEnd()
12408 
 
12409 
  def write(self, oprot):
12410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12412 
      return
12413 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12414 
    oprot.writeFieldStop()
12415 
    oprot.writeStructEnd()
12416 
 
12417 
  def validate(self):
12418 
    return
12419 
 
12420 
 
12421 
  def __repr__(self):
12422 
    L = ['%s=%r' % (key, value)
12423 
      for key, value in self.__dict__.iteritems()]
12424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12425 
 
12426 
  def __eq__(self, other):
12427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12428 
 
12429 
  def __ne__(self, other):
12430 
    return not (self == other)
12431 
 
3064 chandransh 12432 
class getValidOrderCount_args:
12433 
 
12434 
  thrift_spec = (
12435 
  )
12436 
 
12437 
  def read(self, iprot):
12438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12440 
      return
12441 
    iprot.readStructBegin()
12442 
    while True:
12443 
      (fname, ftype, fid) = iprot.readFieldBegin()
12444 
      if ftype == TType.STOP:
12445 
        break
12446 
      else:
12447 
        iprot.skip(ftype)
12448 
      iprot.readFieldEnd()
12449 
    iprot.readStructEnd()
12450 
 
12451 
  def write(self, oprot):
12452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12454 
      return
12455 
    oprot.writeStructBegin('getValidOrderCount_args')
12456 
    oprot.writeFieldStop()
12457 
    oprot.writeStructEnd()
12458 
 
3431 rajveer 12459 
  def validate(self):
12460 
    return
12461 
 
12462 
 
3064 chandransh 12463 
  def __repr__(self):
12464 
    L = ['%s=%r' % (key, value)
12465 
      for key, value in self.__dict__.iteritems()]
12466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12467 
 
12468 
  def __eq__(self, other):
12469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12470 
 
12471 
  def __ne__(self, other):
12472 
    return not (self == other)
12473 
 
12474 
class getValidOrderCount_result:
94 ashish 12475 
  """
12476 
  Attributes:
12477 
   - success
12478 
  """
12479 
 
12480 
  thrift_spec = (
3064 chandransh 12481 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12482 
  )
12483 
 
3064 chandransh 12484 
  def __init__(self, success=None,):
94 ashish 12485 
    self.success = success
12486 
 
12487 
  def read(self, iprot):
12488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12490 
      return
12491 
    iprot.readStructBegin()
12492 
    while True:
12493 
      (fname, ftype, fid) = iprot.readFieldBegin()
12494 
      if ftype == TType.STOP:
12495 
        break
12496 
      if fid == 0:
3064 chandransh 12497 
        if ftype == TType.I64:
12498 
          self.success = iprot.readI64();
94 ashish 12499 
        else:
12500 
          iprot.skip(ftype)
12501 
      else:
12502 
        iprot.skip(ftype)
12503 
      iprot.readFieldEnd()
12504 
    iprot.readStructEnd()
12505 
 
12506 
  def write(self, oprot):
12507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12509 
      return
3064 chandransh 12510 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12511 
    if self.success is not None:
3064 chandransh 12512 
      oprot.writeFieldBegin('success', TType.I64, 0)
12513 
      oprot.writeI64(self.success)
94 ashish 12514 
      oprot.writeFieldEnd()
12515 
    oprot.writeFieldStop()
12516 
    oprot.writeStructEnd()
12517 
 
3431 rajveer 12518 
  def validate(self):
12519 
    return
12520 
 
12521 
 
94 ashish 12522 
  def __repr__(self):
12523 
    L = ['%s=%r' % (key, value)
12524 
      for key, value in self.__dict__.iteritems()]
12525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12526 
 
12527 
  def __eq__(self, other):
12528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12529 
 
12530 
  def __ne__(self, other):
12531 
    return not (self == other)
12532 
 
3064 chandransh 12533 
class getNoOfCustomersWithSuccessfulTransaction_args:
12534 
 
12535 
  thrift_spec = (
12536 
  )
12537 
 
12538 
  def read(self, iprot):
12539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12541 
      return
12542 
    iprot.readStructBegin()
12543 
    while True:
12544 
      (fname, ftype, fid) = iprot.readFieldBegin()
12545 
      if ftype == TType.STOP:
12546 
        break
12547 
      else:
12548 
        iprot.skip(ftype)
12549 
      iprot.readFieldEnd()
12550 
    iprot.readStructEnd()
12551 
 
12552 
  def write(self, oprot):
12553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12555 
      return
12556 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12557 
    oprot.writeFieldStop()
12558 
    oprot.writeStructEnd()
12559 
 
3431 rajveer 12560 
  def validate(self):
12561 
    return
12562 
 
12563 
 
3064 chandransh 12564 
  def __repr__(self):
12565 
    L = ['%s=%r' % (key, value)
12566 
      for key, value in self.__dict__.iteritems()]
12567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12568 
 
12569 
  def __eq__(self, other):
12570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12571 
 
12572 
  def __ne__(self, other):
12573 
    return not (self == other)
12574 
 
12575 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12576 
  """
12577 
  Attributes:
3064 chandransh 12578 
   - success
94 ashish 12579 
  """
12580 
 
12581 
  thrift_spec = (
3064 chandransh 12582 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12583 
  )
12584 
 
3064 chandransh 12585 
  def __init__(self, success=None,):
12586 
    self.success = success
94 ashish 12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
3064 chandransh 12597 
      if fid == 0:
94 ashish 12598 
        if ftype == TType.I64:
3064 chandransh 12599 
          self.success = iprot.readI64();
94 ashish 12600 
        else:
12601 
          iprot.skip(ftype)
12602 
      else:
12603 
        iprot.skip(ftype)
12604 
      iprot.readFieldEnd()
12605 
    iprot.readStructEnd()
12606 
 
12607 
  def write(self, oprot):
12608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12610 
      return
3064 chandransh 12611 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12612 
    if self.success is not None:
3064 chandransh 12613 
      oprot.writeFieldBegin('success', TType.I64, 0)
12614 
      oprot.writeI64(self.success)
94 ashish 12615 
      oprot.writeFieldEnd()
12616 
    oprot.writeFieldStop()
12617 
    oprot.writeStructEnd()
12618 
 
3431 rajveer 12619 
  def validate(self):
12620 
    return
12621 
 
12622 
 
94 ashish 12623 
  def __repr__(self):
12624 
    L = ['%s=%r' % (key, value)
12625 
      for key, value in self.__dict__.iteritems()]
12626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12627 
 
12628 
  def __eq__(self, other):
12629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12630 
 
12631 
  def __ne__(self, other):
12632 
    return not (self == other)
12633 
 
3064 chandransh 12634 
class getValidOrdersAmountRange_args:
12635 
 
12636 
  thrift_spec = (
12637 
  )
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      else:
12649 
        iprot.skip(ftype)
12650 
      iprot.readFieldEnd()
12651 
    iprot.readStructEnd()
12652 
 
12653 
  def write(self, oprot):
12654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12656 
      return
12657 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
3431 rajveer 12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
3064 chandransh 12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
12676 
class getValidOrdersAmountRange_result:
94 ashish 12677 
  """
12678 
  Attributes:
12679 
   - success
12680 
  """
12681 
 
12682 
  thrift_spec = (
3064 chandransh 12683 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12684 
  )
12685 
 
3064 chandransh 12686 
  def __init__(self, success=None,):
94 ashish 12687 
    self.success = success
12688 
 
12689 
  def read(self, iprot):
12690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12692 
      return
12693 
    iprot.readStructBegin()
12694 
    while True:
12695 
      (fname, ftype, fid) = iprot.readFieldBegin()
12696 
      if ftype == TType.STOP:
12697 
        break
12698 
      if fid == 0:
483 rajveer 12699 
        if ftype == TType.LIST:
12700 
          self.success = []
6188 rajveer 12701 
          (_etype249, _size246) = iprot.readListBegin()
12702 
          for _i250 in xrange(_size246):
12703 
            _elem251 = iprot.readDouble();
12704 
            self.success.append(_elem251)
483 rajveer 12705 
          iprot.readListEnd()
94 ashish 12706 
        else:
12707 
          iprot.skip(ftype)
12708 
      else:
12709 
        iprot.skip(ftype)
12710 
      iprot.readFieldEnd()
12711 
    iprot.readStructEnd()
12712 
 
12713 
  def write(self, oprot):
12714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12716 
      return
3064 chandransh 12717 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12718 
    if self.success is not None:
483 rajveer 12719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12720 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12721 
      for iter252 in self.success:
12722 
        oprot.writeDouble(iter252)
483 rajveer 12723 
      oprot.writeListEnd()
94 ashish 12724 
      oprot.writeFieldEnd()
12725 
    oprot.writeFieldStop()
12726 
    oprot.writeStructEnd()
12727 
 
3431 rajveer 12728 
  def validate(self):
12729 
    return
12730 
 
12731 
 
94 ashish 12732 
  def __repr__(self):
12733 
    L = ['%s=%r' % (key, value)
12734 
      for key, value in self.__dict__.iteritems()]
12735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12736 
 
12737 
  def __eq__(self, other):
12738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12739 
 
12740 
  def __ne__(self, other):
12741 
    return not (self == other)
12742 
 
3064 chandransh 12743 
class getValidOrders_args:
1528 ankur.sing 12744 
  """
12745 
  Attributes:
3064 chandransh 12746 
   - limit
5874 rajveer 12747 
   - onlyStore
1528 ankur.sing 12748 
  """
12749 
 
12750 
  thrift_spec = (
12751 
    None, # 0
3064 chandransh 12752 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12753 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12754 
  )
12755 
 
5874 rajveer 12756 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12757 
    self.limit = limit
5874 rajveer 12758 
    self.onlyStore = onlyStore
1528 ankur.sing 12759 
 
12760 
  def read(self, iprot):
12761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12763 
      return
12764 
    iprot.readStructBegin()
12765 
    while True:
12766 
      (fname, ftype, fid) = iprot.readFieldBegin()
12767 
      if ftype == TType.STOP:
12768 
        break
12769 
      if fid == 1:
12770 
        if ftype == TType.I64:
3064 chandransh 12771 
          self.limit = iprot.readI64();
1528 ankur.sing 12772 
        else:
12773 
          iprot.skip(ftype)
5874 rajveer 12774 
      elif fid == 2:
12775 
        if ftype == TType.BOOL:
12776 
          self.onlyStore = iprot.readBool();
12777 
        else:
12778 
          iprot.skip(ftype)
1528 ankur.sing 12779 
      else:
12780 
        iprot.skip(ftype)
12781 
      iprot.readFieldEnd()
12782 
    iprot.readStructEnd()
12783 
 
12784 
  def write(self, oprot):
12785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12787 
      return
3064 chandransh 12788 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12789 
    if self.limit is not None:
3064 chandransh 12790 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12791 
      oprot.writeI64(self.limit)
1528 ankur.sing 12792 
      oprot.writeFieldEnd()
5874 rajveer 12793 
    if self.onlyStore is not None:
12794 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12795 
      oprot.writeBool(self.onlyStore)
12796 
      oprot.writeFieldEnd()
1528 ankur.sing 12797 
    oprot.writeFieldStop()
12798 
    oprot.writeStructEnd()
12799 
 
3431 rajveer 12800 
  def validate(self):
12801 
    return
12802 
 
12803 
 
1528 ankur.sing 12804 
  def __repr__(self):
12805 
    L = ['%s=%r' % (key, value)
12806 
      for key, value in self.__dict__.iteritems()]
12807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12808 
 
12809 
  def __eq__(self, other):
12810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12811 
 
12812 
  def __ne__(self, other):
12813 
    return not (self == other)
12814 
 
3064 chandransh 12815 
class getValidOrders_result:
1528 ankur.sing 12816 
  """
12817 
  Attributes:
12818 
   - success
12819 
  """
12820 
 
12821 
  thrift_spec = (
3064 chandransh 12822 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12823 
  )
12824 
 
3064 chandransh 12825 
  def __init__(self, success=None,):
1528 ankur.sing 12826 
    self.success = success
12827 
 
12828 
  def read(self, iprot):
12829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12831 
      return
12832 
    iprot.readStructBegin()
12833 
    while True:
12834 
      (fname, ftype, fid) = iprot.readFieldBegin()
12835 
      if ftype == TType.STOP:
12836 
        break
12837 
      if fid == 0:
3064 chandransh 12838 
        if ftype == TType.LIST:
12839 
          self.success = []
6188 rajveer 12840 
          (_etype256, _size253) = iprot.readListBegin()
12841 
          for _i257 in xrange(_size253):
12842 
            _elem258 = Order()
12843 
            _elem258.read(iprot)
12844 
            self.success.append(_elem258)
3064 chandransh 12845 
          iprot.readListEnd()
1528 ankur.sing 12846 
        else:
12847 
          iprot.skip(ftype)
12848 
      else:
12849 
        iprot.skip(ftype)
12850 
      iprot.readFieldEnd()
12851 
    iprot.readStructEnd()
12852 
 
12853 
  def write(self, oprot):
12854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12856 
      return
3064 chandransh 12857 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12858 
    if self.success is not None:
3064 chandransh 12859 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12860 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12861 
      for iter259 in self.success:
12862 
        iter259.write(oprot)
3064 chandransh 12863 
      oprot.writeListEnd()
1528 ankur.sing 12864 
      oprot.writeFieldEnd()
12865 
    oprot.writeFieldStop()
12866 
    oprot.writeStructEnd()
12867 
 
3431 rajveer 12868 
  def validate(self):
12869 
    return
12870 
 
12871 
 
1528 ankur.sing 12872 
  def __repr__(self):
12873 
    L = ['%s=%r' % (key, value)
12874 
      for key, value in self.__dict__.iteritems()]
12875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12876 
 
12877 
  def __eq__(self, other):
12878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12879 
 
12880 
  def __ne__(self, other):
12881 
    return not (self == other)
12882 
 
1220 chandransh 12883 
class batchOrders_args:
12884 
  """
12885 
  Attributes:
12886 
   - warehouseId
12887 
  """
12888 
 
12889 
  thrift_spec = (
12890 
    None, # 0
12891 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12892 
  )
12893 
 
12894 
  def __init__(self, warehouseId=None,):
12895 
    self.warehouseId = warehouseId
12896 
 
12897 
  def read(self, iprot):
12898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12900 
      return
12901 
    iprot.readStructBegin()
12902 
    while True:
12903 
      (fname, ftype, fid) = iprot.readFieldBegin()
12904 
      if ftype == TType.STOP:
12905 
        break
12906 
      if fid == 1:
12907 
        if ftype == TType.I64:
12908 
          self.warehouseId = iprot.readI64();
12909 
        else:
12910 
          iprot.skip(ftype)
12911 
      else:
12912 
        iprot.skip(ftype)
12913 
      iprot.readFieldEnd()
12914 
    iprot.readStructEnd()
12915 
 
12916 
  def write(self, oprot):
12917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12919 
      return
12920 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12921 
    if self.warehouseId is not None:
1220 chandransh 12922 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12923 
      oprot.writeI64(self.warehouseId)
12924 
      oprot.writeFieldEnd()
12925 
    oprot.writeFieldStop()
12926 
    oprot.writeStructEnd()
12927 
 
3431 rajveer 12928 
  def validate(self):
12929 
    return
12930 
 
12931 
 
1220 chandransh 12932 
  def __repr__(self):
12933 
    L = ['%s=%r' % (key, value)
12934 
      for key, value in self.__dict__.iteritems()]
12935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12936 
 
12937 
  def __eq__(self, other):
12938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12939 
 
12940 
  def __ne__(self, other):
12941 
    return not (self == other)
12942 
 
12943 
class batchOrders_result:
12944 
  """
12945 
  Attributes:
12946 
   - success
12947 
   - ex
12948 
  """
12949 
 
12950 
  thrift_spec = (
12951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12953 
  )
12954 
 
12955 
  def __init__(self, success=None, ex=None,):
12956 
    self.success = success
12957 
    self.ex = ex
12958 
 
12959 
  def read(self, iprot):
12960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12962 
      return
12963 
    iprot.readStructBegin()
12964 
    while True:
12965 
      (fname, ftype, fid) = iprot.readFieldBegin()
12966 
      if ftype == TType.STOP:
12967 
        break
12968 
      if fid == 0:
12969 
        if ftype == TType.LIST:
12970 
          self.success = []
6188 rajveer 12971 
          (_etype263, _size260) = iprot.readListBegin()
12972 
          for _i264 in xrange(_size260):
12973 
            _elem265 = Order()
12974 
            _elem265.read(iprot)
12975 
            self.success.append(_elem265)
1220 chandransh 12976 
          iprot.readListEnd()
12977 
        else:
12978 
          iprot.skip(ftype)
12979 
      elif fid == 1:
12980 
        if ftype == TType.STRUCT:
12981 
          self.ex = TransactionServiceException()
12982 
          self.ex.read(iprot)
12983 
        else:
12984 
          iprot.skip(ftype)
12985 
      else:
12986 
        iprot.skip(ftype)
12987 
      iprot.readFieldEnd()
12988 
    iprot.readStructEnd()
12989 
 
12990 
  def write(self, oprot):
12991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12993 
      return
12994 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12995 
    if self.success is not None:
1220 chandransh 12996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12998 
      for iter266 in self.success:
12999 
        iter266.write(oprot)
1220 chandransh 13000 
      oprot.writeListEnd()
13001 
      oprot.writeFieldEnd()
3431 rajveer 13002 
    if self.ex is not None:
1220 chandransh 13003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13004 
      self.ex.write(oprot)
13005 
      oprot.writeFieldEnd()
13006 
    oprot.writeFieldStop()
13007 
    oprot.writeStructEnd()
13008 
 
3431 rajveer 13009 
  def validate(self):
13010 
    return
13011 
 
13012 
 
1220 chandransh 13013 
  def __repr__(self):
13014 
    L = ['%s=%r' % (key, value)
13015 
      for key, value in self.__dict__.iteritems()]
13016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13017 
 
13018 
  def __eq__(self, other):
13019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13020 
 
13021 
  def __ne__(self, other):
13022 
    return not (self == other)
13023 
 
1208 chandransh 13024 
class markOrderAsOutOfStock_args:
13025 
  """
13026 
  Attributes:
13027 
   - orderId
13028 
  """
13029 
 
13030 
  thrift_spec = (
13031 
    None, # 0
13032 
    (1, TType.I64, 'orderId', None, None, ), # 1
13033 
  )
13034 
 
13035 
  def __init__(self, orderId=None,):
13036 
    self.orderId = orderId
13037 
 
13038 
  def read(self, iprot):
13039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13041 
      return
13042 
    iprot.readStructBegin()
13043 
    while True:
13044 
      (fname, ftype, fid) = iprot.readFieldBegin()
13045 
      if ftype == TType.STOP:
13046 
        break
13047 
      if fid == 1:
13048 
        if ftype == TType.I64:
13049 
          self.orderId = iprot.readI64();
13050 
        else:
13051 
          iprot.skip(ftype)
13052 
      else:
13053 
        iprot.skip(ftype)
13054 
      iprot.readFieldEnd()
13055 
    iprot.readStructEnd()
13056 
 
13057 
  def write(self, oprot):
13058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13060 
      return
13061 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13062 
    if self.orderId is not None:
1208 chandransh 13063 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13064 
      oprot.writeI64(self.orderId)
13065 
      oprot.writeFieldEnd()
13066 
    oprot.writeFieldStop()
13067 
    oprot.writeStructEnd()
13068 
 
3431 rajveer 13069 
  def validate(self):
13070 
    return
13071 
 
13072 
 
1208 chandransh 13073 
  def __repr__(self):
13074 
    L = ['%s=%r' % (key, value)
13075 
      for key, value in self.__dict__.iteritems()]
13076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13077 
 
13078 
  def __eq__(self, other):
13079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13080 
 
13081 
  def __ne__(self, other):
13082 
    return not (self == other)
13083 
 
13084 
class markOrderAsOutOfStock_result:
13085 
  """
13086 
  Attributes:
13087 
   - success
13088 
   - ex
13089 
  """
13090 
 
13091 
  thrift_spec = (
13092 
    (0, TType.BOOL, 'success', None, None, ), # 0
13093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13094 
  )
13095 
 
13096 
  def __init__(self, success=None, ex=None,):
13097 
    self.success = success
13098 
    self.ex = ex
13099 
 
13100 
  def read(self, iprot):
13101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13103 
      return
13104 
    iprot.readStructBegin()
13105 
    while True:
13106 
      (fname, ftype, fid) = iprot.readFieldBegin()
13107 
      if ftype == TType.STOP:
13108 
        break
13109 
      if fid == 0:
13110 
        if ftype == TType.BOOL:
13111 
          self.success = iprot.readBool();
13112 
        else:
13113 
          iprot.skip(ftype)
13114 
      elif fid == 1:
13115 
        if ftype == TType.STRUCT:
13116 
          self.ex = TransactionServiceException()
13117 
          self.ex.read(iprot)
13118 
        else:
13119 
          iprot.skip(ftype)
13120 
      else:
13121 
        iprot.skip(ftype)
13122 
      iprot.readFieldEnd()
13123 
    iprot.readStructEnd()
13124 
 
13125 
  def write(self, oprot):
13126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13128 
      return
13129 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13130 
    if self.success is not None:
1208 chandransh 13131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13132 
      oprot.writeBool(self.success)
13133 
      oprot.writeFieldEnd()
3431 rajveer 13134 
    if self.ex is not None:
1208 chandransh 13135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13136 
      self.ex.write(oprot)
13137 
      oprot.writeFieldEnd()
13138 
    oprot.writeFieldStop()
13139 
    oprot.writeStructEnd()
13140 
 
3431 rajveer 13141 
  def validate(self):
13142 
    return
13143 
 
13144 
 
1208 chandransh 13145 
  def __repr__(self):
13146 
    L = ['%s=%r' % (key, value)
13147 
      for key, value in self.__dict__.iteritems()]
13148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13149 
 
13150 
  def __eq__(self, other):
13151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13152 
 
13153 
  def __ne__(self, other):
13154 
    return not (self == other)
13155 
 
3064 chandransh 13156 
class verifyOrder_args:
759 chandransh 13157 
  """
13158 
  Attributes:
3064 chandransh 13159 
   - orderId
759 chandransh 13160 
  """
13161 
 
13162 
  thrift_spec = (
13163 
    None, # 0
3064 chandransh 13164 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13165 
  )
13166 
 
3064 chandransh 13167 
  def __init__(self, orderId=None,):
13168 
    self.orderId = orderId
759 chandransh 13169 
 
13170 
  def read(self, iprot):
13171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13173 
      return
13174 
    iprot.readStructBegin()
13175 
    while True:
13176 
      (fname, ftype, fid) = iprot.readFieldBegin()
13177 
      if ftype == TType.STOP:
13178 
        break
13179 
      if fid == 1:
13180 
        if ftype == TType.I64:
3064 chandransh 13181 
          self.orderId = iprot.readI64();
759 chandransh 13182 
        else:
13183 
          iprot.skip(ftype)
13184 
      else:
13185 
        iprot.skip(ftype)
13186 
      iprot.readFieldEnd()
13187 
    iprot.readStructEnd()
13188 
 
13189 
  def write(self, oprot):
13190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13192 
      return
3064 chandransh 13193 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13194 
    if self.orderId is not None:
3064 chandransh 13195 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13196 
      oprot.writeI64(self.orderId)
759 chandransh 13197 
      oprot.writeFieldEnd()
13198 
    oprot.writeFieldStop()
13199 
    oprot.writeStructEnd()
13200 
 
3431 rajveer 13201 
  def validate(self):
13202 
    return
13203 
 
13204 
 
759 chandransh 13205 
  def __repr__(self):
13206 
    L = ['%s=%r' % (key, value)
13207 
      for key, value in self.__dict__.iteritems()]
13208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13209 
 
13210 
  def __eq__(self, other):
13211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13212 
 
13213 
  def __ne__(self, other):
13214 
    return not (self == other)
13215 
 
3064 chandransh 13216 
class verifyOrder_result:
759 chandransh 13217 
  """
13218 
  Attributes:
13219 
   - success
13220 
   - ex
13221 
  """
13222 
 
13223 
  thrift_spec = (
13224 
    (0, TType.BOOL, 'success', None, None, ), # 0
13225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13226 
  )
13227 
 
13228 
  def __init__(self, success=None, ex=None,):
13229 
    self.success = success
13230 
    self.ex = ex
13231 
 
13232 
  def read(self, iprot):
13233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13235 
      return
13236 
    iprot.readStructBegin()
13237 
    while True:
13238 
      (fname, ftype, fid) = iprot.readFieldBegin()
13239 
      if ftype == TType.STOP:
13240 
        break
13241 
      if fid == 0:
13242 
        if ftype == TType.BOOL:
13243 
          self.success = iprot.readBool();
13244 
        else:
13245 
          iprot.skip(ftype)
13246 
      elif fid == 1:
13247 
        if ftype == TType.STRUCT:
13248 
          self.ex = TransactionServiceException()
13249 
          self.ex.read(iprot)
13250 
        else:
13251 
          iprot.skip(ftype)
13252 
      else:
13253 
        iprot.skip(ftype)
13254 
      iprot.readFieldEnd()
13255 
    iprot.readStructEnd()
13256 
 
13257 
  def write(self, oprot):
13258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13260 
      return
3064 chandransh 13261 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13262 
    if self.success is not None:
759 chandransh 13263 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13264 
      oprot.writeBool(self.success)
13265 
      oprot.writeFieldEnd()
3431 rajveer 13266 
    if self.ex is not None:
759 chandransh 13267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13268 
      self.ex.write(oprot)
13269 
      oprot.writeFieldEnd()
13270 
    oprot.writeFieldStop()
13271 
    oprot.writeStructEnd()
13272 
 
3431 rajveer 13273 
  def validate(self):
13274 
    return
13275 
 
13276 
 
759 chandransh 13277 
  def __repr__(self):
13278 
    L = ['%s=%r' % (key, value)
13279 
      for key, value in self.__dict__.iteritems()]
13280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13281 
 
13282 
  def __eq__(self, other):
13283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13284 
 
13285 
  def __ne__(self, other):
13286 
    return not (self == other)
13287 
 
3064 chandransh 13288 
class acceptOrder_args:
1113 chandransh 13289 
  """
13290 
  Attributes:
3064 chandransh 13291 
   - orderId
1113 chandransh 13292 
  """
13293 
 
13294 
  thrift_spec = (
13295 
    None, # 0
3064 chandransh 13296 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13297 
  )
13298 
 
3064 chandransh 13299 
  def __init__(self, orderId=None,):
13300 
    self.orderId = orderId
1113 chandransh 13301 
 
13302 
  def read(self, iprot):
13303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13305 
      return
13306 
    iprot.readStructBegin()
13307 
    while True:
13308 
      (fname, ftype, fid) = iprot.readFieldBegin()
13309 
      if ftype == TType.STOP:
13310 
        break
13311 
      if fid == 1:
13312 
        if ftype == TType.I64:
3064 chandransh 13313 
          self.orderId = iprot.readI64();
1113 chandransh 13314 
        else:
13315 
          iprot.skip(ftype)
13316 
      else:
13317 
        iprot.skip(ftype)
13318 
      iprot.readFieldEnd()
13319 
    iprot.readStructEnd()
13320 
 
13321 
  def write(self, oprot):
13322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13324 
      return
3064 chandransh 13325 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13326 
    if self.orderId is not None:
3064 chandransh 13327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13328 
      oprot.writeI64(self.orderId)
1113 chandransh 13329 
      oprot.writeFieldEnd()
13330 
    oprot.writeFieldStop()
13331 
    oprot.writeStructEnd()
13332 
 
3431 rajveer 13333 
  def validate(self):
13334 
    return
13335 
 
13336 
 
1113 chandransh 13337 
  def __repr__(self):
13338 
    L = ['%s=%r' % (key, value)
13339 
      for key, value in self.__dict__.iteritems()]
13340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13341 
 
13342 
  def __eq__(self, other):
13343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13344 
 
13345 
  def __ne__(self, other):
13346 
    return not (self == other)
13347 
 
3064 chandransh 13348 
class acceptOrder_result:
1113 chandransh 13349 
  """
13350 
  Attributes:
13351 
   - success
13352 
   - ex
13353 
  """
13354 
 
13355 
  thrift_spec = (
3064 chandransh 13356 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13358 
  )
13359 
 
13360 
  def __init__(self, success=None, ex=None,):
13361 
    self.success = success
13362 
    self.ex = ex
13363 
 
13364 
  def read(self, iprot):
13365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13367 
      return
13368 
    iprot.readStructBegin()
13369 
    while True:
13370 
      (fname, ftype, fid) = iprot.readFieldBegin()
13371 
      if ftype == TType.STOP:
13372 
        break
13373 
      if fid == 0:
3064 chandransh 13374 
        if ftype == TType.BOOL:
13375 
          self.success = iprot.readBool();
1113 chandransh 13376 
        else:
13377 
          iprot.skip(ftype)
13378 
      elif fid == 1:
13379 
        if ftype == TType.STRUCT:
13380 
          self.ex = TransactionServiceException()
13381 
          self.ex.read(iprot)
13382 
        else:
13383 
          iprot.skip(ftype)
13384 
      else:
13385 
        iprot.skip(ftype)
13386 
      iprot.readFieldEnd()
13387 
    iprot.readStructEnd()
13388 
 
13389 
  def write(self, oprot):
13390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13392 
      return
3064 chandransh 13393 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13394 
    if self.success is not None:
3064 chandransh 13395 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13396 
      oprot.writeBool(self.success)
1113 chandransh 13397 
      oprot.writeFieldEnd()
3431 rajveer 13398 
    if self.ex is not None:
1113 chandransh 13399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13400 
      self.ex.write(oprot)
13401 
      oprot.writeFieldEnd()
13402 
    oprot.writeFieldStop()
13403 
    oprot.writeStructEnd()
13404 
 
3431 rajveer 13405 
  def validate(self):
13406 
    return
13407 
 
13408 
 
1113 chandransh 13409 
  def __repr__(self):
13410 
    L = ['%s=%r' % (key, value)
13411 
      for key, value in self.__dict__.iteritems()]
13412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13413 
 
13414 
  def __eq__(self, other):
13415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13416 
 
13417 
  def __ne__(self, other):
13418 
    return not (self == other)
13419 
 
3064 chandransh 13420 
class addBillingDetails_args:
1135 chandransh 13421 
  """
13422 
  Attributes:
3064 chandransh 13423 
   - orderId
13424 
   - invoice_number
4658 mandeep.dh 13425 
   - serialNumber
4283 anupam.sin 13426 
   - itemNumber
3064 chandransh 13427 
   - billed_by
4264 rajveer 13428 
   - jacketNumber
4283 anupam.sin 13429 
   - billingType
5110 mandeep.dh 13430 
   - fulfilmentWarehouseId
4763 rajveer 13431 
   - authorize
1135 chandransh 13432 
  """
13433 
 
13434 
  thrift_spec = (
13435 
    None, # 0
3064 chandransh 13436 
    (1, TType.I64, 'orderId', None, None, ), # 1
13437 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13438 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13439 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13440 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13441 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13442 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13443 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13444 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13445 
  )
13446 
 
5110 mandeep.dh 13447 
  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 13448 
    self.orderId = orderId
13449 
    self.invoice_number = invoice_number
4658 mandeep.dh 13450 
    self.serialNumber = serialNumber
4283 anupam.sin 13451 
    self.itemNumber = itemNumber
3064 chandransh 13452 
    self.billed_by = billed_by
4264 rajveer 13453 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13454 
    self.billingType = billingType
5110 mandeep.dh 13455 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13456 
    self.authorize = authorize
1135 chandransh 13457 
 
13458 
  def read(self, iprot):
13459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13461 
      return
13462 
    iprot.readStructBegin()
13463 
    while True:
13464 
      (fname, ftype, fid) = iprot.readFieldBegin()
13465 
      if ftype == TType.STOP:
13466 
        break
13467 
      if fid == 1:
13468 
        if ftype == TType.I64:
3064 chandransh 13469 
          self.orderId = iprot.readI64();
1135 chandransh 13470 
        else:
13471 
          iprot.skip(ftype)
13472 
      elif fid == 2:
3064 chandransh 13473 
        if ftype == TType.STRING:
13474 
          self.invoice_number = iprot.readString();
1135 chandransh 13475 
        else:
13476 
          iprot.skip(ftype)
3064 chandransh 13477 
      elif fid == 3:
5411 rajveer 13478 
        if ftype == TType.LIST:
13479 
          self.serialNumber = []
6188 rajveer 13480 
          (_etype270, _size267) = iprot.readListBegin()
13481 
          for _i271 in xrange(_size267):
13482 
            _elem272 = iprot.readString();
13483 
            self.serialNumber.append(_elem272)
5411 rajveer 13484 
          iprot.readListEnd()
3064 chandransh 13485 
        else:
13486 
          iprot.skip(ftype)
13487 
      elif fid == 4:
5411 rajveer 13488 
        if ftype == TType.LIST:
13489 
          self.itemNumber = []
6188 rajveer 13490 
          (_etype276, _size273) = iprot.readListBegin()
13491 
          for _i277 in xrange(_size273):
13492 
            _elem278 = iprot.readString();
13493 
            self.itemNumber.append(_elem278)
5411 rajveer 13494 
          iprot.readListEnd()
3064 chandransh 13495 
        else:
13496 
          iprot.skip(ftype)
13497 
      elif fid == 5:
13498 
        if ftype == TType.STRING:
4283 anupam.sin 13499 
          self.billed_by = iprot.readString();
3064 chandransh 13500 
        else:
13501 
          iprot.skip(ftype)
13502 
      elif fid == 6:
13503 
        if ftype == TType.I64:
4283 anupam.sin 13504 
          self.jacketNumber = iprot.readI64();
13505 
        else:
13506 
          iprot.skip(ftype)
13507 
      elif fid == 7:
13508 
        if ftype == TType.I64:
3064 chandransh 13509 
          self.billingType = iprot.readI64();
13510 
        else:
13511 
          iprot.skip(ftype)
4283 anupam.sin 13512 
      elif fid == 8:
13513 
        if ftype == TType.I64:
5110 mandeep.dh 13514 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13515 
        else:
13516 
          iprot.skip(ftype)
4763 rajveer 13517 
      elif fid == 9:
13518 
        if ftype == TType.BOOL:
13519 
          self.authorize = iprot.readBool();
13520 
        else:
13521 
          iprot.skip(ftype)
1246 chandransh 13522 
      else:
13523 
        iprot.skip(ftype)
13524 
      iprot.readFieldEnd()
13525 
    iprot.readStructEnd()
13526 
 
13527 
  def write(self, oprot):
13528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13530 
      return
4283 anupam.sin 13531 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13532 
    if self.orderId is not None:
3064 chandransh 13533 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13534 
      oprot.writeI64(self.orderId)
1246 chandransh 13535 
      oprot.writeFieldEnd()
4283 anupam.sin 13536 
    if self.invoice_number is not None:
13537 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13538 
      oprot.writeString(self.invoice_number)
1246 chandransh 13539 
      oprot.writeFieldEnd()
4658 mandeep.dh 13540 
    if self.serialNumber is not None:
5411 rajveer 13541 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13542 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13543 
      for iter279 in self.serialNumber:
13544 
        oprot.writeString(iter279)
5411 rajveer 13545 
      oprot.writeListEnd()
3064 chandransh 13546 
      oprot.writeFieldEnd()
3431 rajveer 13547 
    if self.itemNumber is not None:
5411 rajveer 13548 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13549 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13550 
      for iter280 in self.itemNumber:
13551 
        oprot.writeString(iter280)
5411 rajveer 13552 
      oprot.writeListEnd()
3064 chandransh 13553 
      oprot.writeFieldEnd()
4283 anupam.sin 13554 
    if self.billed_by is not None:
13555 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13556 
      oprot.writeString(self.billed_by)
3064 chandransh 13557 
      oprot.writeFieldEnd()
4283 anupam.sin 13558 
    if self.jacketNumber is not None:
13559 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13560 
      oprot.writeI64(self.jacketNumber)
13561 
      oprot.writeFieldEnd()
3431 rajveer 13562 
    if self.billingType is not None:
4283 anupam.sin 13563 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13564 
      oprot.writeI64(self.billingType)
13565 
      oprot.writeFieldEnd()
5110 mandeep.dh 13566 
    if self.fulfilmentWarehouseId is not None:
13567 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13568 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13569 
      oprot.writeFieldEnd()
4763 rajveer 13570 
    if self.authorize is not None:
13571 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13572 
      oprot.writeBool(self.authorize)
13573 
      oprot.writeFieldEnd()
1246 chandransh 13574 
    oprot.writeFieldStop()
13575 
    oprot.writeStructEnd()
13576 
 
3431 rajveer 13577 
  def validate(self):
13578 
    return
13579 
 
13580 
 
1246 chandransh 13581 
  def __repr__(self):
13582 
    L = ['%s=%r' % (key, value)
13583 
      for key, value in self.__dict__.iteritems()]
13584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13585 
 
13586 
  def __eq__(self, other):
13587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13588 
 
13589 
  def __ne__(self, other):
13590 
    return not (self == other)
13591 
 
4283 anupam.sin 13592 
class addBillingDetails_result:
1246 chandransh 13593 
  """
13594 
  Attributes:
3064 chandransh 13595 
   - success
1246 chandransh 13596 
   - ex
13597 
  """
13598 
 
13599 
  thrift_spec = (
3064 chandransh 13600 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13601 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13602 
  )
13603 
 
3064 chandransh 13604 
  def __init__(self, success=None, ex=None,):
13605 
    self.success = success
1246 chandransh 13606 
    self.ex = ex
13607 
 
13608 
  def read(self, iprot):
13609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13611 
      return
13612 
    iprot.readStructBegin()
13613 
    while True:
13614 
      (fname, ftype, fid) = iprot.readFieldBegin()
13615 
      if ftype == TType.STOP:
13616 
        break
3064 chandransh 13617 
      if fid == 0:
13618 
        if ftype == TType.BOOL:
13619 
          self.success = iprot.readBool();
13620 
        else:
13621 
          iprot.skip(ftype)
13622 
      elif fid == 1:
1246 chandransh 13623 
        if ftype == TType.STRUCT:
13624 
          self.ex = TransactionServiceException()
13625 
          self.ex.read(iprot)
13626 
        else:
13627 
          iprot.skip(ftype)
13628 
      else:
13629 
        iprot.skip(ftype)
13630 
      iprot.readFieldEnd()
13631 
    iprot.readStructEnd()
13632 
 
13633 
  def write(self, oprot):
13634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13636 
      return
4283 anupam.sin 13637 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13638 
    if self.success is not None:
3064 chandransh 13639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13640 
      oprot.writeBool(self.success)
13641 
      oprot.writeFieldEnd()
3431 rajveer 13642 
    if self.ex is not None:
1246 chandransh 13643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13644 
      self.ex.write(oprot)
13645 
      oprot.writeFieldEnd()
13646 
    oprot.writeFieldStop()
13647 
    oprot.writeStructEnd()
13648 
 
3431 rajveer 13649 
  def validate(self):
13650 
    return
13651 
 
13652 
 
1246 chandransh 13653 
  def __repr__(self):
13654 
    L = ['%s=%r' % (key, value)
13655 
      for key, value in self.__dict__.iteritems()]
13656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13657 
 
13658 
  def __eq__(self, other):
13659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13660 
 
13661 
  def __ne__(self, other):
13662 
    return not (self == other)
13663 
 
4579 rajveer 13664 
class addInvoiceNumber_args:
13665 
  """
13666 
  Attributes:
13667 
   - orderId
13668 
   - invoiceNumber
4763 rajveer 13669 
   - color
4579 rajveer 13670 
  """
13671 
 
13672 
  thrift_spec = (
13673 
    None, # 0
13674 
    (1, TType.I64, 'orderId', None, None, ), # 1
13675 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13676 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13677 
  )
13678 
 
4763 rajveer 13679 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13680 
    self.orderId = orderId
13681 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13682 
    self.color = color
4579 rajveer 13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      if fid == 1:
13694 
        if ftype == TType.I64:
13695 
          self.orderId = iprot.readI64();
13696 
        else:
13697 
          iprot.skip(ftype)
13698 
      elif fid == 2:
13699 
        if ftype == TType.STRING:
13700 
          self.invoiceNumber = iprot.readString();
13701 
        else:
13702 
          iprot.skip(ftype)
4763 rajveer 13703 
      elif fid == 3:
13704 
        if ftype == TType.STRING:
13705 
          self.color = iprot.readString();
13706 
        else:
13707 
          iprot.skip(ftype)
4579 rajveer 13708 
      else:
13709 
        iprot.skip(ftype)
13710 
      iprot.readFieldEnd()
13711 
    iprot.readStructEnd()
13712 
 
13713 
  def write(self, oprot):
13714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13716 
      return
13717 
    oprot.writeStructBegin('addInvoiceNumber_args')
13718 
    if self.orderId is not None:
13719 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13720 
      oprot.writeI64(self.orderId)
13721 
      oprot.writeFieldEnd()
13722 
    if self.invoiceNumber is not None:
13723 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13724 
      oprot.writeString(self.invoiceNumber)
13725 
      oprot.writeFieldEnd()
4763 rajveer 13726 
    if self.color is not None:
13727 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13728 
      oprot.writeString(self.color)
13729 
      oprot.writeFieldEnd()
4579 rajveer 13730 
    oprot.writeFieldStop()
13731 
    oprot.writeStructEnd()
13732 
 
13733 
  def validate(self):
13734 
    return
13735 
 
13736 
 
13737 
  def __repr__(self):
13738 
    L = ['%s=%r' % (key, value)
13739 
      for key, value in self.__dict__.iteritems()]
13740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13741 
 
13742 
  def __eq__(self, other):
13743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13744 
 
13745 
  def __ne__(self, other):
13746 
    return not (self == other)
13747 
 
13748 
class addInvoiceNumber_result:
13749 
  """
13750 
  Attributes:
13751 
   - ex
13752 
  """
13753 
 
13754 
  thrift_spec = (
13755 
    None, # 0
13756 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13757 
  )
13758 
 
13759 
  def __init__(self, ex=None,):
13760 
    self.ex = ex
13761 
 
13762 
  def read(self, iprot):
13763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13765 
      return
13766 
    iprot.readStructBegin()
13767 
    while True:
13768 
      (fname, ftype, fid) = iprot.readFieldBegin()
13769 
      if ftype == TType.STOP:
13770 
        break
13771 
      if fid == 1:
13772 
        if ftype == TType.STRUCT:
13773 
          self.ex = TransactionServiceException()
13774 
          self.ex.read(iprot)
13775 
        else:
13776 
          iprot.skip(ftype)
13777 
      else:
13778 
        iprot.skip(ftype)
13779 
      iprot.readFieldEnd()
13780 
    iprot.readStructEnd()
13781 
 
13782 
  def write(self, oprot):
13783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13785 
      return
13786 
    oprot.writeStructBegin('addInvoiceNumber_result')
13787 
    if self.ex is not None:
13788 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13789 
      self.ex.write(oprot)
13790 
      oprot.writeFieldEnd()
13791 
    oprot.writeFieldStop()
13792 
    oprot.writeStructEnd()
13793 
 
13794 
  def validate(self):
13795 
    return
13796 
 
13797 
 
13798 
  def __repr__(self):
13799 
    L = ['%s=%r' % (key, value)
13800 
      for key, value in self.__dict__.iteritems()]
13801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13802 
 
13803 
  def __eq__(self, other):
13804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13805 
 
13806 
  def __ne__(self, other):
13807 
    return not (self == other)
13808 
 
4910 phani.kuma 13809 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13810 
  """
13811 
  Attributes:
3064 chandransh 13812 
   - warehouseId
1408 ankur.sing 13813 
   - providerId
3064 chandransh 13814 
   - cod
4910 phani.kuma 13815 
   - orderIds
1408 ankur.sing 13816 
  """
13817 
 
13818 
  thrift_spec = (
13819 
    None, # 0
3064 chandransh 13820 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13821 
    (2, TType.I64, 'providerId', None, None, ), # 2
13822 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13823 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13824 
  )
13825 
 
4910 phani.kuma 13826 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13827 
    self.warehouseId = warehouseId
1408 ankur.sing 13828 
    self.providerId = providerId
3064 chandransh 13829 
    self.cod = cod
4910 phani.kuma 13830 
    self.orderIds = orderIds
1408 ankur.sing 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:
3064 chandransh 13843 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13844 
        else:
13845 
          iprot.skip(ftype)
13846 
      elif fid == 2:
13847 
        if ftype == TType.I64:
3064 chandransh 13848 
          self.providerId = iprot.readI64();
1408 ankur.sing 13849 
        else:
13850 
          iprot.skip(ftype)
3064 chandransh 13851 
      elif fid == 3:
13852 
        if ftype == TType.BOOL:
13853 
          self.cod = iprot.readBool();
13854 
        else:
13855 
          iprot.skip(ftype)
4910 phani.kuma 13856 
      elif fid == 4:
13857 
        if ftype == TType.LIST:
13858 
          self.orderIds = []
6188 rajveer 13859 
          (_etype284, _size281) = iprot.readListBegin()
13860 
          for _i285 in xrange(_size281):
13861 
            _elem286 = iprot.readI64();
13862 
            self.orderIds.append(_elem286)
4910 phani.kuma 13863 
          iprot.readListEnd()
13864 
        else:
13865 
          iprot.skip(ftype)
1408 ankur.sing 13866 
      else:
13867 
        iprot.skip(ftype)
13868 
      iprot.readFieldEnd()
13869 
    iprot.readStructEnd()
13870 
 
13871 
  def write(self, oprot):
13872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13874 
      return
4910 phani.kuma 13875 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13876 
    if self.warehouseId is not None:
3064 chandransh 13877 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13878 
      oprot.writeI64(self.warehouseId)
13879 
      oprot.writeFieldEnd()
3431 rajveer 13880 
    if self.providerId is not None:
3064 chandransh 13881 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13882 
      oprot.writeI64(self.providerId)
13883 
      oprot.writeFieldEnd()
3431 rajveer 13884 
    if self.cod is not None:
3064 chandransh 13885 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13886 
      oprot.writeBool(self.cod)
1408 ankur.sing 13887 
      oprot.writeFieldEnd()
4910 phani.kuma 13888 
    if self.orderIds is not None:
13889 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13890 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13891 
      for iter287 in self.orderIds:
13892 
        oprot.writeI64(iter287)
4910 phani.kuma 13893 
      oprot.writeListEnd()
13894 
      oprot.writeFieldEnd()
1408 ankur.sing 13895 
    oprot.writeFieldStop()
13896 
    oprot.writeStructEnd()
13897 
 
3431 rajveer 13898 
  def validate(self):
13899 
    return
13900 
 
13901 
 
1408 ankur.sing 13902 
  def __repr__(self):
13903 
    L = ['%s=%r' % (key, value)
13904 
      for key, value in self.__dict__.iteritems()]
13905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13906 
 
13907 
  def __eq__(self, other):
13908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13909 
 
13910 
  def __ne__(self, other):
13911 
    return not (self == other)
13912 
 
4910 phani.kuma 13913 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13914 
  """
13915 
  Attributes:
13916 
   - success
3064 chandransh 13917 
   - ex
1408 ankur.sing 13918 
  """
13919 
 
13920 
  thrift_spec = (
3064 chandransh 13921 
    (0, TType.BOOL, 'success', None, None, ), # 0
13922 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13923 
  )
13924 
 
3064 chandransh 13925 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13926 
    self.success = success
3064 chandransh 13927 
    self.ex = ex
1408 ankur.sing 13928 
 
13929 
  def read(self, iprot):
13930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13932 
      return
13933 
    iprot.readStructBegin()
13934 
    while True:
13935 
      (fname, ftype, fid) = iprot.readFieldBegin()
13936 
      if ftype == TType.STOP:
13937 
        break
13938 
      if fid == 0:
3064 chandransh 13939 
        if ftype == TType.BOOL:
13940 
          self.success = iprot.readBool();
1408 ankur.sing 13941 
        else:
13942 
          iprot.skip(ftype)
3064 chandransh 13943 
      elif fid == 1:
13944 
        if ftype == TType.STRUCT:
13945 
          self.ex = TransactionServiceException()
13946 
          self.ex.read(iprot)
13947 
        else:
13948 
          iprot.skip(ftype)
1408 ankur.sing 13949 
      else:
13950 
        iprot.skip(ftype)
13951 
      iprot.readFieldEnd()
13952 
    iprot.readStructEnd()
13953 
 
13954 
  def write(self, oprot):
13955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13957 
      return
4910 phani.kuma 13958 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13959 
    if self.success is not None:
3064 chandransh 13960 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13961 
      oprot.writeBool(self.success)
1408 ankur.sing 13962 
      oprot.writeFieldEnd()
3431 rajveer 13963 
    if self.ex is not None:
3064 chandransh 13964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13965 
      self.ex.write(oprot)
13966 
      oprot.writeFieldEnd()
1408 ankur.sing 13967 
    oprot.writeFieldStop()
13968 
    oprot.writeStructEnd()
13969 
 
3431 rajveer 13970 
  def validate(self):
13971 
    return
13972 
 
13973 
 
1408 ankur.sing 13974 
  def __repr__(self):
13975 
    L = ['%s=%r' % (key, value)
13976 
      for key, value in self.__dict__.iteritems()]
13977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13978 
 
13979 
  def __eq__(self, other):
13980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13981 
 
13982 
  def __ne__(self, other):
13983 
    return not (self == other)
13984 
 
5676 rajveer 13985 
class markOrdersAsReturnedFromStore_args:
13986 
  """
13987 
  Attributes:
13988 
   - providerId
13989 
   - orderIds
5713 rajveer 13990 
   - awbs
5676 rajveer 13991 
  """
13992 
 
13993 
  thrift_spec = (
13994 
    None, # 0
13995 
    (1, TType.I64, 'providerId', None, None, ), # 1
13996 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13997 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13998 
  )
13999 
 
5713 rajveer 14000 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14001 
    self.providerId = providerId
14002 
    self.orderIds = orderIds
5713 rajveer 14003 
    self.awbs = awbs
5676 rajveer 14004 
 
14005 
  def read(self, iprot):
14006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14008 
      return
14009 
    iprot.readStructBegin()
14010 
    while True:
14011 
      (fname, ftype, fid) = iprot.readFieldBegin()
14012 
      if ftype == TType.STOP:
14013 
        break
14014 
      if fid == 1:
14015 
        if ftype == TType.I64:
14016 
          self.providerId = iprot.readI64();
14017 
        else:
14018 
          iprot.skip(ftype)
14019 
      elif fid == 2:
14020 
        if ftype == TType.LIST:
14021 
          self.orderIds = []
6188 rajveer 14022 
          (_etype291, _size288) = iprot.readListBegin()
14023 
          for _i292 in xrange(_size288):
14024 
            _elem293 = iprot.readI64();
14025 
            self.orderIds.append(_elem293)
5676 rajveer 14026 
          iprot.readListEnd()
14027 
        else:
14028 
          iprot.skip(ftype)
5713 rajveer 14029 
      elif fid == 3:
14030 
        if ftype == TType.LIST:
14031 
          self.awbs = []
6188 rajveer 14032 
          (_etype297, _size294) = iprot.readListBegin()
14033 
          for _i298 in xrange(_size294):
14034 
            _elem299 = iprot.readString();
14035 
            self.awbs.append(_elem299)
5713 rajveer 14036 
          iprot.readListEnd()
14037 
        else:
14038 
          iprot.skip(ftype)
5676 rajveer 14039 
      else:
14040 
        iprot.skip(ftype)
14041 
      iprot.readFieldEnd()
14042 
    iprot.readStructEnd()
14043 
 
14044 
  def write(self, oprot):
14045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14047 
      return
14048 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14049 
    if self.providerId is not None:
14050 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14051 
      oprot.writeI64(self.providerId)
14052 
      oprot.writeFieldEnd()
14053 
    if self.orderIds is not None:
14054 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14055 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14056 
      for iter300 in self.orderIds:
14057 
        oprot.writeI64(iter300)
5676 rajveer 14058 
      oprot.writeListEnd()
14059 
      oprot.writeFieldEnd()
5713 rajveer 14060 
    if self.awbs is not None:
14061 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14062 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14063 
      for iter301 in self.awbs:
14064 
        oprot.writeString(iter301)
5713 rajveer 14065 
      oprot.writeListEnd()
14066 
      oprot.writeFieldEnd()
5676 rajveer 14067 
    oprot.writeFieldStop()
14068 
    oprot.writeStructEnd()
14069 
 
14070 
  def validate(self):
14071 
    return
14072 
 
14073 
 
14074 
  def __repr__(self):
14075 
    L = ['%s=%r' % (key, value)
14076 
      for key, value in self.__dict__.iteritems()]
14077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14078 
 
14079 
  def __eq__(self, other):
14080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14081 
 
14082 
  def __ne__(self, other):
14083 
    return not (self == other)
14084 
 
14085 
class markOrdersAsReturnedFromStore_result:
14086 
  """
14087 
  Attributes:
14088 
   - success
14089 
   - ex
14090 
  """
14091 
 
14092 
  thrift_spec = (
14093 
    (0, TType.BOOL, 'success', None, None, ), # 0
14094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14095 
  )
14096 
 
14097 
  def __init__(self, success=None, ex=None,):
14098 
    self.success = success
14099 
    self.ex = ex
14100 
 
14101 
  def read(self, iprot):
14102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14104 
      return
14105 
    iprot.readStructBegin()
14106 
    while True:
14107 
      (fname, ftype, fid) = iprot.readFieldBegin()
14108 
      if ftype == TType.STOP:
14109 
        break
14110 
      if fid == 0:
14111 
        if ftype == TType.BOOL:
14112 
          self.success = iprot.readBool();
14113 
        else:
14114 
          iprot.skip(ftype)
14115 
      elif fid == 1:
14116 
        if ftype == TType.STRUCT:
14117 
          self.ex = TransactionServiceException()
14118 
          self.ex.read(iprot)
14119 
        else:
14120 
          iprot.skip(ftype)
14121 
      else:
14122 
        iprot.skip(ftype)
14123 
      iprot.readFieldEnd()
14124 
    iprot.readStructEnd()
14125 
 
14126 
  def write(self, oprot):
14127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14129 
      return
14130 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14131 
    if self.success is not None:
14132 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14133 
      oprot.writeBool(self.success)
14134 
      oprot.writeFieldEnd()
14135 
    if self.ex is not None:
14136 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14137 
      self.ex.write(oprot)
14138 
      oprot.writeFieldEnd()
14139 
    oprot.writeFieldStop()
14140 
    oprot.writeStructEnd()
14141 
 
14142 
  def validate(self):
14143 
    return
14144 
 
14145 
 
14146 
  def __repr__(self):
14147 
    L = ['%s=%r' % (key, value)
14148 
      for key, value in self.__dict__.iteritems()]
14149 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14150 
 
14151 
  def __eq__(self, other):
14152 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14153 
 
14154 
  def __ne__(self, other):
14155 
    return not (self == other)
14156 
 
4910 phani.kuma 14157 
class markOrdersAsPickedUp_args:
4410 rajveer 14158 
  """
14159 
  Attributes:
14160 
   - providerId
4910 phani.kuma 14161 
   - pickupDetails
4410 rajveer 14162 
  """
14163 
 
14164 
  thrift_spec = (
14165 
    None, # 0
4910 phani.kuma 14166 
    (1, TType.I64, 'providerId', None, None, ), # 1
14167 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14168 
  )
14169 
 
4910 phani.kuma 14170 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14171 
    self.providerId = providerId
4910 phani.kuma 14172 
    self.pickupDetails = pickupDetails
4410 rajveer 14173 
 
14174 
  def read(self, iprot):
14175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14177 
      return
14178 
    iprot.readStructBegin()
14179 
    while True:
14180 
      (fname, ftype, fid) = iprot.readFieldBegin()
14181 
      if ftype == TType.STOP:
14182 
        break
14183 
      if fid == 1:
14184 
        if ftype == TType.I64:
4910 phani.kuma 14185 
          self.providerId = iprot.readI64();
4410 rajveer 14186 
        else:
14187 
          iprot.skip(ftype)
14188 
      elif fid == 2:
4910 phani.kuma 14189 
        if ftype == TType.MAP:
14190 
          self.pickupDetails = {}
6188 rajveer 14191 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14192 
          for _i306 in xrange(_size302):
14193 
            _key307 = iprot.readString();
14194 
            _val308 = iprot.readString();
14195 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14196 
          iprot.readMapEnd()
4410 rajveer 14197 
        else:
14198 
          iprot.skip(ftype)
14199 
      else:
14200 
        iprot.skip(ftype)
14201 
      iprot.readFieldEnd()
14202 
    iprot.readStructEnd()
14203 
 
14204 
  def write(self, oprot):
14205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14207 
      return
4910 phani.kuma 14208 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14209 
    if self.providerId is not None:
4910 phani.kuma 14210 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14211 
      oprot.writeI64(self.providerId)
14212 
      oprot.writeFieldEnd()
4910 phani.kuma 14213 
    if self.pickupDetails is not None:
14214 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14215 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14216 
      for kiter309,viter310 in self.pickupDetails.items():
14217 
        oprot.writeString(kiter309)
14218 
        oprot.writeString(viter310)
4910 phani.kuma 14219 
      oprot.writeMapEnd()
4410 rajveer 14220 
      oprot.writeFieldEnd()
14221 
    oprot.writeFieldStop()
14222 
    oprot.writeStructEnd()
14223 
 
14224 
  def validate(self):
14225 
    return
14226 
 
14227 
 
14228 
  def __repr__(self):
14229 
    L = ['%s=%r' % (key, value)
14230 
      for key, value in self.__dict__.iteritems()]
14231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14232 
 
14233 
  def __eq__(self, other):
14234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14235 
 
14236 
  def __ne__(self, other):
14237 
    return not (self == other)
14238 
 
4910 phani.kuma 14239 
class markOrdersAsPickedUp_result:
4410 rajveer 14240 
  """
14241 
  Attributes:
14242 
   - ex
14243 
  """
14244 
 
14245 
  thrift_spec = (
4910 phani.kuma 14246 
    None, # 0
4410 rajveer 14247 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14248 
  )
14249 
 
4910 phani.kuma 14250 
  def __init__(self, ex=None,):
4410 rajveer 14251 
    self.ex = ex
14252 
 
14253 
  def read(self, iprot):
14254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14256 
      return
14257 
    iprot.readStructBegin()
14258 
    while True:
14259 
      (fname, ftype, fid) = iprot.readFieldBegin()
14260 
      if ftype == TType.STOP:
14261 
        break
4910 phani.kuma 14262 
      if fid == 1:
4410 rajveer 14263 
        if ftype == TType.STRUCT:
14264 
          self.ex = TransactionServiceException()
14265 
          self.ex.read(iprot)
14266 
        else:
14267 
          iprot.skip(ftype)
14268 
      else:
14269 
        iprot.skip(ftype)
14270 
      iprot.readFieldEnd()
14271 
    iprot.readStructEnd()
14272 
 
14273 
  def write(self, oprot):
14274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14276 
      return
4910 phani.kuma 14277 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14278 
    if self.ex is not None:
14279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14280 
      self.ex.write(oprot)
14281 
      oprot.writeFieldEnd()
14282 
    oprot.writeFieldStop()
14283 
    oprot.writeStructEnd()
14284 
 
14285 
  def validate(self):
14286 
    return
14287 
 
14288 
 
14289 
  def __repr__(self):
14290 
    L = ['%s=%r' % (key, value)
14291 
      for key, value in self.__dict__.iteritems()]
14292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14293 
 
14294 
  def __eq__(self, other):
14295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14296 
 
14297 
  def __ne__(self, other):
14298 
    return not (self == other)
14299 
 
4910 phani.kuma 14300 
class getOrdersNotPickedUp_args:
304 ashish 14301 
  """
14302 
  Attributes:
3064 chandransh 14303 
   - providerId
304 ashish 14304 
  """
94 ashish 14305 
 
304 ashish 14306 
  thrift_spec = (
14307 
    None, # 0
3064 chandransh 14308 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14309 
  )
14310 
 
4910 phani.kuma 14311 
  def __init__(self, providerId=None,):
3064 chandransh 14312 
    self.providerId = providerId
304 ashish 14313 
 
14314 
  def read(self, iprot):
14315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14317 
      return
14318 
    iprot.readStructBegin()
14319 
    while True:
14320 
      (fname, ftype, fid) = iprot.readFieldBegin()
14321 
      if ftype == TType.STOP:
14322 
        break
14323 
      if fid == 1:
14324 
        if ftype == TType.I64:
3064 chandransh 14325 
          self.providerId = iprot.readI64();
304 ashish 14326 
        else:
14327 
          iprot.skip(ftype)
14328 
      else:
14329 
        iprot.skip(ftype)
14330 
      iprot.readFieldEnd()
14331 
    iprot.readStructEnd()
14332 
 
14333 
  def write(self, oprot):
14334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14336 
      return
4910 phani.kuma 14337 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14338 
    if self.providerId is not None:
3064 chandransh 14339 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14340 
      oprot.writeI64(self.providerId)
304 ashish 14341 
      oprot.writeFieldEnd()
14342 
    oprot.writeFieldStop()
14343 
    oprot.writeStructEnd()
14344 
 
3431 rajveer 14345 
  def validate(self):
14346 
    return
14347 
 
14348 
 
304 ashish 14349 
  def __repr__(self):
14350 
    L = ['%s=%r' % (key, value)
14351 
      for key, value in self.__dict__.iteritems()]
14352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14353 
 
14354 
  def __eq__(self, other):
14355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14356 
 
14357 
  def __ne__(self, other):
14358 
    return not (self == other)
14359 
 
4910 phani.kuma 14360 
class getOrdersNotPickedUp_result:
304 ashish 14361 
  """
14362 
  Attributes:
14363 
   - success
14364 
  """
14365 
 
14366 
  thrift_spec = (
3064 chandransh 14367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14368 
  )
14369 
 
4910 phani.kuma 14370 
  def __init__(self, success=None,):
304 ashish 14371 
    self.success = success
14372 
 
14373 
  def read(self, iprot):
14374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14376 
      return
14377 
    iprot.readStructBegin()
14378 
    while True:
14379 
      (fname, ftype, fid) = iprot.readFieldBegin()
14380 
      if ftype == TType.STOP:
14381 
        break
14382 
      if fid == 0:
14383 
        if ftype == TType.LIST:
14384 
          self.success = []
6188 rajveer 14385 
          (_etype314, _size311) = iprot.readListBegin()
14386 
          for _i315 in xrange(_size311):
14387 
            _elem316 = Order()
14388 
            _elem316.read(iprot)
14389 
            self.success.append(_elem316)
304 ashish 14390 
          iprot.readListEnd()
14391 
        else:
14392 
          iprot.skip(ftype)
14393 
      else:
14394 
        iprot.skip(ftype)
14395 
      iprot.readFieldEnd()
14396 
    iprot.readStructEnd()
14397 
 
14398 
  def write(self, oprot):
14399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14401 
      return
4910 phani.kuma 14402 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14403 
    if self.success is not None:
304 ashish 14404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14406 
      for iter317 in self.success:
14407 
        iter317.write(oprot)
304 ashish 14408 
      oprot.writeListEnd()
14409 
      oprot.writeFieldEnd()
14410 
    oprot.writeFieldStop()
14411 
    oprot.writeStructEnd()
14412 
 
3431 rajveer 14413 
  def validate(self):
14414 
    return
14415 
 
14416 
 
304 ashish 14417 
  def __repr__(self):
14418 
    L = ['%s=%r' % (key, value)
14419 
      for key, value in self.__dict__.iteritems()]
14420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14421 
 
14422 
  def __eq__(self, other):
14423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14424 
 
14425 
  def __ne__(self, other):
14426 
    return not (self == other)
14427 
 
3064 chandransh 14428 
class markOrdersAsDelivered_args:
304 ashish 14429 
  """
14430 
  Attributes:
3064 chandransh 14431 
   - providerId
14432 
   - deliveredOrders
304 ashish 14433 
  """
14434 
 
14435 
  thrift_spec = (
14436 
    None, # 0
3064 chandransh 14437 
    (1, TType.I64, 'providerId', None, None, ), # 1
14438 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14439 
  )
14440 
 
3064 chandransh 14441 
  def __init__(self, providerId=None, deliveredOrders=None,):
14442 
    self.providerId = providerId
14443 
    self.deliveredOrders = deliveredOrders
304 ashish 14444 
 
14445 
  def read(self, iprot):
14446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14448 
      return
14449 
    iprot.readStructBegin()
14450 
    while True:
14451 
      (fname, ftype, fid) = iprot.readFieldBegin()
14452 
      if ftype == TType.STOP:
14453 
        break
14454 
      if fid == 1:
14455 
        if ftype == TType.I64:
3064 chandransh 14456 
          self.providerId = iprot.readI64();
304 ashish 14457 
        else:
14458 
          iprot.skip(ftype)
14459 
      elif fid == 2:
3064 chandransh 14460 
        if ftype == TType.MAP:
14461 
          self.deliveredOrders = {}
6188 rajveer 14462 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14463 
          for _i322 in xrange(_size318):
14464 
            _key323 = iprot.readString();
14465 
            _val324 = iprot.readString();
14466 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14467 
          iprot.readMapEnd()
304 ashish 14468 
        else:
14469 
          iprot.skip(ftype)
14470 
      else:
14471 
        iprot.skip(ftype)
14472 
      iprot.readFieldEnd()
14473 
    iprot.readStructEnd()
14474 
 
14475 
  def write(self, oprot):
14476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14478 
      return
3064 chandransh 14479 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14480 
    if self.providerId is not None:
3064 chandransh 14481 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14482 
      oprot.writeI64(self.providerId)
304 ashish 14483 
      oprot.writeFieldEnd()
3431 rajveer 14484 
    if self.deliveredOrders is not None:
3064 chandransh 14485 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14486 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14487 
      for kiter325,viter326 in self.deliveredOrders.items():
14488 
        oprot.writeString(kiter325)
14489 
        oprot.writeString(viter326)
3064 chandransh 14490 
      oprot.writeMapEnd()
304 ashish 14491 
      oprot.writeFieldEnd()
14492 
    oprot.writeFieldStop()
14493 
    oprot.writeStructEnd()
14494 
 
3431 rajveer 14495 
  def validate(self):
14496 
    return
14497 
 
14498 
 
304 ashish 14499 
  def __repr__(self):
14500 
    L = ['%s=%r' % (key, value)
14501 
      for key, value in self.__dict__.iteritems()]
14502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14503 
 
14504 
  def __eq__(self, other):
14505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14506 
 
14507 
  def __ne__(self, other):
14508 
    return not (self == other)
14509 
 
3064 chandransh 14510 
class markOrdersAsDelivered_result:
14511 
  """
14512 
  Attributes:
14513 
   - ex
14514 
  """
304 ashish 14515 
 
14516 
  thrift_spec = (
3064 chandransh 14517 
    None, # 0
14518 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14519 
  )
14520 
 
3064 chandransh 14521 
  def __init__(self, ex=None,):
14522 
    self.ex = ex
304 ashish 14523 
 
1596 ankur.sing 14524 
  def read(self, iprot):
14525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14527 
      return
14528 
    iprot.readStructBegin()
14529 
    while True:
14530 
      (fname, ftype, fid) = iprot.readFieldBegin()
14531 
      if ftype == TType.STOP:
14532 
        break
3064 chandransh 14533 
      if fid == 1:
14534 
        if ftype == TType.STRUCT:
14535 
          self.ex = TransactionServiceException()
14536 
          self.ex.read(iprot)
14537 
        else:
14538 
          iprot.skip(ftype)
1596 ankur.sing 14539 
      else:
14540 
        iprot.skip(ftype)
14541 
      iprot.readFieldEnd()
14542 
    iprot.readStructEnd()
14543 
 
14544 
  def write(self, oprot):
14545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14547 
      return
3064 chandransh 14548 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14549 
    if self.ex is not None:
3064 chandransh 14550 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14551 
      self.ex.write(oprot)
14552 
      oprot.writeFieldEnd()
1596 ankur.sing 14553 
    oprot.writeFieldStop()
14554 
    oprot.writeStructEnd()
14555 
 
3431 rajveer 14556 
  def validate(self):
14557 
    return
14558 
 
14559 
 
1596 ankur.sing 14560 
  def __repr__(self):
14561 
    L = ['%s=%r' % (key, value)
14562 
      for key, value in self.__dict__.iteritems()]
14563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14564 
 
14565 
  def __eq__(self, other):
14566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14567 
 
14568 
  def __ne__(self, other):
14569 
    return not (self == other)
14570 
 
4910 phani.kuma 14571 
class markAsRTOrders_args:
1596 ankur.sing 14572 
  """
14573 
  Attributes:
3064 chandransh 14574 
   - providerId
14575 
   - returnedOrders
1596 ankur.sing 14576 
  """
14577 
 
14578 
  thrift_spec = (
3064 chandransh 14579 
    None, # 0
14580 
    (1, TType.I64, 'providerId', None, None, ), # 1
14581 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14582 
  )
14583 
 
3064 chandransh 14584 
  def __init__(self, providerId=None, returnedOrders=None,):
14585 
    self.providerId = providerId
14586 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14587 
 
14588 
  def read(self, iprot):
14589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14591 
      return
14592 
    iprot.readStructBegin()
14593 
    while True:
14594 
      (fname, ftype, fid) = iprot.readFieldBegin()
14595 
      if ftype == TType.STOP:
14596 
        break
3064 chandransh 14597 
      if fid == 1:
1596 ankur.sing 14598 
        if ftype == TType.I64:
3064 chandransh 14599 
          self.providerId = iprot.readI64();
1596 ankur.sing 14600 
        else:
14601 
          iprot.skip(ftype)
3064 chandransh 14602 
      elif fid == 2:
14603 
        if ftype == TType.MAP:
14604 
          self.returnedOrders = {}
6188 rajveer 14605 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14606 
          for _i331 in xrange(_size327):
14607 
            _key332 = iprot.readString();
14608 
            _val333 = iprot.readString();
14609 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14610 
          iprot.readMapEnd()
14611 
        else:
14612 
          iprot.skip(ftype)
1596 ankur.sing 14613 
      else:
14614 
        iprot.skip(ftype)
14615 
      iprot.readFieldEnd()
14616 
    iprot.readStructEnd()
14617 
 
14618 
  def write(self, oprot):
14619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14621 
      return
4910 phani.kuma 14622 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14623 
    if self.providerId is not None:
3064 chandransh 14624 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14625 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14626 
      oprot.writeFieldEnd()
3431 rajveer 14627 
    if self.returnedOrders is not None:
3064 chandransh 14628 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14629 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14630 
      for kiter334,viter335 in self.returnedOrders.items():
14631 
        oprot.writeString(kiter334)
14632 
        oprot.writeString(viter335)
3064 chandransh 14633 
      oprot.writeMapEnd()
14634 
      oprot.writeFieldEnd()
1596 ankur.sing 14635 
    oprot.writeFieldStop()
14636 
    oprot.writeStructEnd()
14637 
 
3431 rajveer 14638 
  def validate(self):
14639 
    return
14640 
 
14641 
 
1596 ankur.sing 14642 
  def __repr__(self):
14643 
    L = ['%s=%r' % (key, value)
14644 
      for key, value in self.__dict__.iteritems()]
14645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14646 
 
14647 
  def __eq__(self, other):
14648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14649 
 
14650 
  def __ne__(self, other):
14651 
    return not (self == other)
14652 
 
4910 phani.kuma 14653 
class markAsRTOrders_result:
3064 chandransh 14654 
  """
14655 
  Attributes:
14656 
   - ex
14657 
  """
1596 ankur.sing 14658 
 
1627 ankur.sing 14659 
  thrift_spec = (
3064 chandransh 14660 
    None, # 0
14661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14662 
  )
14663 
 
3064 chandransh 14664 
  def __init__(self, ex=None,):
14665 
    self.ex = ex
14666 
 
1627 ankur.sing 14667 
  def read(self, iprot):
14668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14670 
      return
14671 
    iprot.readStructBegin()
14672 
    while True:
14673 
      (fname, ftype, fid) = iprot.readFieldBegin()
14674 
      if ftype == TType.STOP:
14675 
        break
3064 chandransh 14676 
      if fid == 1:
14677 
        if ftype == TType.STRUCT:
14678 
          self.ex = TransactionServiceException()
14679 
          self.ex.read(iprot)
14680 
        else:
14681 
          iprot.skip(ftype)
1627 ankur.sing 14682 
      else:
14683 
        iprot.skip(ftype)
14684 
      iprot.readFieldEnd()
14685 
    iprot.readStructEnd()
14686 
 
14687 
  def write(self, oprot):
14688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14690 
      return
4910 phani.kuma 14691 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14692 
    if self.ex is not None:
3064 chandransh 14693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14694 
      self.ex.write(oprot)
14695 
      oprot.writeFieldEnd()
1627 ankur.sing 14696 
    oprot.writeFieldStop()
14697 
    oprot.writeStructEnd()
14698 
 
3431 rajveer 14699 
  def validate(self):
14700 
    return
14701 
 
14702 
 
1627 ankur.sing 14703 
  def __repr__(self):
14704 
    L = ['%s=%r' % (key, value)
14705 
      for key, value in self.__dict__.iteritems()]
14706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14707 
 
14708 
  def __eq__(self, other):
14709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14710 
 
14711 
  def __ne__(self, other):
14712 
    return not (self == other)
14713 
 
4910 phani.kuma 14714 
class getRTOrders_args:
14715 
  """
14716 
  Attributes:
14717 
   - providerId
14718 
  """
14719 
 
14720 
  thrift_spec = (
14721 
    None, # 0
14722 
    (1, TType.I64, 'providerId', None, None, ), # 1
14723 
  )
14724 
 
14725 
  def __init__(self, providerId=None,):
14726 
    self.providerId = providerId
14727 
 
14728 
  def read(self, iprot):
14729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14731 
      return
14732 
    iprot.readStructBegin()
14733 
    while True:
14734 
      (fname, ftype, fid) = iprot.readFieldBegin()
14735 
      if ftype == TType.STOP:
14736 
        break
14737 
      if fid == 1:
14738 
        if ftype == TType.I64:
14739 
          self.providerId = iprot.readI64();
14740 
        else:
14741 
          iprot.skip(ftype)
14742 
      else:
14743 
        iprot.skip(ftype)
14744 
      iprot.readFieldEnd()
14745 
    iprot.readStructEnd()
14746 
 
14747 
  def write(self, oprot):
14748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14750 
      return
14751 
    oprot.writeStructBegin('getRTOrders_args')
14752 
    if self.providerId is not None:
14753 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14754 
      oprot.writeI64(self.providerId)
14755 
      oprot.writeFieldEnd()
14756 
    oprot.writeFieldStop()
14757 
    oprot.writeStructEnd()
14758 
 
14759 
  def validate(self):
14760 
    return
14761 
 
14762 
 
14763 
  def __repr__(self):
14764 
    L = ['%s=%r' % (key, value)
14765 
      for key, value in self.__dict__.iteritems()]
14766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14767 
 
14768 
  def __eq__(self, other):
14769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14770 
 
14771 
  def __ne__(self, other):
14772 
    return not (self == other)
14773 
 
14774 
class getRTOrders_result:
14775 
  """
14776 
  Attributes:
14777 
   - success
14778 
  """
14779 
 
14780 
  thrift_spec = (
14781 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14782 
  )
14783 
 
14784 
  def __init__(self, success=None,):
14785 
    self.success = success
14786 
 
14787 
  def read(self, iprot):
14788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14790 
      return
14791 
    iprot.readStructBegin()
14792 
    while True:
14793 
      (fname, ftype, fid) = iprot.readFieldBegin()
14794 
      if ftype == TType.STOP:
14795 
        break
14796 
      if fid == 0:
14797 
        if ftype == TType.LIST:
14798 
          self.success = []
6188 rajveer 14799 
          (_etype339, _size336) = iprot.readListBegin()
14800 
          for _i340 in xrange(_size336):
14801 
            _elem341 = Order()
14802 
            _elem341.read(iprot)
14803 
            self.success.append(_elem341)
4910 phani.kuma 14804 
          iprot.readListEnd()
14805 
        else:
14806 
          iprot.skip(ftype)
14807 
      else:
14808 
        iprot.skip(ftype)
14809 
      iprot.readFieldEnd()
14810 
    iprot.readStructEnd()
14811 
 
14812 
  def write(self, oprot):
14813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14815 
      return
14816 
    oprot.writeStructBegin('getRTOrders_result')
14817 
    if self.success is not None:
14818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14820 
      for iter342 in self.success:
14821 
        iter342.write(oprot)
4910 phani.kuma 14822 
      oprot.writeListEnd()
14823 
      oprot.writeFieldEnd()
14824 
    oprot.writeFieldStop()
14825 
    oprot.writeStructEnd()
14826 
 
14827 
  def validate(self):
14828 
    return
14829 
 
14830 
 
14831 
  def __repr__(self):
14832 
    L = ['%s=%r' % (key, value)
14833 
      for key, value in self.__dict__.iteritems()]
14834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14835 
 
14836 
  def __eq__(self, other):
14837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14838 
 
14839 
  def __ne__(self, other):
14840 
    return not (self == other)
14841 
 
3064 chandransh 14842 
class updateNonDeliveryReason_args:
1627 ankur.sing 14843 
  """
14844 
  Attributes:
3064 chandransh 14845 
   - providerId
14846 
   - undeliveredOrders
1627 ankur.sing 14847 
  """
14848 
 
14849 
  thrift_spec = (
3064 chandransh 14850 
    None, # 0
14851 
    (1, TType.I64, 'providerId', None, None, ), # 1
14852 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14853 
  )
14854 
 
3064 chandransh 14855 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14856 
    self.providerId = providerId
14857 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14858 
 
14859 
  def read(self, iprot):
14860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14862 
      return
14863 
    iprot.readStructBegin()
14864 
    while True:
14865 
      (fname, ftype, fid) = iprot.readFieldBegin()
14866 
      if ftype == TType.STOP:
14867 
        break
3064 chandransh 14868 
      if fid == 1:
1627 ankur.sing 14869 
        if ftype == TType.I64:
3064 chandransh 14870 
          self.providerId = iprot.readI64();
1627 ankur.sing 14871 
        else:
14872 
          iprot.skip(ftype)
3064 chandransh 14873 
      elif fid == 2:
14874 
        if ftype == TType.MAP:
14875 
          self.undeliveredOrders = {}
6188 rajveer 14876 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14877 
          for _i347 in xrange(_size343):
14878 
            _key348 = iprot.readString();
14879 
            _val349 = iprot.readString();
14880 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14881 
          iprot.readMapEnd()
14882 
        else:
14883 
          iprot.skip(ftype)
1627 ankur.sing 14884 
      else:
14885 
        iprot.skip(ftype)
14886 
      iprot.readFieldEnd()
14887 
    iprot.readStructEnd()
14888 
 
14889 
  def write(self, oprot):
14890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14892 
      return
3064 chandransh 14893 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14894 
    if self.providerId is not None:
3064 chandransh 14895 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14896 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14897 
      oprot.writeFieldEnd()
3431 rajveer 14898 
    if self.undeliveredOrders is not None:
3064 chandransh 14899 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14900 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14901 
      for kiter350,viter351 in self.undeliveredOrders.items():
14902 
        oprot.writeString(kiter350)
14903 
        oprot.writeString(viter351)
3064 chandransh 14904 
      oprot.writeMapEnd()
14905 
      oprot.writeFieldEnd()
1627 ankur.sing 14906 
    oprot.writeFieldStop()
14907 
    oprot.writeStructEnd()
14908 
 
3431 rajveer 14909 
  def validate(self):
14910 
    return
14911 
 
14912 
 
1627 ankur.sing 14913 
  def __repr__(self):
14914 
    L = ['%s=%r' % (key, value)
14915 
      for key, value in self.__dict__.iteritems()]
14916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14917 
 
14918 
  def __eq__(self, other):
14919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14920 
 
14921 
  def __ne__(self, other):
14922 
    return not (self == other)
14923 
 
3064 chandransh 14924 
class updateNonDeliveryReason_result:
1627 ankur.sing 14925 
  """
14926 
  Attributes:
3064 chandransh 14927 
   - ex
1627 ankur.sing 14928 
  """
14929 
 
14930 
  thrift_spec = (
4910 phani.kuma 14931 
    None, # 0
3064 chandransh 14932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14933 
  )
14934 
 
4910 phani.kuma 14935 
  def __init__(self, ex=None,):
3064 chandransh 14936 
    self.ex = ex
1627 ankur.sing 14937 
 
14938 
  def read(self, iprot):
14939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14941 
      return
14942 
    iprot.readStructBegin()
14943 
    while True:
14944 
      (fname, ftype, fid) = iprot.readFieldBegin()
14945 
      if ftype == TType.STOP:
14946 
        break
4910 phani.kuma 14947 
      if fid == 1:
14948 
        if ftype == TType.STRUCT:
14949 
          self.ex = TransactionServiceException()
14950 
          self.ex.read(iprot)
14951 
        else:
14952 
          iprot.skip(ftype)
14953 
      else:
14954 
        iprot.skip(ftype)
14955 
      iprot.readFieldEnd()
14956 
    iprot.readStructEnd()
14957 
 
14958 
  def write(self, oprot):
14959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14961 
      return
14962 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14963 
    if self.ex is not None:
14964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14965 
      self.ex.write(oprot)
14966 
      oprot.writeFieldEnd()
14967 
    oprot.writeFieldStop()
14968 
    oprot.writeStructEnd()
14969 
 
14970 
  def validate(self):
14971 
    return
14972 
 
14973 
 
14974 
  def __repr__(self):
14975 
    L = ['%s=%r' % (key, value)
14976 
      for key, value in self.__dict__.iteritems()]
14977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14978 
 
14979 
  def __eq__(self, other):
14980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14981 
 
14982 
  def __ne__(self, other):
14983 
    return not (self == other)
14984 
 
14985 
class getNonDeliveredOrdersbyCourier_args:
14986 
  """
14987 
  Attributes:
14988 
   - providerId
14989 
  """
14990 
 
14991 
  thrift_spec = (
14992 
    None, # 0
14993 
    (1, TType.I64, 'providerId', None, None, ), # 1
14994 
  )
14995 
 
14996 
  def __init__(self, providerId=None,):
14997 
    self.providerId = providerId
14998 
 
14999 
  def read(self, iprot):
15000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15002 
      return
15003 
    iprot.readStructBegin()
15004 
    while True:
15005 
      (fname, ftype, fid) = iprot.readFieldBegin()
15006 
      if ftype == TType.STOP:
15007 
        break
15008 
      if fid == 1:
15009 
        if ftype == TType.I64:
15010 
          self.providerId = iprot.readI64();
15011 
        else:
15012 
          iprot.skip(ftype)
15013 
      else:
15014 
        iprot.skip(ftype)
15015 
      iprot.readFieldEnd()
15016 
    iprot.readStructEnd()
15017 
 
15018 
  def write(self, oprot):
15019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15021 
      return
15022 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15023 
    if self.providerId is not None:
15024 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15025 
      oprot.writeI64(self.providerId)
15026 
      oprot.writeFieldEnd()
15027 
    oprot.writeFieldStop()
15028 
    oprot.writeStructEnd()
15029 
 
15030 
  def validate(self):
15031 
    return
15032 
 
15033 
 
15034 
  def __repr__(self):
15035 
    L = ['%s=%r' % (key, value)
15036 
      for key, value in self.__dict__.iteritems()]
15037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15038 
 
15039 
  def __eq__(self, other):
15040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15041 
 
15042 
  def __ne__(self, other):
15043 
    return not (self == other)
15044 
 
15045 
class getNonDeliveredOrdersbyCourier_result:
15046 
  """
15047 
  Attributes:
15048 
   - success
15049 
  """
15050 
 
15051 
  thrift_spec = (
15052 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15053 
  )
15054 
 
15055 
  def __init__(self, success=None,):
15056 
    self.success = success
15057 
 
15058 
  def read(self, iprot):
15059 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15060 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15061 
      return
15062 
    iprot.readStructBegin()
15063 
    while True:
15064 
      (fname, ftype, fid) = iprot.readFieldBegin()
15065 
      if ftype == TType.STOP:
15066 
        break
4581 phani.kuma 15067 
      if fid == 0:
15068 
        if ftype == TType.LIST:
15069 
          self.success = []
6188 rajveer 15070 
          (_etype355, _size352) = iprot.readListBegin()
15071 
          for _i356 in xrange(_size352):
15072 
            _elem357 = Order()
15073 
            _elem357.read(iprot)
15074 
            self.success.append(_elem357)
4581 phani.kuma 15075 
          iprot.readListEnd()
15076 
        else:
15077 
          iprot.skip(ftype)
4910 phani.kuma 15078 
      else:
15079 
        iprot.skip(ftype)
15080 
      iprot.readFieldEnd()
15081 
    iprot.readStructEnd()
15082 
 
15083 
  def write(self, oprot):
15084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15086 
      return
15087 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15088 
    if self.success is not None:
15089 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15090 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15091 
      for iter358 in self.success:
15092 
        iter358.write(oprot)
4910 phani.kuma 15093 
      oprot.writeListEnd()
15094 
      oprot.writeFieldEnd()
15095 
    oprot.writeFieldStop()
15096 
    oprot.writeStructEnd()
15097 
 
15098 
  def validate(self):
15099 
    return
15100 
 
15101 
 
15102 
  def __repr__(self):
15103 
    L = ['%s=%r' % (key, value)
15104 
      for key, value in self.__dict__.iteritems()]
15105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15106 
 
15107 
  def __eq__(self, other):
15108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15109 
 
15110 
  def __ne__(self, other):
15111 
    return not (self == other)
15112 
 
15113 
class markOrdersAsLocalConnected_args:
15114 
  """
15115 
  Attributes:
15116 
   - providerId
15117 
   - local_connected_orders
15118 
  """
15119 
 
15120 
  thrift_spec = (
15121 
    None, # 0
15122 
    (1, TType.I64, 'providerId', None, None, ), # 1
15123 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15124 
  )
15125 
 
15126 
  def __init__(self, providerId=None, local_connected_orders=None,):
15127 
    self.providerId = providerId
15128 
    self.local_connected_orders = local_connected_orders
15129 
 
15130 
  def read(self, iprot):
15131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15133 
      return
15134 
    iprot.readStructBegin()
15135 
    while True:
15136 
      (fname, ftype, fid) = iprot.readFieldBegin()
15137 
      if ftype == TType.STOP:
15138 
        break
15139 
      if fid == 1:
15140 
        if ftype == TType.I64:
15141 
          self.providerId = iprot.readI64();
15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      elif fid == 2:
15145 
        if ftype == TType.MAP:
15146 
          self.local_connected_orders = {}
6188 rajveer 15147 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15148 
          for _i363 in xrange(_size359):
15149 
            _key364 = iprot.readString();
15150 
            _val365 = iprot.readString();
15151 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15152 
          iprot.readMapEnd()
15153 
        else:
15154 
          iprot.skip(ftype)
15155 
      else:
15156 
        iprot.skip(ftype)
15157 
      iprot.readFieldEnd()
15158 
    iprot.readStructEnd()
15159 
 
15160 
  def write(self, oprot):
15161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15163 
      return
15164 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15165 
    if self.providerId is not None:
15166 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15167 
      oprot.writeI64(self.providerId)
15168 
      oprot.writeFieldEnd()
15169 
    if self.local_connected_orders is not None:
15170 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15171 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15172 
      for kiter366,viter367 in self.local_connected_orders.items():
15173 
        oprot.writeString(kiter366)
15174 
        oprot.writeString(viter367)
4910 phani.kuma 15175 
      oprot.writeMapEnd()
15176 
      oprot.writeFieldEnd()
15177 
    oprot.writeFieldStop()
15178 
    oprot.writeStructEnd()
15179 
 
15180 
  def validate(self):
15181 
    return
15182 
 
15183 
 
15184 
  def __repr__(self):
15185 
    L = ['%s=%r' % (key, value)
15186 
      for key, value in self.__dict__.iteritems()]
15187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15188 
 
15189 
  def __eq__(self, other):
15190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15191 
 
15192 
  def __ne__(self, other):
15193 
    return not (self == other)
15194 
 
15195 
class markOrdersAsLocalConnected_result:
15196 
  """
15197 
  Attributes:
15198 
   - ex
15199 
  """
15200 
 
15201 
  thrift_spec = (
15202 
    None, # 0
15203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15204 
  )
15205 
 
15206 
  def __init__(self, ex=None,):
15207 
    self.ex = ex
15208 
 
15209 
  def read(self, iprot):
15210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15212 
      return
15213 
    iprot.readStructBegin()
15214 
    while True:
15215 
      (fname, ftype, fid) = iprot.readFieldBegin()
15216 
      if ftype == TType.STOP:
15217 
        break
15218 
      if fid == 1:
3064 chandransh 15219 
        if ftype == TType.STRUCT:
15220 
          self.ex = TransactionServiceException()
15221 
          self.ex.read(iprot)
1627 ankur.sing 15222 
        else:
15223 
          iprot.skip(ftype)
15224 
      else:
15225 
        iprot.skip(ftype)
15226 
      iprot.readFieldEnd()
15227 
    iprot.readStructEnd()
15228 
 
15229 
  def write(self, oprot):
15230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15232 
      return
4910 phani.kuma 15233 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15234 
    if self.ex is not None:
15235 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15236 
      self.ex.write(oprot)
15237 
      oprot.writeFieldEnd()
15238 
    oprot.writeFieldStop()
15239 
    oprot.writeStructEnd()
15240 
 
15241 
  def validate(self):
15242 
    return
15243 
 
15244 
 
15245 
  def __repr__(self):
15246 
    L = ['%s=%r' % (key, value)
15247 
      for key, value in self.__dict__.iteritems()]
15248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15249 
 
15250 
  def __eq__(self, other):
15251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15252 
 
15253 
  def __ne__(self, other):
15254 
    return not (self == other)
15255 
 
15256 
class getOrdersNotLocalConnected_args:
15257 
  """
15258 
  Attributes:
15259 
   - providerId
15260 
  """
15261 
 
15262 
  thrift_spec = (
15263 
    None, # 0
15264 
    (1, TType.I64, 'providerId', None, None, ), # 1
15265 
  )
15266 
 
15267 
  def __init__(self, providerId=None,):
15268 
    self.providerId = providerId
15269 
 
15270 
  def read(self, iprot):
15271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15273 
      return
15274 
    iprot.readStructBegin()
15275 
    while True:
15276 
      (fname, ftype, fid) = iprot.readFieldBegin()
15277 
      if ftype == TType.STOP:
15278 
        break
15279 
      if fid == 1:
15280 
        if ftype == TType.I64:
15281 
          self.providerId = iprot.readI64();
15282 
        else:
15283 
          iprot.skip(ftype)
15284 
      else:
15285 
        iprot.skip(ftype)
15286 
      iprot.readFieldEnd()
15287 
    iprot.readStructEnd()
15288 
 
15289 
  def write(self, oprot):
15290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15292 
      return
15293 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15294 
    if self.providerId is not None:
15295 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15296 
      oprot.writeI64(self.providerId)
15297 
      oprot.writeFieldEnd()
15298 
    oprot.writeFieldStop()
15299 
    oprot.writeStructEnd()
15300 
 
15301 
  def validate(self):
15302 
    return
15303 
 
15304 
 
15305 
  def __repr__(self):
15306 
    L = ['%s=%r' % (key, value)
15307 
      for key, value in self.__dict__.iteritems()]
15308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15309 
 
15310 
  def __eq__(self, other):
15311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15312 
 
15313 
  def __ne__(self, other):
15314 
    return not (self == other)
15315 
 
15316 
class getOrdersNotLocalConnected_result:
15317 
  """
15318 
  Attributes:
15319 
   - success
15320 
  """
15321 
 
15322 
  thrift_spec = (
15323 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15324 
  )
15325 
 
15326 
  def __init__(self, success=None,):
15327 
    self.success = success
15328 
 
15329 
  def read(self, iprot):
15330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15332 
      return
15333 
    iprot.readStructBegin()
15334 
    while True:
15335 
      (fname, ftype, fid) = iprot.readFieldBegin()
15336 
      if ftype == TType.STOP:
15337 
        break
15338 
      if fid == 0:
15339 
        if ftype == TType.LIST:
15340 
          self.success = []
6188 rajveer 15341 
          (_etype371, _size368) = iprot.readListBegin()
15342 
          for _i372 in xrange(_size368):
15343 
            _elem373 = Order()
15344 
            _elem373.read(iprot)
15345 
            self.success.append(_elem373)
4910 phani.kuma 15346 
          iprot.readListEnd()
15347 
        else:
15348 
          iprot.skip(ftype)
15349 
      else:
15350 
        iprot.skip(ftype)
15351 
      iprot.readFieldEnd()
15352 
    iprot.readStructEnd()
15353 
 
15354 
  def write(self, oprot):
15355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15357 
      return
15358 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15359 
    if self.success is not None:
15360 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15361 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15362 
      for iter374 in self.success:
15363 
        iter374.write(oprot)
4581 phani.kuma 15364 
      oprot.writeListEnd()
15365 
      oprot.writeFieldEnd()
4910 phani.kuma 15366 
    oprot.writeFieldStop()
15367 
    oprot.writeStructEnd()
15368 
 
15369 
  def validate(self):
15370 
    return
15371 
 
15372 
 
15373 
  def __repr__(self):
15374 
    L = ['%s=%r' % (key, value)
15375 
      for key, value in self.__dict__.iteritems()]
15376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15377 
 
15378 
  def __eq__(self, other):
15379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15380 
 
15381 
  def __ne__(self, other):
15382 
    return not (self == other)
15383 
 
15384 
class markOrdersAsDestinationCityReached_args:
15385 
  """
15386 
  Attributes:
15387 
   - providerId
15388 
   - destination_city_reached_orders
15389 
  """
15390 
 
15391 
  thrift_spec = (
15392 
    None, # 0
15393 
    (1, TType.I64, 'providerId', None, None, ), # 1
15394 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15395 
  )
15396 
 
15397 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15398 
    self.providerId = providerId
15399 
    self.destination_city_reached_orders = destination_city_reached_orders
15400 
 
15401 
  def read(self, iprot):
15402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15404 
      return
15405 
    iprot.readStructBegin()
15406 
    while True:
15407 
      (fname, ftype, fid) = iprot.readFieldBegin()
15408 
      if ftype == TType.STOP:
15409 
        break
15410 
      if fid == 1:
15411 
        if ftype == TType.I64:
15412 
          self.providerId = iprot.readI64();
15413 
        else:
15414 
          iprot.skip(ftype)
15415 
      elif fid == 2:
15416 
        if ftype == TType.MAP:
15417 
          self.destination_city_reached_orders = {}
6188 rajveer 15418 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15419 
          for _i379 in xrange(_size375):
15420 
            _key380 = iprot.readString();
15421 
            _val381 = iprot.readString();
15422 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15423 
          iprot.readMapEnd()
15424 
        else:
15425 
          iprot.skip(ftype)
15426 
      else:
15427 
        iprot.skip(ftype)
15428 
      iprot.readFieldEnd()
15429 
    iprot.readStructEnd()
15430 
 
15431 
  def write(self, oprot):
15432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15434 
      return
15435 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15436 
    if self.providerId is not None:
15437 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15438 
      oprot.writeI64(self.providerId)
15439 
      oprot.writeFieldEnd()
15440 
    if self.destination_city_reached_orders is not None:
15441 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15442 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15443 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15444 
        oprot.writeString(kiter382)
15445 
        oprot.writeString(viter383)
4910 phani.kuma 15446 
      oprot.writeMapEnd()
15447 
      oprot.writeFieldEnd()
15448 
    oprot.writeFieldStop()
15449 
    oprot.writeStructEnd()
15450 
 
15451 
  def validate(self):
15452 
    return
15453 
 
15454 
 
15455 
  def __repr__(self):
15456 
    L = ['%s=%r' % (key, value)
15457 
      for key, value in self.__dict__.iteritems()]
15458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15459 
 
15460 
  def __eq__(self, other):
15461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15462 
 
15463 
  def __ne__(self, other):
15464 
    return not (self == other)
15465 
 
15466 
class markOrdersAsDestinationCityReached_result:
15467 
  """
15468 
  Attributes:
15469 
   - ex
15470 
  """
15471 
 
15472 
  thrift_spec = (
15473 
    None, # 0
15474 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15475 
  )
15476 
 
15477 
  def __init__(self, ex=None,):
15478 
    self.ex = ex
15479 
 
15480 
  def read(self, iprot):
15481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15483 
      return
15484 
    iprot.readStructBegin()
15485 
    while True:
15486 
      (fname, ftype, fid) = iprot.readFieldBegin()
15487 
      if ftype == TType.STOP:
15488 
        break
15489 
      if fid == 1:
15490 
        if ftype == TType.STRUCT:
15491 
          self.ex = TransactionServiceException()
15492 
          self.ex.read(iprot)
15493 
        else:
15494 
          iprot.skip(ftype)
15495 
      else:
15496 
        iprot.skip(ftype)
15497 
      iprot.readFieldEnd()
15498 
    iprot.readStructEnd()
15499 
 
15500 
  def write(self, oprot):
15501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15503 
      return
15504 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15505 
    if self.ex is not None:
3064 chandransh 15506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15507 
      self.ex.write(oprot)
1627 ankur.sing 15508 
      oprot.writeFieldEnd()
15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
3431 rajveer 15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
1627 ankur.sing 15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
15526 
 
4910 phani.kuma 15527 
class markOrdersAsFirstDeliveryAttempted_args:
15528 
  """
15529 
  Attributes:
15530 
   - providerId
15531 
   - first_atdl_orders
15532 
  """
15533 
 
15534 
  thrift_spec = (
15535 
    None, # 0
15536 
    (1, TType.I64, 'providerId', None, None, ), # 1
15537 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15538 
  )
15539 
 
15540 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15541 
    self.providerId = providerId
15542 
    self.first_atdl_orders = first_atdl_orders
15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
15553 
      if fid == 1:
15554 
        if ftype == TType.I64:
15555 
          self.providerId = iprot.readI64();
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      elif fid == 2:
15559 
        if ftype == TType.MAP:
15560 
          self.first_atdl_orders = {}
6188 rajveer 15561 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15562 
          for _i388 in xrange(_size384):
15563 
            _key389 = iprot.readString();
15564 
            _val390 = iprot.readString();
15565 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15566 
          iprot.readMapEnd()
15567 
        else:
15568 
          iprot.skip(ftype)
15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
15578 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15579 
    if self.providerId is not None:
15580 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15581 
      oprot.writeI64(self.providerId)
15582 
      oprot.writeFieldEnd()
15583 
    if self.first_atdl_orders is not None:
15584 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15585 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15586 
      for kiter391,viter392 in self.first_atdl_orders.items():
15587 
        oprot.writeString(kiter391)
15588 
        oprot.writeString(viter392)
4910 phani.kuma 15589 
      oprot.writeMapEnd()
15590 
      oprot.writeFieldEnd()
15591 
    oprot.writeFieldStop()
15592 
    oprot.writeStructEnd()
15593 
 
15594 
  def validate(self):
15595 
    return
15596 
 
15597 
 
15598 
  def __repr__(self):
15599 
    L = ['%s=%r' % (key, value)
15600 
      for key, value in self.__dict__.iteritems()]
15601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15602 
 
15603 
  def __eq__(self, other):
15604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15605 
 
15606 
  def __ne__(self, other):
15607 
    return not (self == other)
15608 
 
15609 
class markOrdersAsFirstDeliveryAttempted_result:
15610 
  """
15611 
  Attributes:
15612 
   - ex
15613 
  """
15614 
 
15615 
  thrift_spec = (
15616 
    None, # 0
15617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15618 
  )
15619 
 
15620 
  def __init__(self, ex=None,):
15621 
    self.ex = ex
15622 
 
15623 
  def read(self, iprot):
15624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15626 
      return
15627 
    iprot.readStructBegin()
15628 
    while True:
15629 
      (fname, ftype, fid) = iprot.readFieldBegin()
15630 
      if ftype == TType.STOP:
15631 
        break
15632 
      if fid == 1:
15633 
        if ftype == TType.STRUCT:
15634 
          self.ex = TransactionServiceException()
15635 
          self.ex.read(iprot)
15636 
        else:
15637 
          iprot.skip(ftype)
15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
15647 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15648 
    if self.ex is not None:
15649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15650 
      self.ex.write(oprot)
15651 
      oprot.writeFieldEnd()
15652 
    oprot.writeFieldStop()
15653 
    oprot.writeStructEnd()
15654 
 
15655 
  def validate(self):
15656 
    return
15657 
 
15658 
 
15659 
  def __repr__(self):
15660 
    L = ['%s=%r' % (key, value)
15661 
      for key, value in self.__dict__.iteritems()]
15662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15663 
 
15664 
  def __eq__(self, other):
15665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15666 
 
15667 
  def __ne__(self, other):
15668 
    return not (self == other)
15669 
 
3064 chandransh 15670 
class getUndeliveredOrders_args:
1886 ankur.sing 15671 
  """
15672 
  Attributes:
3064 chandransh 15673 
   - providerId
15674 
   - warehouseId
1886 ankur.sing 15675 
  """
1627 ankur.sing 15676 
 
1886 ankur.sing 15677 
  thrift_spec = (
15678 
    None, # 0
3064 chandransh 15679 
    (1, TType.I64, 'providerId', None, None, ), # 1
15680 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15681 
  )
15682 
 
3064 chandransh 15683 
  def __init__(self, providerId=None, warehouseId=None,):
15684 
    self.providerId = providerId
15685 
    self.warehouseId = warehouseId
1886 ankur.sing 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:
3064 chandransh 15698 
          self.providerId = iprot.readI64();
1886 ankur.sing 15699 
        else:
15700 
          iprot.skip(ftype)
3064 chandransh 15701 
      elif fid == 2:
15702 
        if ftype == TType.I64:
15703 
          self.warehouseId = iprot.readI64();
15704 
        else:
15705 
          iprot.skip(ftype)
1886 ankur.sing 15706 
      else:
15707 
        iprot.skip(ftype)
15708 
      iprot.readFieldEnd()
15709 
    iprot.readStructEnd()
15710 
 
15711 
  def write(self, oprot):
15712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15714 
      return
3064 chandransh 15715 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15716 
    if self.providerId is not None:
3064 chandransh 15717 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15718 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15719 
      oprot.writeFieldEnd()
3431 rajveer 15720 
    if self.warehouseId is not None:
3064 chandransh 15721 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15722 
      oprot.writeI64(self.warehouseId)
15723 
      oprot.writeFieldEnd()
1886 ankur.sing 15724 
    oprot.writeFieldStop()
15725 
    oprot.writeStructEnd()
15726 
 
3431 rajveer 15727 
  def validate(self):
15728 
    return
15729 
 
15730 
 
1886 ankur.sing 15731 
  def __repr__(self):
15732 
    L = ['%s=%r' % (key, value)
15733 
      for key, value in self.__dict__.iteritems()]
15734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15735 
 
15736 
  def __eq__(self, other):
15737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15738 
 
15739 
  def __ne__(self, other):
15740 
    return not (self == other)
15741 
 
3064 chandransh 15742 
class getUndeliveredOrders_result:
1886 ankur.sing 15743 
  """
15744 
  Attributes:
15745 
   - success
15746 
  """
15747 
 
15748 
  thrift_spec = (
15749 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15750 
  )
15751 
 
15752 
  def __init__(self, success=None,):
15753 
    self.success = success
15754 
 
15755 
  def read(self, iprot):
15756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15758 
      return
15759 
    iprot.readStructBegin()
15760 
    while True:
15761 
      (fname, ftype, fid) = iprot.readFieldBegin()
15762 
      if ftype == TType.STOP:
15763 
        break
15764 
      if fid == 0:
15765 
        if ftype == TType.LIST:
15766 
          self.success = []
6188 rajveer 15767 
          (_etype396, _size393) = iprot.readListBegin()
15768 
          for _i397 in xrange(_size393):
15769 
            _elem398 = Order()
15770 
            _elem398.read(iprot)
15771 
            self.success.append(_elem398)
1886 ankur.sing 15772 
          iprot.readListEnd()
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
3064 chandransh 15784 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15785 
    if self.success is not None:
1886 ankur.sing 15786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15787 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15788 
      for iter399 in self.success:
15789 
        iter399.write(oprot)
1886 ankur.sing 15790 
      oprot.writeListEnd()
15791 
      oprot.writeFieldEnd()
15792 
    oprot.writeFieldStop()
15793 
    oprot.writeStructEnd()
15794 
 
3431 rajveer 15795 
  def validate(self):
15796 
    return
15797 
 
15798 
 
1886 ankur.sing 15799 
  def __repr__(self):
15800 
    L = ['%s=%r' % (key, value)
15801 
      for key, value in self.__dict__.iteritems()]
15802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15803 
 
15804 
  def __eq__(self, other):
15805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15806 
 
15807 
  def __ne__(self, other):
15808 
    return not (self == other)
15809 
 
4783 phani.kuma 15810 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15811 
 
15812 
  thrift_spec = (
15813 
  )
15814 
 
15815 
  def read(self, iprot):
15816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15818 
      return
15819 
    iprot.readStructBegin()
15820 
    while True:
15821 
      (fname, ftype, fid) = iprot.readFieldBegin()
15822 
      if ftype == TType.STOP:
15823 
        break
15824 
      else:
15825 
        iprot.skip(ftype)
15826 
      iprot.readFieldEnd()
15827 
    iprot.readStructEnd()
15828 
 
15829 
  def write(self, oprot):
15830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15832 
      return
15833 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15834 
    oprot.writeFieldStop()
15835 
    oprot.writeStructEnd()
15836 
 
15837 
  def validate(self):
15838 
    return
15839 
 
15840 
 
15841 
  def __repr__(self):
15842 
    L = ['%s=%r' % (key, value)
15843 
      for key, value in self.__dict__.iteritems()]
15844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15845 
 
15846 
  def __eq__(self, other):
15847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15848 
 
15849 
  def __ne__(self, other):
15850 
    return not (self == other)
15851 
 
15852 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15853 
  """
15854 
  Attributes:
15855 
   - success
15856 
  """
15857 
 
15858 
  thrift_spec = (
15859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15860 
  )
15861 
 
15862 
  def __init__(self, success=None,):
15863 
    self.success = success
15864 
 
15865 
  def read(self, iprot):
15866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15868 
      return
15869 
    iprot.readStructBegin()
15870 
    while True:
15871 
      (fname, ftype, fid) = iprot.readFieldBegin()
15872 
      if ftype == TType.STOP:
15873 
        break
15874 
      if fid == 0:
15875 
        if ftype == TType.LIST:
15876 
          self.success = []
6188 rajveer 15877 
          (_etype403, _size400) = iprot.readListBegin()
15878 
          for _i404 in xrange(_size400):
15879 
            _elem405 = Order()
15880 
            _elem405.read(iprot)
15881 
            self.success.append(_elem405)
4783 phani.kuma 15882 
          iprot.readListEnd()
15883 
        else:
15884 
          iprot.skip(ftype)
15885 
      else:
15886 
        iprot.skip(ftype)
15887 
      iprot.readFieldEnd()
15888 
    iprot.readStructEnd()
15889 
 
15890 
  def write(self, oprot):
15891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15893 
      return
15894 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15895 
    if self.success is not None:
15896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15898 
      for iter406 in self.success:
15899 
        iter406.write(oprot)
4783 phani.kuma 15900 
      oprot.writeListEnd()
15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
2536 chandransh 15920 
class toggleDOAFlag_args:
15921 
  """
15922 
  Attributes:
15923 
   - orderId
15924 
  """
1886 ankur.sing 15925 
 
2536 chandransh 15926 
  thrift_spec = (
15927 
    None, # 0
15928 
    (1, TType.I64, 'orderId', None, None, ), # 1
15929 
  )
15930 
 
15931 
  def __init__(self, orderId=None,):
15932 
    self.orderId = orderId
15933 
 
15934 
  def read(self, iprot):
15935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15937 
      return
15938 
    iprot.readStructBegin()
15939 
    while True:
15940 
      (fname, ftype, fid) = iprot.readFieldBegin()
15941 
      if ftype == TType.STOP:
15942 
        break
15943 
      if fid == 1:
15944 
        if ftype == TType.I64:
15945 
          self.orderId = iprot.readI64();
15946 
        else:
15947 
          iprot.skip(ftype)
15948 
      else:
15949 
        iprot.skip(ftype)
15950 
      iprot.readFieldEnd()
15951 
    iprot.readStructEnd()
15952 
 
15953 
  def write(self, oprot):
15954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15956 
      return
15957 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15958 
    if self.orderId is not None:
2536 chandransh 15959 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15960 
      oprot.writeI64(self.orderId)
15961 
      oprot.writeFieldEnd()
15962 
    oprot.writeFieldStop()
15963 
    oprot.writeStructEnd()
15964 
 
3431 rajveer 15965 
  def validate(self):
15966 
    return
15967 
 
15968 
 
2536 chandransh 15969 
  def __repr__(self):
15970 
    L = ['%s=%r' % (key, value)
15971 
      for key, value in self.__dict__.iteritems()]
15972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15973 
 
15974 
  def __eq__(self, other):
15975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15976 
 
15977 
  def __ne__(self, other):
15978 
    return not (self == other)
15979 
 
15980 
class toggleDOAFlag_result:
15981 
  """
15982 
  Attributes:
15983 
   - success
15984 
   - ex
15985 
  """
15986 
 
15987 
  thrift_spec = (
15988 
    (0, TType.BOOL, 'success', None, None, ), # 0
15989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15990 
  )
15991 
 
15992 
  def __init__(self, success=None, ex=None,):
15993 
    self.success = success
15994 
    self.ex = ex
15995 
 
15996 
  def read(self, iprot):
15997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15999 
      return
16000 
    iprot.readStructBegin()
16001 
    while True:
16002 
      (fname, ftype, fid) = iprot.readFieldBegin()
16003 
      if ftype == TType.STOP:
16004 
        break
16005 
      if fid == 0:
16006 
        if ftype == TType.BOOL:
16007 
          self.success = iprot.readBool();
16008 
        else:
16009 
          iprot.skip(ftype)
16010 
      elif fid == 1:
16011 
        if ftype == TType.STRUCT:
16012 
          self.ex = TransactionServiceException()
16013 
          self.ex.read(iprot)
16014 
        else:
16015 
          iprot.skip(ftype)
16016 
      else:
16017 
        iprot.skip(ftype)
16018 
      iprot.readFieldEnd()
16019 
    iprot.readStructEnd()
16020 
 
16021 
  def write(self, oprot):
16022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16024 
      return
16025 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16026 
    if self.success is not None:
2536 chandransh 16027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16028 
      oprot.writeBool(self.success)
16029 
      oprot.writeFieldEnd()
3431 rajveer 16030 
    if self.ex is not None:
2536 chandransh 16031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16032 
      self.ex.write(oprot)
16033 
      oprot.writeFieldEnd()
16034 
    oprot.writeFieldStop()
16035 
    oprot.writeStructEnd()
16036 
 
3431 rajveer 16037 
  def validate(self):
16038 
    return
16039 
 
16040 
 
2536 chandransh 16041 
  def __repr__(self):
16042 
    L = ['%s=%r' % (key, value)
16043 
      for key, value in self.__dict__.iteritems()]
16044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16045 
 
16046 
  def __eq__(self, other):
16047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16048 
 
16049 
  def __ne__(self, other):
16050 
    return not (self == other)
16051 
 
4712 rajveer 16052 
class markOrderAsDelivered_args:
16053 
  """
16054 
  Attributes:
16055 
   - orderId
16056 
   - deliveryTimestamp
16057 
   - receiver
16058 
  """
16059 
 
16060 
  thrift_spec = None
16061 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16062 
    self.orderId = orderId
16063 
    self.deliveryTimestamp = deliveryTimestamp
16064 
    self.receiver = receiver
16065 
 
16066 
  def read(self, iprot):
16067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16069 
      return
16070 
    iprot.readStructBegin()
16071 
    while True:
16072 
      (fname, ftype, fid) = iprot.readFieldBegin()
16073 
      if ftype == TType.STOP:
16074 
        break
16075 
      if fid == 1:
16076 
        if ftype == TType.I64:
16077 
          self.orderId = iprot.readI64();
16078 
        else:
16079 
          iprot.skip(ftype)
16080 
      elif fid == 2:
16081 
        if ftype == TType.I64:
16082 
          self.deliveryTimestamp = iprot.readI64();
16083 
        else:
16084 
          iprot.skip(ftype)
16085 
      elif fid == -1:
16086 
        if ftype == TType.STRING:
16087 
          self.receiver = iprot.readString();
16088 
        else:
16089 
          iprot.skip(ftype)
16090 
      else:
16091 
        iprot.skip(ftype)
16092 
      iprot.readFieldEnd()
16093 
    iprot.readStructEnd()
16094 
 
16095 
  def write(self, oprot):
16096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16098 
      return
16099 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16100 
    if self.receiver is not None:
16101 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16102 
      oprot.writeString(self.receiver)
16103 
      oprot.writeFieldEnd()
16104 
    if self.orderId is not None:
16105 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16106 
      oprot.writeI64(self.orderId)
16107 
      oprot.writeFieldEnd()
16108 
    if self.deliveryTimestamp is not None:
16109 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16110 
      oprot.writeI64(self.deliveryTimestamp)
16111 
      oprot.writeFieldEnd()
16112 
    oprot.writeFieldStop()
16113 
    oprot.writeStructEnd()
16114 
 
16115 
  def validate(self):
16116 
    return
16117 
 
16118 
 
16119 
  def __repr__(self):
16120 
    L = ['%s=%r' % (key, value)
16121 
      for key, value in self.__dict__.iteritems()]
16122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16123 
 
16124 
  def __eq__(self, other):
16125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16126 
 
16127 
  def __ne__(self, other):
16128 
    return not (self == other)
16129 
 
16130 
class markOrderAsDelivered_result:
16131 
  """
16132 
  Attributes:
16133 
   - ex
16134 
  """
16135 
 
16136 
  thrift_spec = (
16137 
    None, # 0
16138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16139 
  )
16140 
 
16141 
  def __init__(self, ex=None,):
16142 
    self.ex = ex
16143 
 
16144 
  def read(self, iprot):
16145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16147 
      return
16148 
    iprot.readStructBegin()
16149 
    while True:
16150 
      (fname, ftype, fid) = iprot.readFieldBegin()
16151 
      if ftype == TType.STOP:
16152 
        break
16153 
      if fid == 1:
16154 
        if ftype == TType.STRUCT:
16155 
          self.ex = TransactionServiceException()
16156 
          self.ex.read(iprot)
16157 
        else:
16158 
          iprot.skip(ftype)
16159 
      else:
16160 
        iprot.skip(ftype)
16161 
      iprot.readFieldEnd()
16162 
    iprot.readStructEnd()
16163 
 
16164 
  def write(self, oprot):
16165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16167 
      return
16168 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16169 
    if self.ex is not None:
16170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16171 
      self.ex.write(oprot)
16172 
      oprot.writeFieldEnd()
16173 
    oprot.writeFieldStop()
16174 
    oprot.writeStructEnd()
16175 
 
16176 
  def validate(self):
16177 
    return
16178 
 
16179 
 
16180 
  def __repr__(self):
16181 
    L = ['%s=%r' % (key, value)
16182 
      for key, value in self.__dict__.iteritems()]
16183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16184 
 
16185 
  def __eq__(self, other):
16186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16187 
 
16188 
  def __ne__(self, other):
16189 
    return not (self == other)
16190 
 
5553 rajveer 16191 
class markOrderAsReceivedAtStore_args:
16192 
  """
16193 
  Attributes:
16194 
   - orderId
16195 
   - deliveryTimestamp
16196 
  """
16197 
 
16198 
  thrift_spec = (
16199 
    None, # 0
16200 
    (1, TType.I64, 'orderId', None, None, ), # 1
16201 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16202 
  )
16203 
 
16204 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16205 
    self.orderId = orderId
16206 
    self.deliveryTimestamp = deliveryTimestamp
16207 
 
16208 
  def read(self, iprot):
16209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16211 
      return
16212 
    iprot.readStructBegin()
16213 
    while True:
16214 
      (fname, ftype, fid) = iprot.readFieldBegin()
16215 
      if ftype == TType.STOP:
16216 
        break
16217 
      if fid == 1:
16218 
        if ftype == TType.I64:
16219 
          self.orderId = iprot.readI64();
16220 
        else:
16221 
          iprot.skip(ftype)
16222 
      elif fid == 2:
16223 
        if ftype == TType.I64:
16224 
          self.deliveryTimestamp = iprot.readI64();
16225 
        else:
16226 
          iprot.skip(ftype)
16227 
      else:
16228 
        iprot.skip(ftype)
16229 
      iprot.readFieldEnd()
16230 
    iprot.readStructEnd()
16231 
 
16232 
  def write(self, oprot):
16233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16235 
      return
16236 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16237 
    if self.orderId is not None:
16238 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16239 
      oprot.writeI64(self.orderId)
16240 
      oprot.writeFieldEnd()
16241 
    if self.deliveryTimestamp is not None:
16242 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16243 
      oprot.writeI64(self.deliveryTimestamp)
16244 
      oprot.writeFieldEnd()
16245 
    oprot.writeFieldStop()
16246 
    oprot.writeStructEnd()
16247 
 
16248 
  def validate(self):
16249 
    return
16250 
 
16251 
 
16252 
  def __repr__(self):
16253 
    L = ['%s=%r' % (key, value)
16254 
      for key, value in self.__dict__.iteritems()]
16255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16256 
 
16257 
  def __eq__(self, other):
16258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16259 
 
16260 
  def __ne__(self, other):
16261 
    return not (self == other)
16262 
 
16263 
class markOrderAsReceivedAtStore_result:
16264 
  """
16265 
  Attributes:
16266 
   - ex
16267 
  """
16268 
 
16269 
  thrift_spec = (
16270 
    None, # 0
16271 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16272 
  )
16273 
 
16274 
  def __init__(self, ex=None,):
16275 
    self.ex = ex
16276 
 
16277 
  def read(self, iprot):
16278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16280 
      return
16281 
    iprot.readStructBegin()
16282 
    while True:
16283 
      (fname, ftype, fid) = iprot.readFieldBegin()
16284 
      if ftype == TType.STOP:
16285 
        break
16286 
      if fid == 1:
16287 
        if ftype == TType.STRUCT:
16288 
          self.ex = TransactionServiceException()
16289 
          self.ex.read(iprot)
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
16301 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16302 
    if self.ex is not None:
16303 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16304 
      self.ex.write(oprot)
16305 
      oprot.writeFieldEnd()
16306 
    oprot.writeFieldStop()
16307 
    oprot.writeStructEnd()
16308 
 
16309 
  def validate(self):
16310 
    return
16311 
 
16312 
 
16313 
  def __repr__(self):
16314 
    L = ['%s=%r' % (key, value)
16315 
      for key, value in self.__dict__.iteritems()]
16316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16317 
 
16318 
  def __eq__(self, other):
16319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16320 
 
16321 
  def __ne__(self, other):
16322 
    return not (self == other)
16323 
 
4454 rajveer 16324 
class markOrderDoaRequestReceived_args:
16325 
  """
16326 
  Attributes:
16327 
   - orderId
16328 
  """
16329 
 
16330 
  thrift_spec = (
16331 
    None, # 0
16332 
    (1, TType.I64, 'orderId', None, None, ), # 1
16333 
  )
16334 
 
16335 
  def __init__(self, orderId=None,):
16336 
    self.orderId = orderId
16337 
 
16338 
  def read(self, iprot):
16339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16341 
      return
16342 
    iprot.readStructBegin()
16343 
    while True:
16344 
      (fname, ftype, fid) = iprot.readFieldBegin()
16345 
      if ftype == TType.STOP:
16346 
        break
16347 
      if fid == 1:
16348 
        if ftype == TType.I64:
16349 
          self.orderId = iprot.readI64();
16350 
        else:
16351 
          iprot.skip(ftype)
16352 
      else:
16353 
        iprot.skip(ftype)
16354 
      iprot.readFieldEnd()
16355 
    iprot.readStructEnd()
16356 
 
16357 
  def write(self, oprot):
16358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16360 
      return
16361 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16362 
    if self.orderId is not None:
16363 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16364 
      oprot.writeI64(self.orderId)
16365 
      oprot.writeFieldEnd()
16366 
    oprot.writeFieldStop()
16367 
    oprot.writeStructEnd()
16368 
 
16369 
  def validate(self):
16370 
    return
16371 
 
16372 
 
16373 
  def __repr__(self):
16374 
    L = ['%s=%r' % (key, value)
16375 
      for key, value in self.__dict__.iteritems()]
16376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16377 
 
16378 
  def __eq__(self, other):
16379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16380 
 
16381 
  def __ne__(self, other):
16382 
    return not (self == other)
16383 
 
16384 
class markOrderDoaRequestReceived_result:
16385 
  """
16386 
  Attributes:
16387 
   - success
16388 
   - ex
16389 
  """
16390 
 
16391 
  thrift_spec = (
16392 
    (0, TType.BOOL, 'success', None, None, ), # 0
16393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16394 
  )
16395 
 
16396 
  def __init__(self, success=None, ex=None,):
16397 
    self.success = success
16398 
    self.ex = ex
16399 
 
16400 
  def read(self, iprot):
16401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16403 
      return
16404 
    iprot.readStructBegin()
16405 
    while True:
16406 
      (fname, ftype, fid) = iprot.readFieldBegin()
16407 
      if ftype == TType.STOP:
16408 
        break
16409 
      if fid == 0:
16410 
        if ftype == TType.BOOL:
16411 
          self.success = iprot.readBool();
16412 
        else:
16413 
          iprot.skip(ftype)
16414 
      elif fid == 1:
16415 
        if ftype == TType.STRUCT:
16416 
          self.ex = TransactionServiceException()
16417 
          self.ex.read(iprot)
16418 
        else:
16419 
          iprot.skip(ftype)
16420 
      else:
16421 
        iprot.skip(ftype)
16422 
      iprot.readFieldEnd()
16423 
    iprot.readStructEnd()
16424 
 
16425 
  def write(self, oprot):
16426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16428 
      return
16429 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16430 
    if self.success is not None:
16431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16432 
      oprot.writeBool(self.success)
16433 
      oprot.writeFieldEnd()
16434 
    if self.ex is not None:
16435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16436 
      self.ex.write(oprot)
16437 
      oprot.writeFieldEnd()
16438 
    oprot.writeFieldStop()
16439 
    oprot.writeStructEnd()
16440 
 
16441 
  def validate(self):
16442 
    return
16443 
 
16444 
 
16445 
  def __repr__(self):
16446 
    L = ['%s=%r' % (key, value)
16447 
      for key, value in self.__dict__.iteritems()]
16448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16449 
 
16450 
  def __eq__(self, other):
16451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16452 
 
16453 
  def __ne__(self, other):
16454 
    return not (self == other)
16455 
 
16456 
class markOrderDoaRequestAuthorized_args:
16457 
  """
16458 
  Attributes:
16459 
   - orderId
16460 
   - isAuthorized
16461 
  """
16462 
 
16463 
  thrift_spec = (
16464 
    None, # 0
16465 
    (1, TType.I64, 'orderId', None, None, ), # 1
16466 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16467 
  )
16468 
 
16469 
  def __init__(self, orderId=None, isAuthorized=None,):
16470 
    self.orderId = orderId
16471 
    self.isAuthorized = isAuthorized
16472 
 
16473 
  def read(self, iprot):
16474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16476 
      return
16477 
    iprot.readStructBegin()
16478 
    while True:
16479 
      (fname, ftype, fid) = iprot.readFieldBegin()
16480 
      if ftype == TType.STOP:
16481 
        break
16482 
      if fid == 1:
16483 
        if ftype == TType.I64:
16484 
          self.orderId = iprot.readI64();
16485 
        else:
16486 
          iprot.skip(ftype)
16487 
      elif fid == 2:
16488 
        if ftype == TType.BOOL:
16489 
          self.isAuthorized = iprot.readBool();
16490 
        else:
16491 
          iprot.skip(ftype)
16492 
      else:
16493 
        iprot.skip(ftype)
16494 
      iprot.readFieldEnd()
16495 
    iprot.readStructEnd()
16496 
 
16497 
  def write(self, oprot):
16498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16500 
      return
16501 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16502 
    if self.orderId is not None:
16503 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16504 
      oprot.writeI64(self.orderId)
16505 
      oprot.writeFieldEnd()
16506 
    if self.isAuthorized is not None:
16507 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16508 
      oprot.writeBool(self.isAuthorized)
16509 
      oprot.writeFieldEnd()
16510 
    oprot.writeFieldStop()
16511 
    oprot.writeStructEnd()
16512 
 
16513 
  def validate(self):
16514 
    return
16515 
 
16516 
 
16517 
  def __repr__(self):
16518 
    L = ['%s=%r' % (key, value)
16519 
      for key, value in self.__dict__.iteritems()]
16520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16521 
 
16522 
  def __eq__(self, other):
16523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16524 
 
16525 
  def __ne__(self, other):
16526 
    return not (self == other)
16527 
 
16528 
class markOrderDoaRequestAuthorized_result:
16529 
  """
16530 
  Attributes:
16531 
   - success
16532 
   - ex
16533 
  """
16534 
 
16535 
  thrift_spec = (
16536 
    (0, TType.BOOL, 'success', None, None, ), # 0
16537 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16538 
  )
16539 
 
16540 
  def __init__(self, success=None, ex=None,):
16541 
    self.success = success
16542 
    self.ex = ex
16543 
 
16544 
  def read(self, iprot):
16545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16547 
      return
16548 
    iprot.readStructBegin()
16549 
    while True:
16550 
      (fname, ftype, fid) = iprot.readFieldBegin()
16551 
      if ftype == TType.STOP:
16552 
        break
16553 
      if fid == 0:
16554 
        if ftype == TType.BOOL:
16555 
          self.success = iprot.readBool();
16556 
        else:
16557 
          iprot.skip(ftype)
16558 
      elif fid == 1:
16559 
        if ftype == TType.STRUCT:
16560 
          self.ex = TransactionServiceException()
16561 
          self.ex.read(iprot)
16562 
        else:
16563 
          iprot.skip(ftype)
16564 
      else:
16565 
        iprot.skip(ftype)
16566 
      iprot.readFieldEnd()
16567 
    iprot.readStructEnd()
16568 
 
16569 
  def write(self, oprot):
16570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16572 
      return
16573 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16574 
    if self.success is not None:
16575 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16576 
      oprot.writeBool(self.success)
16577 
      oprot.writeFieldEnd()
16578 
    if self.ex is not None:
16579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16580 
      self.ex.write(oprot)
16581 
      oprot.writeFieldEnd()
16582 
    oprot.writeFieldStop()
16583 
    oprot.writeStructEnd()
16584 
 
16585 
  def validate(self):
16586 
    return
16587 
 
16588 
 
16589 
  def __repr__(self):
16590 
    L = ['%s=%r' % (key, value)
16591 
      for key, value in self.__dict__.iteritems()]
16592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16593 
 
16594 
  def __eq__(self, other):
16595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16596 
 
16597 
  def __ne__(self, other):
16598 
    return not (self == other)
16599 
 
4488 rajveer 16600 
class markOrderReturnRequestReceived_args:
16601 
  """
16602 
  Attributes:
16603 
   - orderId
16604 
  """
16605 
 
16606 
  thrift_spec = (
16607 
    None, # 0
16608 
    (1, TType.I64, 'orderId', None, None, ), # 1
16609 
  )
16610 
 
16611 
  def __init__(self, orderId=None,):
16612 
    self.orderId = orderId
16613 
 
16614 
  def read(self, iprot):
16615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16617 
      return
16618 
    iprot.readStructBegin()
16619 
    while True:
16620 
      (fname, ftype, fid) = iprot.readFieldBegin()
16621 
      if ftype == TType.STOP:
16622 
        break
16623 
      if fid == 1:
16624 
        if ftype == TType.I64:
16625 
          self.orderId = iprot.readI64();
16626 
        else:
16627 
          iprot.skip(ftype)
16628 
      else:
16629 
        iprot.skip(ftype)
16630 
      iprot.readFieldEnd()
16631 
    iprot.readStructEnd()
16632 
 
16633 
  def write(self, oprot):
16634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16636 
      return
16637 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16638 
    if self.orderId is not None:
16639 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16640 
      oprot.writeI64(self.orderId)
16641 
      oprot.writeFieldEnd()
16642 
    oprot.writeFieldStop()
16643 
    oprot.writeStructEnd()
16644 
 
16645 
  def validate(self):
16646 
    return
16647 
 
16648 
 
16649 
  def __repr__(self):
16650 
    L = ['%s=%r' % (key, value)
16651 
      for key, value in self.__dict__.iteritems()]
16652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16653 
 
16654 
  def __eq__(self, other):
16655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16656 
 
16657 
  def __ne__(self, other):
16658 
    return not (self == other)
16659 
 
16660 
class markOrderReturnRequestReceived_result:
16661 
  """
16662 
  Attributes:
16663 
   - success
16664 
   - ex
16665 
  """
16666 
 
16667 
  thrift_spec = (
16668 
    (0, TType.BOOL, 'success', None, None, ), # 0
16669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16670 
  )
16671 
 
16672 
  def __init__(self, success=None, ex=None,):
16673 
    self.success = success
16674 
    self.ex = ex
16675 
 
16676 
  def read(self, iprot):
16677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16679 
      return
16680 
    iprot.readStructBegin()
16681 
    while True:
16682 
      (fname, ftype, fid) = iprot.readFieldBegin()
16683 
      if ftype == TType.STOP:
16684 
        break
16685 
      if fid == 0:
16686 
        if ftype == TType.BOOL:
16687 
          self.success = iprot.readBool();
16688 
        else:
16689 
          iprot.skip(ftype)
16690 
      elif fid == 1:
16691 
        if ftype == TType.STRUCT:
16692 
          self.ex = TransactionServiceException()
16693 
          self.ex.read(iprot)
16694 
        else:
16695 
          iprot.skip(ftype)
16696 
      else:
16697 
        iprot.skip(ftype)
16698 
      iprot.readFieldEnd()
16699 
    iprot.readStructEnd()
16700 
 
16701 
  def write(self, oprot):
16702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16704 
      return
16705 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16706 
    if self.success is not None:
16707 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16708 
      oprot.writeBool(self.success)
16709 
      oprot.writeFieldEnd()
16710 
    if self.ex is not None:
16711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16712 
      self.ex.write(oprot)
16713 
      oprot.writeFieldEnd()
16714 
    oprot.writeFieldStop()
16715 
    oprot.writeStructEnd()
16716 
 
16717 
  def validate(self):
16718 
    return
16719 
 
16720 
 
16721 
  def __repr__(self):
16722 
    L = ['%s=%r' % (key, value)
16723 
      for key, value in self.__dict__.iteritems()]
16724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16725 
 
16726 
  def __eq__(self, other):
16727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16728 
 
16729 
  def __ne__(self, other):
16730 
    return not (self == other)
16731 
 
16732 
class markOrderReturnRequestAuthorized_args:
16733 
  """
16734 
  Attributes:
16735 
   - orderId
16736 
   - isAuthorized
16737 
  """
16738 
 
16739 
  thrift_spec = (
16740 
    None, # 0
16741 
    (1, TType.I64, 'orderId', None, None, ), # 1
16742 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16743 
  )
16744 
 
16745 
  def __init__(self, orderId=None, isAuthorized=None,):
16746 
    self.orderId = orderId
16747 
    self.isAuthorized = isAuthorized
16748 
 
16749 
  def read(self, iprot):
16750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16752 
      return
16753 
    iprot.readStructBegin()
16754 
    while True:
16755 
      (fname, ftype, fid) = iprot.readFieldBegin()
16756 
      if ftype == TType.STOP:
16757 
        break
16758 
      if fid == 1:
16759 
        if ftype == TType.I64:
16760 
          self.orderId = iprot.readI64();
16761 
        else:
16762 
          iprot.skip(ftype)
16763 
      elif fid == 2:
16764 
        if ftype == TType.BOOL:
16765 
          self.isAuthorized = iprot.readBool();
16766 
        else:
16767 
          iprot.skip(ftype)
16768 
      else:
16769 
        iprot.skip(ftype)
16770 
      iprot.readFieldEnd()
16771 
    iprot.readStructEnd()
16772 
 
16773 
  def write(self, oprot):
16774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16776 
      return
16777 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16778 
    if self.orderId is not None:
16779 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16780 
      oprot.writeI64(self.orderId)
16781 
      oprot.writeFieldEnd()
16782 
    if self.isAuthorized is not None:
16783 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16784 
      oprot.writeBool(self.isAuthorized)
16785 
      oprot.writeFieldEnd()
16786 
    oprot.writeFieldStop()
16787 
    oprot.writeStructEnd()
16788 
 
16789 
  def validate(self):
16790 
    return
16791 
 
16792 
 
16793 
  def __repr__(self):
16794 
    L = ['%s=%r' % (key, value)
16795 
      for key, value in self.__dict__.iteritems()]
16796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16797 
 
16798 
  def __eq__(self, other):
16799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16800 
 
16801 
  def __ne__(self, other):
16802 
    return not (self == other)
16803 
 
16804 
class markOrderReturnRequestAuthorized_result:
16805 
  """
16806 
  Attributes:
16807 
   - success
16808 
   - ex
16809 
  """
16810 
 
16811 
  thrift_spec = (
16812 
    (0, TType.BOOL, 'success', None, None, ), # 0
16813 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16814 
  )
16815 
 
16816 
  def __init__(self, success=None, ex=None,):
16817 
    self.success = success
16818 
    self.ex = ex
16819 
 
16820 
  def read(self, iprot):
16821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16823 
      return
16824 
    iprot.readStructBegin()
16825 
    while True:
16826 
      (fname, ftype, fid) = iprot.readFieldBegin()
16827 
      if ftype == TType.STOP:
16828 
        break
16829 
      if fid == 0:
16830 
        if ftype == TType.BOOL:
16831 
          self.success = iprot.readBool();
16832 
        else:
16833 
          iprot.skip(ftype)
16834 
      elif fid == 1:
16835 
        if ftype == TType.STRUCT:
16836 
          self.ex = TransactionServiceException()
16837 
          self.ex.read(iprot)
16838 
        else:
16839 
          iprot.skip(ftype)
16840 
      else:
16841 
        iprot.skip(ftype)
16842 
      iprot.readFieldEnd()
16843 
    iprot.readStructEnd()
16844 
 
16845 
  def write(self, oprot):
16846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16848 
      return
16849 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16850 
    if self.success is not None:
16851 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16852 
      oprot.writeBool(self.success)
16853 
      oprot.writeFieldEnd()
16854 
    if self.ex is not None:
16855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16856 
      self.ex.write(oprot)
16857 
      oprot.writeFieldEnd()
16858 
    oprot.writeFieldStop()
16859 
    oprot.writeStructEnd()
16860 
 
16861 
  def validate(self):
16862 
    return
16863 
 
16864 
 
16865 
  def __repr__(self):
16866 
    L = ['%s=%r' % (key, value)
16867 
      for key, value in self.__dict__.iteritems()]
16868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16869 
 
16870 
  def __eq__(self, other):
16871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16872 
 
16873 
  def __ne__(self, other):
16874 
    return not (self == other)
16875 
 
2536 chandransh 16876 
class requestPickupNumber_args:
16877 
  """
16878 
  Attributes:
16879 
   - orderId
4579 rajveer 16880 
   - providerId
2536 chandransh 16881 
  """
16882 
 
16883 
  thrift_spec = (
16884 
    None, # 0
16885 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16886 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16887 
  )
16888 
 
4579 rajveer 16889 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16890 
    self.orderId = orderId
4579 rajveer 16891 
    self.providerId = providerId
2536 chandransh 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)
4579 rajveer 16907 
      elif fid == 2:
16908 
        if ftype == TType.I64:
16909 
          self.providerId = iprot.readI64();
16910 
        else:
16911 
          iprot.skip(ftype)
2536 chandransh 16912 
      else:
16913 
        iprot.skip(ftype)
16914 
      iprot.readFieldEnd()
16915 
    iprot.readStructEnd()
16916 
 
16917 
  def write(self, oprot):
16918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16920 
      return
16921 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16922 
    if self.orderId is not None:
2536 chandransh 16923 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16924 
      oprot.writeI64(self.orderId)
16925 
      oprot.writeFieldEnd()
4579 rajveer 16926 
    if self.providerId is not None:
16927 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16928 
      oprot.writeI64(self.providerId)
16929 
      oprot.writeFieldEnd()
2536 chandransh 16930 
    oprot.writeFieldStop()
16931 
    oprot.writeStructEnd()
16932 
 
3431 rajveer 16933 
  def validate(self):
16934 
    return
16935 
 
16936 
 
2536 chandransh 16937 
  def __repr__(self):
16938 
    L = ['%s=%r' % (key, value)
16939 
      for key, value in self.__dict__.iteritems()]
16940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16941 
 
16942 
  def __eq__(self, other):
16943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16944 
 
16945 
  def __ne__(self, other):
16946 
    return not (self == other)
16947 
 
16948 
class requestPickupNumber_result:
16949 
  """
16950 
  Attributes:
16951 
   - success
16952 
   - ex
16953 
  """
16954 
 
16955 
  thrift_spec = (
16956 
    (0, TType.BOOL, 'success', None, None, ), # 0
16957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16958 
  )
16959 
 
16960 
  def __init__(self, success=None, ex=None,):
16961 
    self.success = success
16962 
    self.ex = ex
16963 
 
16964 
  def read(self, iprot):
16965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16967 
      return
16968 
    iprot.readStructBegin()
16969 
    while True:
16970 
      (fname, ftype, fid) = iprot.readFieldBegin()
16971 
      if ftype == TType.STOP:
16972 
        break
16973 
      if fid == 0:
16974 
        if ftype == TType.BOOL:
16975 
          self.success = iprot.readBool();
16976 
        else:
16977 
          iprot.skip(ftype)
16978 
      elif fid == 1:
16979 
        if ftype == TType.STRUCT:
16980 
          self.ex = TransactionServiceException()
16981 
          self.ex.read(iprot)
16982 
        else:
16983 
          iprot.skip(ftype)
16984 
      else:
16985 
        iprot.skip(ftype)
16986 
      iprot.readFieldEnd()
16987 
    iprot.readStructEnd()
16988 
 
16989 
  def write(self, oprot):
16990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16992 
      return
16993 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16994 
    if self.success is not None:
2536 chandransh 16995 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16996 
      oprot.writeBool(self.success)
16997 
      oprot.writeFieldEnd()
3431 rajveer 16998 
    if self.ex is not None:
2536 chandransh 16999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17000 
      self.ex.write(oprot)
17001 
      oprot.writeFieldEnd()
17002 
    oprot.writeFieldStop()
17003 
    oprot.writeStructEnd()
17004 
 
3431 rajveer 17005 
  def validate(self):
17006 
    return
17007 
 
17008 
 
2536 chandransh 17009 
  def __repr__(self):
17010 
    L = ['%s=%r' % (key, value)
17011 
      for key, value in self.__dict__.iteritems()]
17012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17013 
 
17014 
  def __eq__(self, other):
17015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17016 
 
17017 
  def __ne__(self, other):
17018 
    return not (self == other)
17019 
 
17020 
class authorizePickup_args:
17021 
  """
17022 
  Attributes:
17023 
   - orderId
17024 
   - pickupNumber
4602 rajveer 17025 
   - providerId
2536 chandransh 17026 
  """
17027 
 
17028 
  thrift_spec = (
17029 
    None, # 0
17030 
    (1, TType.I64, 'orderId', None, None, ), # 1
17031 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17032 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17033 
  )
17034 
 
4602 rajveer 17035 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17036 
    self.orderId = orderId
17037 
    self.pickupNumber = pickupNumber
4602 rajveer 17038 
    self.providerId = providerId
2536 chandransh 17039 
 
17040 
  def read(self, iprot):
17041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17043 
      return
17044 
    iprot.readStructBegin()
17045 
    while True:
17046 
      (fname, ftype, fid) = iprot.readFieldBegin()
17047 
      if ftype == TType.STOP:
17048 
        break
17049 
      if fid == 1:
17050 
        if ftype == TType.I64:
17051 
          self.orderId = iprot.readI64();
17052 
        else:
17053 
          iprot.skip(ftype)
17054 
      elif fid == 2:
17055 
        if ftype == TType.STRING:
17056 
          self.pickupNumber = iprot.readString();
17057 
        else:
17058 
          iprot.skip(ftype)
4602 rajveer 17059 
      elif fid == 3:
17060 
        if ftype == TType.I64:
17061 
          self.providerId = iprot.readI64();
17062 
        else:
17063 
          iprot.skip(ftype)
2536 chandransh 17064 
      else:
17065 
        iprot.skip(ftype)
17066 
      iprot.readFieldEnd()
17067 
    iprot.readStructEnd()
17068 
 
17069 
  def write(self, oprot):
17070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17072 
      return
17073 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17074 
    if self.orderId is not None:
2536 chandransh 17075 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17076 
      oprot.writeI64(self.orderId)
17077 
      oprot.writeFieldEnd()
3431 rajveer 17078 
    if self.pickupNumber is not None:
2536 chandransh 17079 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17080 
      oprot.writeString(self.pickupNumber)
17081 
      oprot.writeFieldEnd()
4602 rajveer 17082 
    if self.providerId is not None:
17083 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17084 
      oprot.writeI64(self.providerId)
17085 
      oprot.writeFieldEnd()
2536 chandransh 17086 
    oprot.writeFieldStop()
17087 
    oprot.writeStructEnd()
17088 
 
3431 rajveer 17089 
  def validate(self):
17090 
    return
17091 
 
17092 
 
2536 chandransh 17093 
  def __repr__(self):
17094 
    L = ['%s=%r' % (key, value)
17095 
      for key, value in self.__dict__.iteritems()]
17096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17097 
 
17098 
  def __eq__(self, other):
17099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17100 
 
17101 
  def __ne__(self, other):
17102 
    return not (self == other)
17103 
 
17104 
class authorizePickup_result:
17105 
  """
17106 
  Attributes:
17107 
   - success
17108 
   - ex
17109 
  """
17110 
 
17111 
  thrift_spec = (
17112 
    (0, TType.BOOL, 'success', None, None, ), # 0
17113 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17114 
  )
17115 
 
17116 
  def __init__(self, success=None, ex=None,):
17117 
    self.success = success
17118 
    self.ex = ex
17119 
 
17120 
  def read(self, iprot):
17121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17123 
      return
17124 
    iprot.readStructBegin()
17125 
    while True:
17126 
      (fname, ftype, fid) = iprot.readFieldBegin()
17127 
      if ftype == TType.STOP:
17128 
        break
17129 
      if fid == 0:
17130 
        if ftype == TType.BOOL:
17131 
          self.success = iprot.readBool();
17132 
        else:
17133 
          iprot.skip(ftype)
17134 
      elif fid == 1:
17135 
        if ftype == TType.STRUCT:
17136 
          self.ex = TransactionServiceException()
17137 
          self.ex.read(iprot)
17138 
        else:
17139 
          iprot.skip(ftype)
17140 
      else:
17141 
        iprot.skip(ftype)
17142 
      iprot.readFieldEnd()
17143 
    iprot.readStructEnd()
17144 
 
17145 
  def write(self, oprot):
17146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17148 
      return
17149 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17150 
    if self.success is not None:
2536 chandransh 17151 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17152 
      oprot.writeBool(self.success)
17153 
      oprot.writeFieldEnd()
3431 rajveer 17154 
    if self.ex is not None:
2536 chandransh 17155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17156 
      self.ex.write(oprot)
17157 
      oprot.writeFieldEnd()
17158 
    oprot.writeFieldStop()
17159 
    oprot.writeStructEnd()
17160 
 
3431 rajveer 17161 
  def validate(self):
17162 
    return
17163 
 
17164 
 
2536 chandransh 17165 
  def __repr__(self):
17166 
    L = ['%s=%r' % (key, value)
17167 
      for key, value in self.__dict__.iteritems()]
17168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17169 
 
17170 
  def __eq__(self, other):
17171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17172 
 
17173 
  def __ne__(self, other):
17174 
    return not (self == other)
17175 
 
2764 chandransh 17176 
class markDoasAsPickedUp_args:
17177 
  """
17178 
  Attributes:
17179 
   - providerId
17180 
   - pickupDetails
17181 
  """
17182 
 
17183 
  thrift_spec = (
17184 
    None, # 0
17185 
    (1, TType.I64, 'providerId', None, None, ), # 1
17186 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17187 
  )
17188 
 
17189 
  def __init__(self, providerId=None, pickupDetails=None,):
17190 
    self.providerId = providerId
17191 
    self.pickupDetails = pickupDetails
17192 
 
17193 
  def read(self, iprot):
17194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17196 
      return
17197 
    iprot.readStructBegin()
17198 
    while True:
17199 
      (fname, ftype, fid) = iprot.readFieldBegin()
17200 
      if ftype == TType.STOP:
17201 
        break
17202 
      if fid == 1:
17203 
        if ftype == TType.I64:
17204 
          self.providerId = iprot.readI64();
17205 
        else:
17206 
          iprot.skip(ftype)
17207 
      elif fid == 2:
17208 
        if ftype == TType.MAP:
17209 
          self.pickupDetails = {}
6188 rajveer 17210 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17211 
          for _i411 in xrange(_size407):
17212 
            _key412 = iprot.readString();
17213 
            _val413 = iprot.readString();
17214 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17215 
          iprot.readMapEnd()
17216 
        else:
17217 
          iprot.skip(ftype)
17218 
      else:
17219 
        iprot.skip(ftype)
17220 
      iprot.readFieldEnd()
17221 
    iprot.readStructEnd()
17222 
 
17223 
  def write(self, oprot):
17224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17226 
      return
17227 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17228 
    if self.providerId is not None:
2764 chandransh 17229 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17230 
      oprot.writeI64(self.providerId)
17231 
      oprot.writeFieldEnd()
3431 rajveer 17232 
    if self.pickupDetails is not None:
2764 chandransh 17233 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17234 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17235 
      for kiter414,viter415 in self.pickupDetails.items():
17236 
        oprot.writeString(kiter414)
17237 
        oprot.writeString(viter415)
2764 chandransh 17238 
      oprot.writeMapEnd()
17239 
      oprot.writeFieldEnd()
17240 
    oprot.writeFieldStop()
17241 
    oprot.writeStructEnd()
17242 
 
3431 rajveer 17243 
  def validate(self):
17244 
    return
17245 
 
17246 
 
2764 chandransh 17247 
  def __repr__(self):
17248 
    L = ['%s=%r' % (key, value)
17249 
      for key, value in self.__dict__.iteritems()]
17250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17251 
 
17252 
  def __eq__(self, other):
17253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17254 
 
17255 
  def __ne__(self, other):
17256 
    return not (self == other)
17257 
 
17258 
class markDoasAsPickedUp_result:
4910 phani.kuma 17259 
 
17260 
  thrift_spec = (
17261 
  )
17262 
 
17263 
  def read(self, iprot):
17264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17266 
      return
17267 
    iprot.readStructBegin()
17268 
    while True:
17269 
      (fname, ftype, fid) = iprot.readFieldBegin()
17270 
      if ftype == TType.STOP:
17271 
        break
17272 
      else:
17273 
        iprot.skip(ftype)
17274 
      iprot.readFieldEnd()
17275 
    iprot.readStructEnd()
17276 
 
17277 
  def write(self, oprot):
17278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17280 
      return
17281 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17282 
    oprot.writeFieldStop()
17283 
    oprot.writeStructEnd()
17284 
 
17285 
  def validate(self):
17286 
    return
17287 
 
17288 
 
17289 
  def __repr__(self):
17290 
    L = ['%s=%r' % (key, value)
17291 
      for key, value in self.__dict__.iteritems()]
17292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17293 
 
17294 
  def __eq__(self, other):
17295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17296 
 
17297 
  def __ne__(self, other):
17298 
    return not (self == other)
17299 
 
17300 
class getDoasNotPickedUp_args:
2764 chandransh 17301 
  """
17302 
  Attributes:
4910 phani.kuma 17303 
   - providerId
17304 
  """
17305 
 
17306 
  thrift_spec = (
17307 
    None, # 0
17308 
    (1, TType.I64, 'providerId', None, None, ), # 1
17309 
  )
17310 
 
17311 
  def __init__(self, providerId=None,):
17312 
    self.providerId = providerId
17313 
 
17314 
  def read(self, iprot):
17315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17317 
      return
17318 
    iprot.readStructBegin()
17319 
    while True:
17320 
      (fname, ftype, fid) = iprot.readFieldBegin()
17321 
      if ftype == TType.STOP:
17322 
        break
17323 
      if fid == 1:
17324 
        if ftype == TType.I64:
17325 
          self.providerId = iprot.readI64();
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      else:
17329 
        iprot.skip(ftype)
17330 
      iprot.readFieldEnd()
17331 
    iprot.readStructEnd()
17332 
 
17333 
  def write(self, oprot):
17334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17336 
      return
17337 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17338 
    if self.providerId is not None:
17339 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17340 
      oprot.writeI64(self.providerId)
17341 
      oprot.writeFieldEnd()
17342 
    oprot.writeFieldStop()
17343 
    oprot.writeStructEnd()
17344 
 
17345 
  def validate(self):
17346 
    return
17347 
 
17348 
 
17349 
  def __repr__(self):
17350 
    L = ['%s=%r' % (key, value)
17351 
      for key, value in self.__dict__.iteritems()]
17352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17353 
 
17354 
  def __eq__(self, other):
17355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17356 
 
17357 
  def __ne__(self, other):
17358 
    return not (self == other)
17359 
 
17360 
class getDoasNotPickedUp_result:
17361 
  """
17362 
  Attributes:
2764 chandransh 17363 
   - success
17364 
  """
17365 
 
17366 
  thrift_spec = (
17367 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17368 
  )
17369 
 
17370 
  def __init__(self, success=None,):
17371 
    self.success = success
17372 
 
17373 
  def read(self, iprot):
17374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17376 
      return
17377 
    iprot.readStructBegin()
17378 
    while True:
17379 
      (fname, ftype, fid) = iprot.readFieldBegin()
17380 
      if ftype == TType.STOP:
17381 
        break
17382 
      if fid == 0:
17383 
        if ftype == TType.LIST:
17384 
          self.success = []
6188 rajveer 17385 
          (_etype419, _size416) = iprot.readListBegin()
17386 
          for _i420 in xrange(_size416):
17387 
            _elem421 = Order()
17388 
            _elem421.read(iprot)
17389 
            self.success.append(_elem421)
2764 chandransh 17390 
          iprot.readListEnd()
17391 
        else:
17392 
          iprot.skip(ftype)
17393 
      else:
17394 
        iprot.skip(ftype)
17395 
      iprot.readFieldEnd()
17396 
    iprot.readStructEnd()
17397 
 
17398 
  def write(self, oprot):
17399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17401 
      return
4910 phani.kuma 17402 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17403 
    if self.success is not None:
2764 chandransh 17404 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17405 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17406 
      for iter422 in self.success:
17407 
        iter422.write(oprot)
2764 chandransh 17408 
      oprot.writeListEnd()
17409 
      oprot.writeFieldEnd()
17410 
    oprot.writeFieldStop()
17411 
    oprot.writeStructEnd()
17412 
 
3431 rajveer 17413 
  def validate(self):
17414 
    return
17415 
 
17416 
 
2764 chandransh 17417 
  def __repr__(self):
17418 
    L = ['%s=%r' % (key, value)
17419 
      for key, value in self.__dict__.iteritems()]
17420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17421 
 
17422 
  def __eq__(self, other):
17423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17424 
 
17425 
  def __ne__(self, other):
17426 
    return not (self == other)
17427 
 
4741 phani.kuma 17428 
class markReturnOrdersAsPickedUp_args:
17429 
  """
17430 
  Attributes:
17431 
   - providerId
17432 
   - pickupDetails
17433 
  """
17434 
 
17435 
  thrift_spec = (
17436 
    None, # 0
17437 
    (1, TType.I64, 'providerId', None, None, ), # 1
17438 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17439 
  )
17440 
 
17441 
  def __init__(self, providerId=None, pickupDetails=None,):
17442 
    self.providerId = providerId
17443 
    self.pickupDetails = pickupDetails
17444 
 
17445 
  def read(self, iprot):
17446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17448 
      return
17449 
    iprot.readStructBegin()
17450 
    while True:
17451 
      (fname, ftype, fid) = iprot.readFieldBegin()
17452 
      if ftype == TType.STOP:
17453 
        break
17454 
      if fid == 1:
17455 
        if ftype == TType.I64:
17456 
          self.providerId = iprot.readI64();
17457 
        else:
17458 
          iprot.skip(ftype)
17459 
      elif fid == 2:
17460 
        if ftype == TType.MAP:
17461 
          self.pickupDetails = {}
6188 rajveer 17462 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17463 
          for _i427 in xrange(_size423):
17464 
            _key428 = iprot.readString();
17465 
            _val429 = iprot.readString();
17466 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17467 
          iprot.readMapEnd()
17468 
        else:
17469 
          iprot.skip(ftype)
17470 
      else:
17471 
        iprot.skip(ftype)
17472 
      iprot.readFieldEnd()
17473 
    iprot.readStructEnd()
17474 
 
17475 
  def write(self, oprot):
17476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17478 
      return
17479 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17480 
    if self.providerId is not None:
17481 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17482 
      oprot.writeI64(self.providerId)
17483 
      oprot.writeFieldEnd()
17484 
    if self.pickupDetails is not None:
17485 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17486 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17487 
      for kiter430,viter431 in self.pickupDetails.items():
17488 
        oprot.writeString(kiter430)
17489 
        oprot.writeString(viter431)
4741 phani.kuma 17490 
      oprot.writeMapEnd()
17491 
      oprot.writeFieldEnd()
17492 
    oprot.writeFieldStop()
17493 
    oprot.writeStructEnd()
17494 
 
17495 
  def validate(self):
17496 
    return
17497 
 
17498 
 
17499 
  def __repr__(self):
17500 
    L = ['%s=%r' % (key, value)
17501 
      for key, value in self.__dict__.iteritems()]
17502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17503 
 
17504 
  def __eq__(self, other):
17505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17506 
 
17507 
  def __ne__(self, other):
17508 
    return not (self == other)
17509 
 
17510 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17511 
 
17512 
  thrift_spec = (
17513 
  )
17514 
 
17515 
  def read(self, iprot):
17516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17518 
      return
17519 
    iprot.readStructBegin()
17520 
    while True:
17521 
      (fname, ftype, fid) = iprot.readFieldBegin()
17522 
      if ftype == TType.STOP:
17523 
        break
17524 
      else:
17525 
        iprot.skip(ftype)
17526 
      iprot.readFieldEnd()
17527 
    iprot.readStructEnd()
17528 
 
17529 
  def write(self, oprot):
17530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17532 
      return
17533 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17534 
    oprot.writeFieldStop()
17535 
    oprot.writeStructEnd()
17536 
 
17537 
  def validate(self):
17538 
    return
17539 
 
17540 
 
17541 
  def __repr__(self):
17542 
    L = ['%s=%r' % (key, value)
17543 
      for key, value in self.__dict__.iteritems()]
17544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17545 
 
17546 
  def __eq__(self, other):
17547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17548 
 
17549 
  def __ne__(self, other):
17550 
    return not (self == other)
17551 
 
17552 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17553 
  """
17554 
  Attributes:
4910 phani.kuma 17555 
   - providerId
17556 
  """
17557 
 
17558 
  thrift_spec = (
17559 
    None, # 0
17560 
    (1, TType.I64, 'providerId', None, None, ), # 1
17561 
  )
17562 
 
17563 
  def __init__(self, providerId=None,):
17564 
    self.providerId = providerId
17565 
 
17566 
  def read(self, iprot):
17567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17569 
      return
17570 
    iprot.readStructBegin()
17571 
    while True:
17572 
      (fname, ftype, fid) = iprot.readFieldBegin()
17573 
      if ftype == TType.STOP:
17574 
        break
17575 
      if fid == 1:
17576 
        if ftype == TType.I64:
17577 
          self.providerId = iprot.readI64();
17578 
        else:
17579 
          iprot.skip(ftype)
17580 
      else:
17581 
        iprot.skip(ftype)
17582 
      iprot.readFieldEnd()
17583 
    iprot.readStructEnd()
17584 
 
17585 
  def write(self, oprot):
17586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17588 
      return
17589 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17590 
    if self.providerId is not None:
17591 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17592 
      oprot.writeI64(self.providerId)
17593 
      oprot.writeFieldEnd()
17594 
    oprot.writeFieldStop()
17595 
    oprot.writeStructEnd()
17596 
 
17597 
  def validate(self):
17598 
    return
17599 
 
17600 
 
17601 
  def __repr__(self):
17602 
    L = ['%s=%r' % (key, value)
17603 
      for key, value in self.__dict__.iteritems()]
17604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17605 
 
17606 
  def __eq__(self, other):
17607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17608 
 
17609 
  def __ne__(self, other):
17610 
    return not (self == other)
17611 
 
17612 
class getReturnOrdersNotPickedUp_result:
17613 
  """
17614 
  Attributes:
4741 phani.kuma 17615 
   - success
17616 
  """
17617 
 
17618 
  thrift_spec = (
17619 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17620 
  )
17621 
 
17622 
  def __init__(self, success=None,):
17623 
    self.success = success
17624 
 
17625 
  def read(self, iprot):
17626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17628 
      return
17629 
    iprot.readStructBegin()
17630 
    while True:
17631 
      (fname, ftype, fid) = iprot.readFieldBegin()
17632 
      if ftype == TType.STOP:
17633 
        break
17634 
      if fid == 0:
17635 
        if ftype == TType.LIST:
17636 
          self.success = []
6188 rajveer 17637 
          (_etype435, _size432) = iprot.readListBegin()
17638 
          for _i436 in xrange(_size432):
17639 
            _elem437 = Order()
17640 
            _elem437.read(iprot)
17641 
            self.success.append(_elem437)
4741 phani.kuma 17642 
          iprot.readListEnd()
17643 
        else:
17644 
          iprot.skip(ftype)
17645 
      else:
17646 
        iprot.skip(ftype)
17647 
      iprot.readFieldEnd()
17648 
    iprot.readStructEnd()
17649 
 
17650 
  def write(self, oprot):
17651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17653 
      return
4910 phani.kuma 17654 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17655 
    if self.success is not None:
17656 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17657 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17658 
      for iter438 in self.success:
17659 
        iter438.write(oprot)
4741 phani.kuma 17660 
      oprot.writeListEnd()
17661 
      oprot.writeFieldEnd()
17662 
    oprot.writeFieldStop()
17663 
    oprot.writeStructEnd()
17664 
 
17665 
  def validate(self):
17666 
    return
17667 
 
17668 
 
17669 
  def __repr__(self):
17670 
    L = ['%s=%r' % (key, value)
17671 
      for key, value in self.__dict__.iteritems()]
17672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17673 
 
17674 
  def __eq__(self, other):
17675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17676 
 
17677 
  def __ne__(self, other):
17678 
    return not (self == other)
17679 
 
2616 chandransh 17680 
class receiveReturn_args:
2591 chandransh 17681 
  """
17682 
  Attributes:
17683 
   - orderId
4479 rajveer 17684 
   - receiveCondition
2591 chandransh 17685 
  """
2536 chandransh 17686 
 
2591 chandransh 17687 
  thrift_spec = (
17688 
    None, # 0
17689 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17690 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17691 
  )
17692 
 
4479 rajveer 17693 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17694 
    self.orderId = orderId
4479 rajveer 17695 
    self.receiveCondition = receiveCondition
2591 chandransh 17696 
 
17697 
  def read(self, iprot):
17698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17700 
      return
17701 
    iprot.readStructBegin()
17702 
    while True:
17703 
      (fname, ftype, fid) = iprot.readFieldBegin()
17704 
      if ftype == TType.STOP:
17705 
        break
17706 
      if fid == 1:
17707 
        if ftype == TType.I64:
17708 
          self.orderId = iprot.readI64();
17709 
        else:
17710 
          iprot.skip(ftype)
4479 rajveer 17711 
      elif fid == 2:
17712 
        if ftype == TType.I64:
17713 
          self.receiveCondition = iprot.readI64();
17714 
        else:
17715 
          iprot.skip(ftype)
2591 chandransh 17716 
      else:
17717 
        iprot.skip(ftype)
17718 
      iprot.readFieldEnd()
17719 
    iprot.readStructEnd()
17720 
 
17721 
  def write(self, oprot):
17722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17724 
      return
2616 chandransh 17725 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17726 
    if self.orderId is not None:
2591 chandransh 17727 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17728 
      oprot.writeI64(self.orderId)
17729 
      oprot.writeFieldEnd()
4479 rajveer 17730 
    if self.receiveCondition is not None:
17731 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17732 
      oprot.writeI64(self.receiveCondition)
17733 
      oprot.writeFieldEnd()
2591 chandransh 17734 
    oprot.writeFieldStop()
17735 
    oprot.writeStructEnd()
17736 
 
3431 rajveer 17737 
  def validate(self):
17738 
    return
17739 
 
17740 
 
2591 chandransh 17741 
  def __repr__(self):
17742 
    L = ['%s=%r' % (key, value)
17743 
      for key, value in self.__dict__.iteritems()]
17744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17745 
 
17746 
  def __eq__(self, other):
17747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17748 
 
17749 
  def __ne__(self, other):
17750 
    return not (self == other)
17751 
 
2616 chandransh 17752 
class receiveReturn_result:
2591 chandransh 17753 
  """
17754 
  Attributes:
17755 
   - success
17756 
   - ex
17757 
  """
17758 
 
17759 
  thrift_spec = (
17760 
    (0, TType.BOOL, 'success', None, None, ), # 0
17761 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17762 
  )
17763 
 
17764 
  def __init__(self, success=None, ex=None,):
17765 
    self.success = success
17766 
    self.ex = ex
17767 
 
17768 
  def read(self, iprot):
17769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17771 
      return
17772 
    iprot.readStructBegin()
17773 
    while True:
17774 
      (fname, ftype, fid) = iprot.readFieldBegin()
17775 
      if ftype == TType.STOP:
17776 
        break
17777 
      if fid == 0:
17778 
        if ftype == TType.BOOL:
17779 
          self.success = iprot.readBool();
17780 
        else:
17781 
          iprot.skip(ftype)
17782 
      elif fid == 1:
17783 
        if ftype == TType.STRUCT:
17784 
          self.ex = TransactionServiceException()
17785 
          self.ex.read(iprot)
17786 
        else:
17787 
          iprot.skip(ftype)
17788 
      else:
17789 
        iprot.skip(ftype)
17790 
      iprot.readFieldEnd()
17791 
    iprot.readStructEnd()
17792 
 
17793 
  def write(self, oprot):
17794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17796 
      return
2616 chandransh 17797 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17798 
    if self.success is not None:
2591 chandransh 17799 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17800 
      oprot.writeBool(self.success)
17801 
      oprot.writeFieldEnd()
3431 rajveer 17802 
    if self.ex is not None:
2591 chandransh 17803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17804 
      self.ex.write(oprot)
17805 
      oprot.writeFieldEnd()
17806 
    oprot.writeFieldStop()
17807 
    oprot.writeStructEnd()
17808 
 
3431 rajveer 17809 
  def validate(self):
17810 
    return
17811 
 
17812 
 
2591 chandransh 17813 
  def __repr__(self):
17814 
    L = ['%s=%r' % (key, value)
17815 
      for key, value in self.__dict__.iteritems()]
17816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17817 
 
17818 
  def __eq__(self, other):
17819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17820 
 
17821 
  def __ne__(self, other):
17822 
    return not (self == other)
17823 
 
17824 
class validateDoa_args:
17825 
  """
17826 
  Attributes:
17827 
   - orderId
17828 
   - isValid
17829 
  """
17830 
 
17831 
  thrift_spec = (
17832 
    None, # 0
17833 
    (1, TType.I64, 'orderId', None, None, ), # 1
17834 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17835 
  )
17836 
 
17837 
  def __init__(self, orderId=None, isValid=None,):
17838 
    self.orderId = orderId
17839 
    self.isValid = isValid
17840 
 
17841 
  def read(self, iprot):
17842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17844 
      return
17845 
    iprot.readStructBegin()
17846 
    while True:
17847 
      (fname, ftype, fid) = iprot.readFieldBegin()
17848 
      if ftype == TType.STOP:
17849 
        break
17850 
      if fid == 1:
17851 
        if ftype == TType.I64:
17852 
          self.orderId = iprot.readI64();
17853 
        else:
17854 
          iprot.skip(ftype)
17855 
      elif fid == 2:
17856 
        if ftype == TType.BOOL:
17857 
          self.isValid = iprot.readBool();
17858 
        else:
17859 
          iprot.skip(ftype)
17860 
      else:
17861 
        iprot.skip(ftype)
17862 
      iprot.readFieldEnd()
17863 
    iprot.readStructEnd()
17864 
 
17865 
  def write(self, oprot):
17866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17868 
      return
17869 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17870 
    if self.orderId is not None:
2591 chandransh 17871 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17872 
      oprot.writeI64(self.orderId)
17873 
      oprot.writeFieldEnd()
3431 rajveer 17874 
    if self.isValid is not None:
2591 chandransh 17875 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17876 
      oprot.writeBool(self.isValid)
17877 
      oprot.writeFieldEnd()
17878 
    oprot.writeFieldStop()
17879 
    oprot.writeStructEnd()
17880 
 
3431 rajveer 17881 
  def validate(self):
17882 
    return
17883 
 
17884 
 
2591 chandransh 17885 
  def __repr__(self):
17886 
    L = ['%s=%r' % (key, value)
17887 
      for key, value in self.__dict__.iteritems()]
17888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17889 
 
17890 
  def __eq__(self, other):
17891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17892 
 
17893 
  def __ne__(self, other):
17894 
    return not (self == other)
17895 
 
17896 
class validateDoa_result:
17897 
  """
17898 
  Attributes:
17899 
   - success
17900 
   - ex
17901 
  """
17902 
 
17903 
  thrift_spec = (
17904 
    (0, TType.BOOL, 'success', None, None, ), # 0
17905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17906 
  )
17907 
 
17908 
  def __init__(self, success=None, ex=None,):
17909 
    self.success = success
17910 
    self.ex = ex
17911 
 
17912 
  def read(self, iprot):
17913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17915 
      return
17916 
    iprot.readStructBegin()
17917 
    while True:
17918 
      (fname, ftype, fid) = iprot.readFieldBegin()
17919 
      if ftype == TType.STOP:
17920 
        break
17921 
      if fid == 0:
17922 
        if ftype == TType.BOOL:
17923 
          self.success = iprot.readBool();
17924 
        else:
17925 
          iprot.skip(ftype)
17926 
      elif fid == 1:
17927 
        if ftype == TType.STRUCT:
17928 
          self.ex = TransactionServiceException()
17929 
          self.ex.read(iprot)
17930 
        else:
17931 
          iprot.skip(ftype)
17932 
      else:
17933 
        iprot.skip(ftype)
17934 
      iprot.readFieldEnd()
17935 
    iprot.readStructEnd()
17936 
 
17937 
  def write(self, oprot):
17938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17940 
      return
17941 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17942 
    if self.success is not None:
2591 chandransh 17943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17944 
      oprot.writeBool(self.success)
17945 
      oprot.writeFieldEnd()
3431 rajveer 17946 
    if self.ex is not None:
2591 chandransh 17947 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17948 
      self.ex.write(oprot)
17949 
      oprot.writeFieldEnd()
17950 
    oprot.writeFieldStop()
17951 
    oprot.writeStructEnd()
17952 
 
3431 rajveer 17953 
  def validate(self):
17954 
    return
17955 
 
17956 
 
2591 chandransh 17957 
  def __repr__(self):
17958 
    L = ['%s=%r' % (key, value)
17959 
      for key, value in self.__dict__.iteritems()]
17960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17961 
 
17962 
  def __eq__(self, other):
17963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17964 
 
17965 
  def __ne__(self, other):
17966 
    return not (self == other)
17967 
 
4495 rajveer 17968 
class validateReturnProduct_args:
17969 
  """
17970 
  Attributes:
17971 
   - orderId
17972 
   - isUsable
17973 
  """
17974 
 
17975 
  thrift_spec = (
17976 
    None, # 0
17977 
    (1, TType.I64, 'orderId', None, None, ), # 1
17978 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17979 
  )
17980 
 
17981 
  def __init__(self, orderId=None, isUsable=None,):
17982 
    self.orderId = orderId
17983 
    self.isUsable = isUsable
17984 
 
17985 
  def read(self, iprot):
17986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17988 
      return
17989 
    iprot.readStructBegin()
17990 
    while True:
17991 
      (fname, ftype, fid) = iprot.readFieldBegin()
17992 
      if ftype == TType.STOP:
17993 
        break
17994 
      if fid == 1:
17995 
        if ftype == TType.I64:
17996 
          self.orderId = iprot.readI64();
17997 
        else:
17998 
          iprot.skip(ftype)
17999 
      elif fid == 2:
18000 
        if ftype == TType.BOOL:
18001 
          self.isUsable = iprot.readBool();
18002 
        else:
18003 
          iprot.skip(ftype)
18004 
      else:
18005 
        iprot.skip(ftype)
18006 
      iprot.readFieldEnd()
18007 
    iprot.readStructEnd()
18008 
 
18009 
  def write(self, oprot):
18010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18012 
      return
18013 
    oprot.writeStructBegin('validateReturnProduct_args')
18014 
    if self.orderId is not None:
18015 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18016 
      oprot.writeI64(self.orderId)
18017 
      oprot.writeFieldEnd()
18018 
    if self.isUsable is not None:
18019 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18020 
      oprot.writeBool(self.isUsable)
18021 
      oprot.writeFieldEnd()
18022 
    oprot.writeFieldStop()
18023 
    oprot.writeStructEnd()
18024 
 
18025 
  def validate(self):
18026 
    return
18027 
 
18028 
 
18029 
  def __repr__(self):
18030 
    L = ['%s=%r' % (key, value)
18031 
      for key, value in self.__dict__.iteritems()]
18032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18033 
 
18034 
  def __eq__(self, other):
18035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18036 
 
18037 
  def __ne__(self, other):
18038 
    return not (self == other)
18039 
 
18040 
class validateReturnProduct_result:
18041 
  """
18042 
  Attributes:
18043 
   - success
18044 
   - ex
18045 
  """
18046 
 
18047 
  thrift_spec = (
18048 
    (0, TType.BOOL, 'success', None, None, ), # 0
18049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18050 
  )
18051 
 
18052 
  def __init__(self, success=None, ex=None,):
18053 
    self.success = success
18054 
    self.ex = ex
18055 
 
18056 
  def read(self, iprot):
18057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18059 
      return
18060 
    iprot.readStructBegin()
18061 
    while True:
18062 
      (fname, ftype, fid) = iprot.readFieldBegin()
18063 
      if ftype == TType.STOP:
18064 
        break
18065 
      if fid == 0:
18066 
        if ftype == TType.BOOL:
18067 
          self.success = iprot.readBool();
18068 
        else:
18069 
          iprot.skip(ftype)
18070 
      elif fid == 1:
18071 
        if ftype == TType.STRUCT:
18072 
          self.ex = TransactionServiceException()
18073 
          self.ex.read(iprot)
18074 
        else:
18075 
          iprot.skip(ftype)
18076 
      else:
18077 
        iprot.skip(ftype)
18078 
      iprot.readFieldEnd()
18079 
    iprot.readStructEnd()
18080 
 
18081 
  def write(self, oprot):
18082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18084 
      return
18085 
    oprot.writeStructBegin('validateReturnProduct_result')
18086 
    if self.success is not None:
18087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18088 
      oprot.writeBool(self.success)
18089 
      oprot.writeFieldEnd()
18090 
    if self.ex is not None:
18091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18092 
      self.ex.write(oprot)
18093 
      oprot.writeFieldEnd()
18094 
    oprot.writeFieldStop()
18095 
    oprot.writeStructEnd()
18096 
 
18097 
  def validate(self):
18098 
    return
18099 
 
18100 
 
18101 
  def __repr__(self):
18102 
    L = ['%s=%r' % (key, value)
18103 
      for key, value in self.__dict__.iteritems()]
18104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18105 
 
18106 
  def __eq__(self, other):
18107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18108 
 
18109 
  def __ne__(self, other):
18110 
    return not (self == other)
18111 
 
2616 chandransh 18112 
class reshipOrder_args:
18113 
  """
18114 
  Attributes:
18115 
   - orderId
18116 
  """
2591 chandransh 18117 
 
2616 chandransh 18118 
  thrift_spec = (
18119 
    None, # 0
18120 
    (1, TType.I64, 'orderId', None, None, ), # 1
18121 
  )
18122 
 
18123 
  def __init__(self, orderId=None,):
18124 
    self.orderId = orderId
18125 
 
18126 
  def read(self, iprot):
18127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18129 
      return
18130 
    iprot.readStructBegin()
18131 
    while True:
18132 
      (fname, ftype, fid) = iprot.readFieldBegin()
18133 
      if ftype == TType.STOP:
18134 
        break
18135 
      if fid == 1:
18136 
        if ftype == TType.I64:
18137 
          self.orderId = iprot.readI64();
18138 
        else:
18139 
          iprot.skip(ftype)
18140 
      else:
18141 
        iprot.skip(ftype)
18142 
      iprot.readFieldEnd()
18143 
    iprot.readStructEnd()
18144 
 
18145 
  def write(self, oprot):
18146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18148 
      return
18149 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18150 
    if self.orderId is not None:
2616 chandransh 18151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18152 
      oprot.writeI64(self.orderId)
18153 
      oprot.writeFieldEnd()
18154 
    oprot.writeFieldStop()
18155 
    oprot.writeStructEnd()
18156 
 
3431 rajveer 18157 
  def validate(self):
18158 
    return
18159 
 
18160 
 
2616 chandransh 18161 
  def __repr__(self):
18162 
    L = ['%s=%r' % (key, value)
18163 
      for key, value in self.__dict__.iteritems()]
18164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18165 
 
18166 
  def __eq__(self, other):
18167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18168 
 
18169 
  def __ne__(self, other):
18170 
    return not (self == other)
18171 
 
18172 
class reshipOrder_result:
18173 
  """
18174 
  Attributes:
18175 
   - success
18176 
   - ex
18177 
  """
18178 
 
18179 
  thrift_spec = (
18180 
    (0, TType.I64, 'success', None, None, ), # 0
18181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18182 
  )
18183 
 
18184 
  def __init__(self, success=None, ex=None,):
18185 
    self.success = success
18186 
    self.ex = ex
18187 
 
18188 
  def read(self, iprot):
18189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18191 
      return
18192 
    iprot.readStructBegin()
18193 
    while True:
18194 
      (fname, ftype, fid) = iprot.readFieldBegin()
18195 
      if ftype == TType.STOP:
18196 
        break
18197 
      if fid == 0:
18198 
        if ftype == TType.I64:
18199 
          self.success = iprot.readI64();
18200 
        else:
18201 
          iprot.skip(ftype)
18202 
      elif fid == 1:
18203 
        if ftype == TType.STRUCT:
18204 
          self.ex = TransactionServiceException()
18205 
          self.ex.read(iprot)
18206 
        else:
18207 
          iprot.skip(ftype)
18208 
      else:
18209 
        iprot.skip(ftype)
18210 
      iprot.readFieldEnd()
18211 
    iprot.readStructEnd()
18212 
 
18213 
  def write(self, oprot):
18214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18216 
      return
18217 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18218 
    if self.success is not None:
2616 chandransh 18219 
      oprot.writeFieldBegin('success', TType.I64, 0)
18220 
      oprot.writeI64(self.success)
18221 
      oprot.writeFieldEnd()
3431 rajveer 18222 
    if self.ex is not None:
2616 chandransh 18223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18224 
      self.ex.write(oprot)
18225 
      oprot.writeFieldEnd()
18226 
    oprot.writeFieldStop()
18227 
    oprot.writeStructEnd()
18228 
 
3431 rajveer 18229 
  def validate(self):
18230 
    return
18231 
 
18232 
 
2616 chandransh 18233 
  def __repr__(self):
18234 
    L = ['%s=%r' % (key, value)
18235 
      for key, value in self.__dict__.iteritems()]
18236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18237 
 
18238 
  def __eq__(self, other):
18239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18240 
 
18241 
  def __ne__(self, other):
18242 
    return not (self == other)
18243 
 
18244 
class refundOrder_args:
18245 
  """
18246 
  Attributes:
18247 
   - orderId
3226 chandransh 18248 
   - refundedBy
18249 
   - reason
2616 chandransh 18250 
  """
18251 
 
18252 
  thrift_spec = (
18253 
    None, # 0
18254 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18255 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18256 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18257 
  )
18258 
 
3226 chandransh 18259 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18260 
    self.orderId = orderId
3226 chandransh 18261 
    self.refundedBy = refundedBy
18262 
    self.reason = reason
2616 chandransh 18263 
 
18264 
  def read(self, iprot):
18265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18267 
      return
18268 
    iprot.readStructBegin()
18269 
    while True:
18270 
      (fname, ftype, fid) = iprot.readFieldBegin()
18271 
      if ftype == TType.STOP:
18272 
        break
18273 
      if fid == 1:
18274 
        if ftype == TType.I64:
18275 
          self.orderId = iprot.readI64();
18276 
        else:
18277 
          iprot.skip(ftype)
3226 chandransh 18278 
      elif fid == 2:
18279 
        if ftype == TType.STRING:
18280 
          self.refundedBy = iprot.readString();
18281 
        else:
18282 
          iprot.skip(ftype)
18283 
      elif fid == 3:
18284 
        if ftype == TType.STRING:
18285 
          self.reason = iprot.readString();
18286 
        else:
18287 
          iprot.skip(ftype)
2616 chandransh 18288 
      else:
18289 
        iprot.skip(ftype)
18290 
      iprot.readFieldEnd()
18291 
    iprot.readStructEnd()
18292 
 
18293 
  def write(self, oprot):
18294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18296 
      return
18297 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18298 
    if self.orderId is not None:
2616 chandransh 18299 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18300 
      oprot.writeI64(self.orderId)
18301 
      oprot.writeFieldEnd()
3431 rajveer 18302 
    if self.refundedBy is not None:
3226 chandransh 18303 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18304 
      oprot.writeString(self.refundedBy)
18305 
      oprot.writeFieldEnd()
3431 rajveer 18306 
    if self.reason is not None:
3226 chandransh 18307 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18308 
      oprot.writeString(self.reason)
18309 
      oprot.writeFieldEnd()
2616 chandransh 18310 
    oprot.writeFieldStop()
18311 
    oprot.writeStructEnd()
18312 
 
3431 rajveer 18313 
  def validate(self):
18314 
    return
18315 
 
18316 
 
2616 chandransh 18317 
  def __repr__(self):
18318 
    L = ['%s=%r' % (key, value)
18319 
      for key, value in self.__dict__.iteritems()]
18320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18321 
 
18322 
  def __eq__(self, other):
18323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18324 
 
18325 
  def __ne__(self, other):
18326 
    return not (self == other)
18327 
 
18328 
class refundOrder_result:
18329 
  """
18330 
  Attributes:
18331 
   - success
18332 
   - ex
18333 
  """
18334 
 
18335 
  thrift_spec = (
18336 
    (0, TType.BOOL, 'success', None, None, ), # 0
18337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18338 
  )
18339 
 
18340 
  def __init__(self, success=None, ex=None,):
18341 
    self.success = success
18342 
    self.ex = ex
18343 
 
18344 
  def read(self, iprot):
18345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18347 
      return
18348 
    iprot.readStructBegin()
18349 
    while True:
18350 
      (fname, ftype, fid) = iprot.readFieldBegin()
18351 
      if ftype == TType.STOP:
18352 
        break
18353 
      if fid == 0:
18354 
        if ftype == TType.BOOL:
18355 
          self.success = iprot.readBool();
18356 
        else:
18357 
          iprot.skip(ftype)
18358 
      elif fid == 1:
18359 
        if ftype == TType.STRUCT:
18360 
          self.ex = TransactionServiceException()
18361 
          self.ex.read(iprot)
18362 
        else:
18363 
          iprot.skip(ftype)
18364 
      else:
18365 
        iprot.skip(ftype)
18366 
      iprot.readFieldEnd()
18367 
    iprot.readStructEnd()
18368 
 
18369 
  def write(self, oprot):
18370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18372 
      return
18373 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18374 
    if self.success is not None:
2616 chandransh 18375 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18376 
      oprot.writeBool(self.success)
18377 
      oprot.writeFieldEnd()
3431 rajveer 18378 
    if self.ex is not None:
2616 chandransh 18379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18380 
      self.ex.write(oprot)
18381 
      oprot.writeFieldEnd()
18382 
    oprot.writeFieldStop()
18383 
    oprot.writeStructEnd()
18384 
 
3431 rajveer 18385 
  def validate(self):
18386 
    return
18387 
 
18388 
 
2616 chandransh 18389 
  def __repr__(self):
18390 
    L = ['%s=%r' % (key, value)
18391 
      for key, value in self.__dict__.iteritems()]
18392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18393 
 
18394 
  def __eq__(self, other):
18395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18396 
 
18397 
  def __ne__(self, other):
18398 
    return not (self == other)
18399 
 
2690 chandransh 18400 
class getReturnOrders_args:
18401 
  """
18402 
  Attributes:
18403 
   - warehouseId
18404 
   - fromDate
18405 
   - toDate
18406 
  """
2616 chandransh 18407 
 
2690 chandransh 18408 
  thrift_spec = (
18409 
    None, # 0
18410 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18411 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18412 
    (3, TType.I64, 'toDate', None, None, ), # 3
18413 
  )
18414 
 
18415 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18416 
    self.warehouseId = warehouseId
18417 
    self.fromDate = fromDate
18418 
    self.toDate = toDate
18419 
 
18420 
  def read(self, iprot):
18421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18423 
      return
18424 
    iprot.readStructBegin()
18425 
    while True:
18426 
      (fname, ftype, fid) = iprot.readFieldBegin()
18427 
      if ftype == TType.STOP:
18428 
        break
18429 
      if fid == 1:
18430 
        if ftype == TType.I64:
18431 
          self.warehouseId = iprot.readI64();
18432 
        else:
18433 
          iprot.skip(ftype)
18434 
      elif fid == 2:
18435 
        if ftype == TType.I64:
18436 
          self.fromDate = iprot.readI64();
18437 
        else:
18438 
          iprot.skip(ftype)
18439 
      elif fid == 3:
18440 
        if ftype == TType.I64:
18441 
          self.toDate = iprot.readI64();
18442 
        else:
18443 
          iprot.skip(ftype)
18444 
      else:
18445 
        iprot.skip(ftype)
18446 
      iprot.readFieldEnd()
18447 
    iprot.readStructEnd()
18448 
 
18449 
  def write(self, oprot):
18450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18452 
      return
18453 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18454 
    if self.warehouseId is not None:
2690 chandransh 18455 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18456 
      oprot.writeI64(self.warehouseId)
18457 
      oprot.writeFieldEnd()
3431 rajveer 18458 
    if self.fromDate is not None:
2690 chandransh 18459 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18460 
      oprot.writeI64(self.fromDate)
18461 
      oprot.writeFieldEnd()
3431 rajveer 18462 
    if self.toDate is not None:
2690 chandransh 18463 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18464 
      oprot.writeI64(self.toDate)
18465 
      oprot.writeFieldEnd()
18466 
    oprot.writeFieldStop()
18467 
    oprot.writeStructEnd()
18468 
 
3431 rajveer 18469 
  def validate(self):
18470 
    return
18471 
 
18472 
 
2690 chandransh 18473 
  def __repr__(self):
18474 
    L = ['%s=%r' % (key, value)
18475 
      for key, value in self.__dict__.iteritems()]
18476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18477 
 
18478 
  def __eq__(self, other):
18479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18480 
 
18481 
  def __ne__(self, other):
18482 
    return not (self == other)
18483 
 
18484 
class getReturnOrders_result:
18485 
  """
18486 
  Attributes:
18487 
   - success
18488 
  """
18489 
 
18490 
  thrift_spec = (
18491 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18492 
  )
18493 
 
18494 
  def __init__(self, success=None,):
18495 
    self.success = success
18496 
 
18497 
  def read(self, iprot):
18498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18500 
      return
18501 
    iprot.readStructBegin()
18502 
    while True:
18503 
      (fname, ftype, fid) = iprot.readFieldBegin()
18504 
      if ftype == TType.STOP:
18505 
        break
18506 
      if fid == 0:
18507 
        if ftype == TType.LIST:
18508 
          self.success = []
6188 rajveer 18509 
          (_etype442, _size439) = iprot.readListBegin()
18510 
          for _i443 in xrange(_size439):
18511 
            _elem444 = ReturnOrder()
18512 
            _elem444.read(iprot)
18513 
            self.success.append(_elem444)
2690 chandransh 18514 
          iprot.readListEnd()
18515 
        else:
18516 
          iprot.skip(ftype)
18517 
      else:
18518 
        iprot.skip(ftype)
18519 
      iprot.readFieldEnd()
18520 
    iprot.readStructEnd()
18521 
 
18522 
  def write(self, oprot):
18523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18525 
      return
18526 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18527 
    if self.success is not None:
2690 chandransh 18528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18529 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18530 
      for iter445 in self.success:
18531 
        iter445.write(oprot)
2690 chandransh 18532 
      oprot.writeListEnd()
18533 
      oprot.writeFieldEnd()
18534 
    oprot.writeFieldStop()
18535 
    oprot.writeStructEnd()
18536 
 
3431 rajveer 18537 
  def validate(self):
18538 
    return
18539 
 
18540 
 
2690 chandransh 18541 
  def __repr__(self):
18542 
    L = ['%s=%r' % (key, value)
18543 
      for key, value in self.__dict__.iteritems()]
18544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18545 
 
18546 
  def __eq__(self, other):
18547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18548 
 
18549 
  def __ne__(self, other):
18550 
    return not (self == other)
18551 
 
5481 phani.kuma 18552 
class getAllReturnOrders_args:
18553 
  """
18554 
  Attributes:
18555 
   - onlyNotProcessed
18556 
   - fromDate
18557 
   - toDate
18558 
  """
18559 
 
18560 
  thrift_spec = (
18561 
    None, # 0
18562 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18563 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18564 
    (3, TType.I64, 'toDate', None, None, ), # 3
18565 
  )
18566 
 
18567 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18568 
    self.onlyNotProcessed = onlyNotProcessed
18569 
    self.fromDate = fromDate
18570 
    self.toDate = toDate
18571 
 
18572 
  def read(self, iprot):
18573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18575 
      return
18576 
    iprot.readStructBegin()
18577 
    while True:
18578 
      (fname, ftype, fid) = iprot.readFieldBegin()
18579 
      if ftype == TType.STOP:
18580 
        break
18581 
      if fid == 1:
18582 
        if ftype == TType.BOOL:
18583 
          self.onlyNotProcessed = iprot.readBool();
18584 
        else:
18585 
          iprot.skip(ftype)
18586 
      elif fid == 2:
18587 
        if ftype == TType.I64:
18588 
          self.fromDate = iprot.readI64();
18589 
        else:
18590 
          iprot.skip(ftype)
18591 
      elif fid == 3:
18592 
        if ftype == TType.I64:
18593 
          self.toDate = iprot.readI64();
18594 
        else:
18595 
          iprot.skip(ftype)
18596 
      else:
18597 
        iprot.skip(ftype)
18598 
      iprot.readFieldEnd()
18599 
    iprot.readStructEnd()
18600 
 
18601 
  def write(self, oprot):
18602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18604 
      return
18605 
    oprot.writeStructBegin('getAllReturnOrders_args')
18606 
    if self.onlyNotProcessed is not None:
18607 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18608 
      oprot.writeBool(self.onlyNotProcessed)
18609 
      oprot.writeFieldEnd()
18610 
    if self.fromDate is not None:
18611 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18612 
      oprot.writeI64(self.fromDate)
18613 
      oprot.writeFieldEnd()
18614 
    if self.toDate is not None:
18615 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18616 
      oprot.writeI64(self.toDate)
18617 
      oprot.writeFieldEnd()
18618 
    oprot.writeFieldStop()
18619 
    oprot.writeStructEnd()
18620 
 
18621 
  def validate(self):
18622 
    return
18623 
 
18624 
 
18625 
  def __repr__(self):
18626 
    L = ['%s=%r' % (key, value)
18627 
      for key, value in self.__dict__.iteritems()]
18628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18629 
 
18630 
  def __eq__(self, other):
18631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18632 
 
18633 
  def __ne__(self, other):
18634 
    return not (self == other)
18635 
 
18636 
class getAllReturnOrders_result:
18637 
  """
18638 
  Attributes:
18639 
   - success
18640 
  """
18641 
 
18642 
  thrift_spec = (
18643 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18644 
  )
18645 
 
18646 
  def __init__(self, success=None,):
18647 
    self.success = success
18648 
 
18649 
  def read(self, iprot):
18650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18652 
      return
18653 
    iprot.readStructBegin()
18654 
    while True:
18655 
      (fname, ftype, fid) = iprot.readFieldBegin()
18656 
      if ftype == TType.STOP:
18657 
        break
18658 
      if fid == 0:
18659 
        if ftype == TType.LIST:
18660 
          self.success = []
6188 rajveer 18661 
          (_etype449, _size446) = iprot.readListBegin()
18662 
          for _i450 in xrange(_size446):
18663 
            _elem451 = ReturnOrder()
18664 
            _elem451.read(iprot)
18665 
            self.success.append(_elem451)
5481 phani.kuma 18666 
          iprot.readListEnd()
18667 
        else:
18668 
          iprot.skip(ftype)
18669 
      else:
18670 
        iprot.skip(ftype)
18671 
      iprot.readFieldEnd()
18672 
    iprot.readStructEnd()
18673 
 
18674 
  def write(self, oprot):
18675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18677 
      return
18678 
    oprot.writeStructBegin('getAllReturnOrders_result')
18679 
    if self.success is not None:
18680 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18681 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18682 
      for iter452 in self.success:
18683 
        iter452.write(oprot)
5481 phani.kuma 18684 
      oprot.writeListEnd()
18685 
      oprot.writeFieldEnd()
18686 
    oprot.writeFieldStop()
18687 
    oprot.writeStructEnd()
18688 
 
18689 
  def validate(self):
18690 
    return
18691 
 
18692 
 
18693 
  def __repr__(self):
18694 
    L = ['%s=%r' % (key, value)
18695 
      for key, value in self.__dict__.iteritems()]
18696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18697 
 
18698 
  def __eq__(self, other):
18699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18700 
 
18701 
  def __ne__(self, other):
18702 
    return not (self == other)
18703 
 
2700 chandransh 18704 
class getReturnOrder_args:
18705 
  """
18706 
  Attributes:
18707 
   - id
18708 
  """
18709 
 
18710 
  thrift_spec = (
18711 
    None, # 0
18712 
    (1, TType.I64, 'id', None, None, ), # 1
18713 
  )
18714 
 
18715 
  def __init__(self, id=None,):
18716 
    self.id = id
18717 
 
18718 
  def read(self, iprot):
18719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18721 
      return
18722 
    iprot.readStructBegin()
18723 
    while True:
18724 
      (fname, ftype, fid) = iprot.readFieldBegin()
18725 
      if ftype == TType.STOP:
18726 
        break
18727 
      if fid == 1:
18728 
        if ftype == TType.I64:
18729 
          self.id = iprot.readI64();
18730 
        else:
18731 
          iprot.skip(ftype)
18732 
      else:
18733 
        iprot.skip(ftype)
18734 
      iprot.readFieldEnd()
18735 
    iprot.readStructEnd()
18736 
 
18737 
  def write(self, oprot):
18738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18740 
      return
18741 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18742 
    if self.id is not None:
2700 chandransh 18743 
      oprot.writeFieldBegin('id', TType.I64, 1)
18744 
      oprot.writeI64(self.id)
18745 
      oprot.writeFieldEnd()
18746 
    oprot.writeFieldStop()
18747 
    oprot.writeStructEnd()
18748 
 
3431 rajveer 18749 
  def validate(self):
18750 
    return
18751 
 
18752 
 
2700 chandransh 18753 
  def __repr__(self):
18754 
    L = ['%s=%r' % (key, value)
18755 
      for key, value in self.__dict__.iteritems()]
18756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18757 
 
18758 
  def __eq__(self, other):
18759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18760 
 
18761 
  def __ne__(self, other):
18762 
    return not (self == other)
18763 
 
18764 
class getReturnOrder_result:
18765 
  """
18766 
  Attributes:
18767 
   - success
18768 
   - ex
18769 
  """
18770 
 
18771 
  thrift_spec = (
18772 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18774 
  )
18775 
 
18776 
  def __init__(self, success=None, ex=None,):
18777 
    self.success = success
18778 
    self.ex = ex
18779 
 
18780 
  def read(self, iprot):
18781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18783 
      return
18784 
    iprot.readStructBegin()
18785 
    while True:
18786 
      (fname, ftype, fid) = iprot.readFieldBegin()
18787 
      if ftype == TType.STOP:
18788 
        break
18789 
      if fid == 0:
18790 
        if ftype == TType.STRUCT:
18791 
          self.success = ReturnOrder()
18792 
          self.success.read(iprot)
18793 
        else:
18794 
          iprot.skip(ftype)
18795 
      elif fid == 1:
18796 
        if ftype == TType.STRUCT:
18797 
          self.ex = TransactionServiceException()
18798 
          self.ex.read(iprot)
18799 
        else:
18800 
          iprot.skip(ftype)
18801 
      else:
18802 
        iprot.skip(ftype)
18803 
      iprot.readFieldEnd()
18804 
    iprot.readStructEnd()
18805 
 
18806 
  def write(self, oprot):
18807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18809 
      return
18810 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18811 
    if self.success is not None:
2700 chandransh 18812 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18813 
      self.success.write(oprot)
18814 
      oprot.writeFieldEnd()
3431 rajveer 18815 
    if self.ex is not None:
2700 chandransh 18816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18817 
      self.ex.write(oprot)
18818 
      oprot.writeFieldEnd()
18819 
    oprot.writeFieldStop()
18820 
    oprot.writeStructEnd()
18821 
 
3431 rajveer 18822 
  def validate(self):
18823 
    return
18824 
 
18825 
 
2700 chandransh 18826 
  def __repr__(self):
18827 
    L = ['%s=%r' % (key, value)
18828 
      for key, value in self.__dict__.iteritems()]
18829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18830 
 
18831 
  def __eq__(self, other):
18832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18833 
 
18834 
  def __ne__(self, other):
18835 
    return not (self == other)
18836 
 
2690 chandransh 18837 
class processReturn_args:
18838 
  """
18839 
  Attributes:
18840 
   - returnOrderId
18841 
  """
18842 
 
18843 
  thrift_spec = (
18844 
    None, # 0
18845 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18846 
  )
18847 
 
18848 
  def __init__(self, returnOrderId=None,):
18849 
    self.returnOrderId = returnOrderId
18850 
 
18851 
  def read(self, iprot):
18852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18854 
      return
18855 
    iprot.readStructBegin()
18856 
    while True:
18857 
      (fname, ftype, fid) = iprot.readFieldBegin()
18858 
      if ftype == TType.STOP:
18859 
        break
18860 
      if fid == 1:
18861 
        if ftype == TType.I64:
18862 
          self.returnOrderId = iprot.readI64();
18863 
        else:
18864 
          iprot.skip(ftype)
18865 
      else:
18866 
        iprot.skip(ftype)
18867 
      iprot.readFieldEnd()
18868 
    iprot.readStructEnd()
18869 
 
18870 
  def write(self, oprot):
18871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18873 
      return
18874 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18875 
    if self.returnOrderId is not None:
2690 chandransh 18876 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18877 
      oprot.writeI64(self.returnOrderId)
18878 
      oprot.writeFieldEnd()
18879 
    oprot.writeFieldStop()
18880 
    oprot.writeStructEnd()
18881 
 
3431 rajveer 18882 
  def validate(self):
18883 
    return
18884 
 
18885 
 
2690 chandransh 18886 
  def __repr__(self):
18887 
    L = ['%s=%r' % (key, value)
18888 
      for key, value in self.__dict__.iteritems()]
18889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18890 
 
18891 
  def __eq__(self, other):
18892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18893 
 
18894 
  def __ne__(self, other):
18895 
    return not (self == other)
18896 
 
18897 
class processReturn_result:
18898 
  """
18899 
  Attributes:
18900 
   - ex
18901 
  """
18902 
 
18903 
  thrift_spec = (
18904 
    None, # 0
18905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18906 
  )
18907 
 
18908 
  def __init__(self, ex=None,):
18909 
    self.ex = ex
18910 
 
18911 
  def read(self, iprot):
18912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18914 
      return
18915 
    iprot.readStructBegin()
18916 
    while True:
18917 
      (fname, ftype, fid) = iprot.readFieldBegin()
18918 
      if ftype == TType.STOP:
18919 
        break
18920 
      if fid == 1:
18921 
        if ftype == TType.STRUCT:
18922 
          self.ex = TransactionServiceException()
18923 
          self.ex.read(iprot)
18924 
        else:
18925 
          iprot.skip(ftype)
18926 
      else:
18927 
        iprot.skip(ftype)
18928 
      iprot.readFieldEnd()
18929 
    iprot.readStructEnd()
18930 
 
18931 
  def write(self, oprot):
18932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18934 
      return
18935 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18936 
    if self.ex is not None:
2690 chandransh 18937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18938 
      self.ex.write(oprot)
18939 
      oprot.writeFieldEnd()
18940 
    oprot.writeFieldStop()
18941 
    oprot.writeStructEnd()
18942 
 
3431 rajveer 18943 
  def validate(self):
18944 
    return
18945 
 
18946 
 
2690 chandransh 18947 
  def __repr__(self):
18948 
    L = ['%s=%r' % (key, value)
18949 
      for key, value in self.__dict__.iteritems()]
18950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18951 
 
18952 
  def __eq__(self, other):
18953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18954 
 
18955 
  def __ne__(self, other):
18956 
    return not (self == other)
18957 
 
3451 chandransh 18958 
class updateWeight_args:
18959 
  """
18960 
  Attributes:
18961 
   - orderId
18962 
   - weight
18963 
  """
18964 
 
18965 
  thrift_spec = (
18966 
    None, # 0
18967 
    (1, TType.I64, 'orderId', None, None, ), # 1
18968 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18969 
  )
18970 
 
18971 
  def __init__(self, orderId=None, weight=None,):
18972 
    self.orderId = orderId
18973 
    self.weight = weight
18974 
 
18975 
  def read(self, iprot):
18976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18978 
      return
18979 
    iprot.readStructBegin()
18980 
    while True:
18981 
      (fname, ftype, fid) = iprot.readFieldBegin()
18982 
      if ftype == TType.STOP:
18983 
        break
18984 
      if fid == 1:
18985 
        if ftype == TType.I64:
18986 
          self.orderId = iprot.readI64();
18987 
        else:
18988 
          iprot.skip(ftype)
18989 
      elif fid == 2:
18990 
        if ftype == TType.DOUBLE:
18991 
          self.weight = iprot.readDouble();
18992 
        else:
18993 
          iprot.skip(ftype)
18994 
      else:
18995 
        iprot.skip(ftype)
18996 
      iprot.readFieldEnd()
18997 
    iprot.readStructEnd()
18998 
 
18999 
  def write(self, oprot):
19000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19002 
      return
19003 
    oprot.writeStructBegin('updateWeight_args')
19004 
    if self.orderId is not None:
19005 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19006 
      oprot.writeI64(self.orderId)
19007 
      oprot.writeFieldEnd()
19008 
    if self.weight is not None:
19009 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19010 
      oprot.writeDouble(self.weight)
19011 
      oprot.writeFieldEnd()
19012 
    oprot.writeFieldStop()
19013 
    oprot.writeStructEnd()
19014 
 
19015 
  def validate(self):
19016 
    return
19017 
 
19018 
 
19019 
  def __repr__(self):
19020 
    L = ['%s=%r' % (key, value)
19021 
      for key, value in self.__dict__.iteritems()]
19022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19023 
 
19024 
  def __eq__(self, other):
19025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19026 
 
19027 
  def __ne__(self, other):
19028 
    return not (self == other)
19029 
 
19030 
class updateWeight_result:
19031 
  """
19032 
  Attributes:
19033 
   - success
19034 
   - ex
19035 
  """
19036 
 
19037 
  thrift_spec = (
19038 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19040 
  )
19041 
 
19042 
  def __init__(self, success=None, ex=None,):
19043 
    self.success = success
19044 
    self.ex = ex
19045 
 
19046 
  def read(self, iprot):
19047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19049 
      return
19050 
    iprot.readStructBegin()
19051 
    while True:
19052 
      (fname, ftype, fid) = iprot.readFieldBegin()
19053 
      if ftype == TType.STOP:
19054 
        break
19055 
      if fid == 0:
19056 
        if ftype == TType.STRUCT:
19057 
          self.success = Order()
19058 
          self.success.read(iprot)
19059 
        else:
19060 
          iprot.skip(ftype)
19061 
      elif fid == 1:
19062 
        if ftype == TType.STRUCT:
19063 
          self.ex = TransactionServiceException()
19064 
          self.ex.read(iprot)
19065 
        else:
19066 
          iprot.skip(ftype)
19067 
      else:
19068 
        iprot.skip(ftype)
19069 
      iprot.readFieldEnd()
19070 
    iprot.readStructEnd()
19071 
 
19072 
  def write(self, oprot):
19073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19075 
      return
19076 
    oprot.writeStructBegin('updateWeight_result')
19077 
    if self.success is not None:
19078 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19079 
      self.success.write(oprot)
19080 
      oprot.writeFieldEnd()
19081 
    if self.ex is not None:
19082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19083 
      self.ex.write(oprot)
19084 
      oprot.writeFieldEnd()
19085 
    oprot.writeFieldStop()
19086 
    oprot.writeStructEnd()
19087 
 
19088 
  def validate(self):
19089 
    return
19090 
 
19091 
 
19092 
  def __repr__(self):
19093 
    L = ['%s=%r' % (key, value)
19094 
      for key, value in self.__dict__.iteritems()]
19095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19096 
 
19097 
  def __eq__(self, other):
19098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19099 
 
19100 
  def __ne__(self, other):
19101 
    return not (self == other)
3469 chandransh 19102 
 
19103 
class changeItem_args:
19104 
  """
19105 
  Attributes:
19106 
   - orderId
19107 
   - itemId
19108 
  """
19109 
 
19110 
  thrift_spec = (
19111 
    None, # 0
19112 
    (1, TType.I64, 'orderId', None, None, ), # 1
19113 
    (2, TType.I64, 'itemId', None, None, ), # 2
19114 
  )
19115 
 
19116 
  def __init__(self, orderId=None, itemId=None,):
19117 
    self.orderId = orderId
19118 
    self.itemId = itemId
19119 
 
19120 
  def read(self, iprot):
19121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19123 
      return
19124 
    iprot.readStructBegin()
19125 
    while True:
19126 
      (fname, ftype, fid) = iprot.readFieldBegin()
19127 
      if ftype == TType.STOP:
19128 
        break
19129 
      if fid == 1:
19130 
        if ftype == TType.I64:
19131 
          self.orderId = iprot.readI64();
19132 
        else:
19133 
          iprot.skip(ftype)
19134 
      elif fid == 2:
19135 
        if ftype == TType.I64:
19136 
          self.itemId = iprot.readI64();
19137 
        else:
19138 
          iprot.skip(ftype)
19139 
      else:
19140 
        iprot.skip(ftype)
19141 
      iprot.readFieldEnd()
19142 
    iprot.readStructEnd()
19143 
 
19144 
  def write(self, oprot):
19145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19147 
      return
19148 
    oprot.writeStructBegin('changeItem_args')
19149 
    if self.orderId is not None:
19150 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19151 
      oprot.writeI64(self.orderId)
19152 
      oprot.writeFieldEnd()
19153 
    if self.itemId is not None:
19154 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19155 
      oprot.writeI64(self.itemId)
19156 
      oprot.writeFieldEnd()
19157 
    oprot.writeFieldStop()
19158 
    oprot.writeStructEnd()
19159 
 
19160 
  def validate(self):
19161 
    return
19162 
 
19163 
 
19164 
  def __repr__(self):
19165 
    L = ['%s=%r' % (key, value)
19166 
      for key, value in self.__dict__.iteritems()]
19167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19168 
 
19169 
  def __eq__(self, other):
19170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19171 
 
19172 
  def __ne__(self, other):
19173 
    return not (self == other)
19174 
 
19175 
class changeItem_result:
19176 
  """
19177 
  Attributes:
19178 
   - success
19179 
   - ex
19180 
  """
19181 
 
19182 
  thrift_spec = (
19183 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19184 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19185 
  )
19186 
 
19187 
  def __init__(self, success=None, ex=None,):
19188 
    self.success = success
19189 
    self.ex = ex
19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 0:
19201 
        if ftype == TType.STRUCT:
19202 
          self.success = Order()
19203 
          self.success.read(iprot)
19204 
        else:
19205 
          iprot.skip(ftype)
19206 
      elif fid == 1:
19207 
        if ftype == TType.STRUCT:
19208 
          self.ex = TransactionServiceException()
19209 
          self.ex.read(iprot)
19210 
        else:
19211 
          iprot.skip(ftype)
19212 
      else:
19213 
        iprot.skip(ftype)
19214 
      iprot.readFieldEnd()
19215 
    iprot.readStructEnd()
19216 
 
19217 
  def write(self, oprot):
19218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19220 
      return
19221 
    oprot.writeStructBegin('changeItem_result')
19222 
    if self.success is not None:
19223 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19224 
      self.success.write(oprot)
19225 
      oprot.writeFieldEnd()
19226 
    if self.ex is not None:
19227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19228 
      self.ex.write(oprot)
19229 
      oprot.writeFieldEnd()
19230 
    oprot.writeFieldStop()
19231 
    oprot.writeStructEnd()
19232 
 
19233 
  def validate(self):
19234 
    return
19235 
 
19236 
 
19237 
  def __repr__(self):
19238 
    L = ['%s=%r' % (key, value)
19239 
      for key, value in self.__dict__.iteritems()]
19240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19241 
 
19242 
  def __eq__(self, other):
19243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19244 
 
19245 
  def __ne__(self, other):
19246 
    return not (self == other)
19247 
 
19248 
class shiftToWarehouse_args:
19249 
  """
19250 
  Attributes:
19251 
   - orderId
19252 
   - warehouseId
19253 
  """
19254 
 
19255 
  thrift_spec = (
19256 
    None, # 0
19257 
    (1, TType.I64, 'orderId', None, None, ), # 1
19258 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19259 
  )
19260 
 
19261 
  def __init__(self, orderId=None, warehouseId=None,):
19262 
    self.orderId = orderId
19263 
    self.warehouseId = warehouseId
19264 
 
19265 
  def read(self, iprot):
19266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19268 
      return
19269 
    iprot.readStructBegin()
19270 
    while True:
19271 
      (fname, ftype, fid) = iprot.readFieldBegin()
19272 
      if ftype == TType.STOP:
19273 
        break
19274 
      if fid == 1:
19275 
        if ftype == TType.I64:
19276 
          self.orderId = iprot.readI64();
19277 
        else:
19278 
          iprot.skip(ftype)
19279 
      elif fid == 2:
19280 
        if ftype == TType.I64:
19281 
          self.warehouseId = iprot.readI64();
19282 
        else:
19283 
          iprot.skip(ftype)
19284 
      else:
19285 
        iprot.skip(ftype)
19286 
      iprot.readFieldEnd()
19287 
    iprot.readStructEnd()
19288 
 
19289 
  def write(self, oprot):
19290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19292 
      return
19293 
    oprot.writeStructBegin('shiftToWarehouse_args')
19294 
    if self.orderId is not None:
19295 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19296 
      oprot.writeI64(self.orderId)
19297 
      oprot.writeFieldEnd()
19298 
    if self.warehouseId is not None:
19299 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19300 
      oprot.writeI64(self.warehouseId)
19301 
      oprot.writeFieldEnd()
19302 
    oprot.writeFieldStop()
19303 
    oprot.writeStructEnd()
19304 
 
19305 
  def validate(self):
19306 
    return
19307 
 
19308 
 
19309 
  def __repr__(self):
19310 
    L = ['%s=%r' % (key, value)
19311 
      for key, value in self.__dict__.iteritems()]
19312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19313 
 
19314 
  def __eq__(self, other):
19315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19316 
 
19317 
  def __ne__(self, other):
19318 
    return not (self == other)
19319 
 
19320 
class shiftToWarehouse_result:
19321 
  """
19322 
  Attributes:
19323 
   - success
19324 
   - ex
19325 
  """
19326 
 
19327 
  thrift_spec = (
19328 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19330 
  )
19331 
 
19332 
  def __init__(self, success=None, ex=None,):
19333 
    self.success = success
19334 
    self.ex = ex
19335 
 
19336 
  def read(self, iprot):
19337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19339 
      return
19340 
    iprot.readStructBegin()
19341 
    while True:
19342 
      (fname, ftype, fid) = iprot.readFieldBegin()
19343 
      if ftype == TType.STOP:
19344 
        break
19345 
      if fid == 0:
19346 
        if ftype == TType.STRUCT:
19347 
          self.success = Order()
19348 
          self.success.read(iprot)
19349 
        else:
19350 
          iprot.skip(ftype)
19351 
      elif fid == 1:
19352 
        if ftype == TType.STRUCT:
19353 
          self.ex = TransactionServiceException()
19354 
          self.ex.read(iprot)
19355 
        else:
19356 
          iprot.skip(ftype)
19357 
      else:
19358 
        iprot.skip(ftype)
19359 
      iprot.readFieldEnd()
19360 
    iprot.readStructEnd()
19361 
 
19362 
  def write(self, oprot):
19363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19365 
      return
19366 
    oprot.writeStructBegin('shiftToWarehouse_result')
19367 
    if self.success is not None:
19368 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19369 
      self.success.write(oprot)
19370 
      oprot.writeFieldEnd()
19371 
    if self.ex is not None:
19372 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19373 
      self.ex.write(oprot)
19374 
      oprot.writeFieldEnd()
19375 
    oprot.writeFieldStop()
19376 
    oprot.writeStructEnd()
19377 
 
19378 
  def validate(self):
19379 
    return
19380 
 
19381 
 
19382 
  def __repr__(self):
19383 
    L = ['%s=%r' % (key, value)
19384 
      for key, value in self.__dict__.iteritems()]
19385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19386 
 
19387 
  def __eq__(self, other):
19388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19389 
 
19390 
  def __ne__(self, other):
19391 
    return not (self == other)
3553 chandransh 19392 
 
19393 
class addDelayReason_args:
19394 
  """
19395 
  Attributes:
19396 
   - orderId
19397 
   - delayReason
3986 chandransh 19398 
   - furtherDelay
4647 rajveer 19399 
   - delayReasonText
3553 chandransh 19400 
  """
19401 
 
19402 
  thrift_spec = (
19403 
    None, # 0
19404 
    (1, TType.I64, 'orderId', None, None, ), # 1
19405 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19406 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19407 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19408 
  )
19409 
 
4647 rajveer 19410 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19411 
    self.orderId = orderId
19412 
    self.delayReason = delayReason
3986 chandransh 19413 
    self.furtherDelay = furtherDelay
4647 rajveer 19414 
    self.delayReasonText = delayReasonText
3553 chandransh 19415 
 
19416 
  def read(self, iprot):
19417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19419 
      return
19420 
    iprot.readStructBegin()
19421 
    while True:
19422 
      (fname, ftype, fid) = iprot.readFieldBegin()
19423 
      if ftype == TType.STOP:
19424 
        break
19425 
      if fid == 1:
19426 
        if ftype == TType.I64:
19427 
          self.orderId = iprot.readI64();
19428 
        else:
19429 
          iprot.skip(ftype)
19430 
      elif fid == 2:
19431 
        if ftype == TType.I32:
19432 
          self.delayReason = iprot.readI32();
19433 
        else:
19434 
          iprot.skip(ftype)
3986 chandransh 19435 
      elif fid == 3:
19436 
        if ftype == TType.I64:
19437 
          self.furtherDelay = iprot.readI64();
19438 
        else:
19439 
          iprot.skip(ftype)
4647 rajveer 19440 
      elif fid == 4:
19441 
        if ftype == TType.STRING:
19442 
          self.delayReasonText = iprot.readString();
19443 
        else:
19444 
          iprot.skip(ftype)
3553 chandransh 19445 
      else:
19446 
        iprot.skip(ftype)
19447 
      iprot.readFieldEnd()
19448 
    iprot.readStructEnd()
19449 
 
19450 
  def write(self, oprot):
19451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19453 
      return
19454 
    oprot.writeStructBegin('addDelayReason_args')
19455 
    if self.orderId is not None:
19456 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19457 
      oprot.writeI64(self.orderId)
19458 
      oprot.writeFieldEnd()
19459 
    if self.delayReason is not None:
19460 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19461 
      oprot.writeI32(self.delayReason)
19462 
      oprot.writeFieldEnd()
3986 chandransh 19463 
    if self.furtherDelay is not None:
19464 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19465 
      oprot.writeI64(self.furtherDelay)
19466 
      oprot.writeFieldEnd()
4647 rajveer 19467 
    if self.delayReasonText is not None:
19468 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19469 
      oprot.writeString(self.delayReasonText)
19470 
      oprot.writeFieldEnd()
3553 chandransh 19471 
    oprot.writeFieldStop()
19472 
    oprot.writeStructEnd()
19473 
 
19474 
  def validate(self):
19475 
    return
19476 
 
19477 
 
19478 
  def __repr__(self):
19479 
    L = ['%s=%r' % (key, value)
19480 
      for key, value in self.__dict__.iteritems()]
19481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19482 
 
19483 
  def __eq__(self, other):
19484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19485 
 
19486 
  def __ne__(self, other):
19487 
    return not (self == other)
19488 
 
19489 
class addDelayReason_result:
19490 
  """
19491 
  Attributes:
19492 
   - success
19493 
   - ex
19494 
  """
19495 
 
19496 
  thrift_spec = (
19497 
    (0, TType.BOOL, 'success', None, None, ), # 0
19498 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19499 
  )
19500 
 
19501 
  def __init__(self, success=None, ex=None,):
19502 
    self.success = success
19503 
    self.ex = ex
19504 
 
19505 
  def read(self, iprot):
19506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19508 
      return
19509 
    iprot.readStructBegin()
19510 
    while True:
19511 
      (fname, ftype, fid) = iprot.readFieldBegin()
19512 
      if ftype == TType.STOP:
19513 
        break
19514 
      if fid == 0:
19515 
        if ftype == TType.BOOL:
19516 
          self.success = iprot.readBool();
19517 
        else:
19518 
          iprot.skip(ftype)
19519 
      elif fid == 1:
19520 
        if ftype == TType.STRUCT:
19521 
          self.ex = TransactionServiceException()
19522 
          self.ex.read(iprot)
19523 
        else:
19524 
          iprot.skip(ftype)
19525 
      else:
19526 
        iprot.skip(ftype)
19527 
      iprot.readFieldEnd()
19528 
    iprot.readStructEnd()
19529 
 
19530 
  def write(self, oprot):
19531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19533 
      return
19534 
    oprot.writeStructBegin('addDelayReason_result')
19535 
    if self.success is not None:
19536 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19537 
      oprot.writeBool(self.success)
19538 
      oprot.writeFieldEnd()
19539 
    if self.ex is not None:
19540 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19541 
      self.ex.write(oprot)
19542 
      oprot.writeFieldEnd()
19543 
    oprot.writeFieldStop()
19544 
    oprot.writeStructEnd()
19545 
 
19546 
  def validate(self):
19547 
    return
19548 
 
19549 
 
19550 
  def __repr__(self):
19551 
    L = ['%s=%r' % (key, value)
19552 
      for key, value in self.__dict__.iteritems()]
19553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19554 
 
19555 
  def __eq__(self, other):
19556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19557 
 
19558 
  def __ne__(self, other):
19559 
    return not (self == other)
3956 chandransh 19560 
 
19561 
class reconcileCodCollection_args:
19562 
  """
19563 
  Attributes:
19564 
   - collectedAmountMap
19565 
   - xferBy
19566 
   - xferTxnId
19567 
   - xferDate
19568 
  """
19569 
 
19570 
  thrift_spec = (
19571 
    None, # 0
19572 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19573 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19574 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19575 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19576 
  )
19577 
 
19578 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19579 
    self.collectedAmountMap = collectedAmountMap
19580 
    self.xferBy = xferBy
19581 
    self.xferTxnId = xferTxnId
19582 
    self.xferDate = xferDate
19583 
 
19584 
  def read(self, iprot):
19585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19587 
      return
19588 
    iprot.readStructBegin()
19589 
    while True:
19590 
      (fname, ftype, fid) = iprot.readFieldBegin()
19591 
      if ftype == TType.STOP:
19592 
        break
19593 
      if fid == 1:
19594 
        if ftype == TType.MAP:
19595 
          self.collectedAmountMap = {}
6188 rajveer 19596 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19597 
          for _i457 in xrange(_size453):
19598 
            _key458 = iprot.readString();
19599 
            _val459 = iprot.readDouble();
19600 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19601 
          iprot.readMapEnd()
19602 
        else:
19603 
          iprot.skip(ftype)
19604 
      elif fid == 2:
19605 
        if ftype == TType.STRING:
19606 
          self.xferBy = iprot.readString();
19607 
        else:
19608 
          iprot.skip(ftype)
19609 
      elif fid == 3:
19610 
        if ftype == TType.STRING:
19611 
          self.xferTxnId = iprot.readString();
19612 
        else:
19613 
          iprot.skip(ftype)
19614 
      elif fid == 4:
19615 
        if ftype == TType.I64:
19616 
          self.xferDate = iprot.readI64();
19617 
        else:
19618 
          iprot.skip(ftype)
19619 
      else:
19620 
        iprot.skip(ftype)
19621 
      iprot.readFieldEnd()
19622 
    iprot.readStructEnd()
19623 
 
19624 
  def write(self, oprot):
19625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19627 
      return
19628 
    oprot.writeStructBegin('reconcileCodCollection_args')
19629 
    if self.collectedAmountMap is not None:
19630 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19631 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19632 
      for kiter460,viter461 in self.collectedAmountMap.items():
19633 
        oprot.writeString(kiter460)
19634 
        oprot.writeDouble(viter461)
3956 chandransh 19635 
      oprot.writeMapEnd()
19636 
      oprot.writeFieldEnd()
19637 
    if self.xferBy is not None:
19638 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19639 
      oprot.writeString(self.xferBy)
19640 
      oprot.writeFieldEnd()
19641 
    if self.xferTxnId is not None:
19642 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19643 
      oprot.writeString(self.xferTxnId)
19644 
      oprot.writeFieldEnd()
19645 
    if self.xferDate is not None:
19646 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19647 
      oprot.writeI64(self.xferDate)
19648 
      oprot.writeFieldEnd()
19649 
    oprot.writeFieldStop()
19650 
    oprot.writeStructEnd()
19651 
 
19652 
  def validate(self):
19653 
    return
19654 
 
19655 
 
19656 
  def __repr__(self):
19657 
    L = ['%s=%r' % (key, value)
19658 
      for key, value in self.__dict__.iteritems()]
19659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19660 
 
19661 
  def __eq__(self, other):
19662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19663 
 
19664 
  def __ne__(self, other):
19665 
    return not (self == other)
19666 
 
19667 
class reconcileCodCollection_result:
19668 
  """
19669 
  Attributes:
19670 
   - success
19671 
   - ex
19672 
  """
19673 
 
19674 
  thrift_spec = (
19675 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19676 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19677 
  )
19678 
 
19679 
  def __init__(self, success=None, ex=None,):
19680 
    self.success = success
19681 
    self.ex = ex
19682 
 
19683 
  def read(self, iprot):
19684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19686 
      return
19687 
    iprot.readStructBegin()
19688 
    while True:
19689 
      (fname, ftype, fid) = iprot.readFieldBegin()
19690 
      if ftype == TType.STOP:
19691 
        break
19692 
      if fid == 0:
19693 
        if ftype == TType.MAP:
19694 
          self.success = {}
6188 rajveer 19695 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19696 
          for _i466 in xrange(_size462):
19697 
            _key467 = iprot.readString();
19698 
            _val468 = iprot.readString();
19699 
            self.success[_key467] = _val468
3956 chandransh 19700 
          iprot.readMapEnd()
19701 
        else:
19702 
          iprot.skip(ftype)
19703 
      elif fid == 1:
19704 
        if ftype == TType.STRUCT:
19705 
          self.ex = TransactionServiceException()
19706 
          self.ex.read(iprot)
19707 
        else:
19708 
          iprot.skip(ftype)
19709 
      else:
19710 
        iprot.skip(ftype)
19711 
      iprot.readFieldEnd()
19712 
    iprot.readStructEnd()
19713 
 
19714 
  def write(self, oprot):
19715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19717 
      return
19718 
    oprot.writeStructBegin('reconcileCodCollection_result')
19719 
    if self.success is not None:
19720 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19721 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19722 
      for kiter469,viter470 in self.success.items():
19723 
        oprot.writeString(kiter469)
19724 
        oprot.writeString(viter470)
3956 chandransh 19725 
      oprot.writeMapEnd()
19726 
      oprot.writeFieldEnd()
19727 
    if self.ex is not None:
19728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19729 
      self.ex.write(oprot)
19730 
      oprot.writeFieldEnd()
19731 
    oprot.writeFieldStop()
19732 
    oprot.writeStructEnd()
19733 
 
19734 
  def validate(self):
19735 
    return
19736 
 
19737 
 
19738 
  def __repr__(self):
19739 
    L = ['%s=%r' % (key, value)
19740 
      for key, value in self.__dict__.iteritems()]
19741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19742 
 
19743 
  def __eq__(self, other):
19744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19745 
 
19746 
  def __ne__(self, other):
19747 
    return not (self == other)
4008 mandeep.dh 19748 
 
19749 
class getTransactionsRequiringExtraProcessing_args:
19750 
  """
19751 
  Attributes:
19752 
   - category
19753 
  """
19754 
 
19755 
  thrift_spec = (
19756 
    None, # 0
19757 
    (1, TType.I32, 'category', None, None, ), # 1
19758 
  )
19759 
 
19760 
  def __init__(self, category=None,):
19761 
    self.category = category
19762 
 
19763 
  def read(self, iprot):
19764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19766 
      return
19767 
    iprot.readStructBegin()
19768 
    while True:
19769 
      (fname, ftype, fid) = iprot.readFieldBegin()
19770 
      if ftype == TType.STOP:
19771 
        break
19772 
      if fid == 1:
19773 
        if ftype == TType.I32:
19774 
          self.category = iprot.readI32();
19775 
        else:
19776 
          iprot.skip(ftype)
19777 
      else:
19778 
        iprot.skip(ftype)
19779 
      iprot.readFieldEnd()
19780 
    iprot.readStructEnd()
19781 
 
19782 
  def write(self, oprot):
19783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19785 
      return
19786 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19787 
    if self.category is not None:
19788 
      oprot.writeFieldBegin('category', TType.I32, 1)
19789 
      oprot.writeI32(self.category)
19790 
      oprot.writeFieldEnd()
19791 
    oprot.writeFieldStop()
19792 
    oprot.writeStructEnd()
19793 
 
19794 
  def validate(self):
19795 
    return
19796 
 
19797 
 
19798 
  def __repr__(self):
19799 
    L = ['%s=%r' % (key, value)
19800 
      for key, value in self.__dict__.iteritems()]
19801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19802 
 
19803 
  def __eq__(self, other):
19804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19805 
 
19806 
  def __ne__(self, other):
19807 
    return not (self == other)
19808 
 
19809 
class getTransactionsRequiringExtraProcessing_result:
19810 
  """
19811 
  Attributes:
19812 
   - success
19813 
  """
19814 
 
19815 
  thrift_spec = (
19816 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19817 
  )
19818 
 
19819 
  def __init__(self, success=None,):
19820 
    self.success = success
19821 
 
19822 
  def read(self, iprot):
19823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19825 
      return
19826 
    iprot.readStructBegin()
19827 
    while True:
19828 
      (fname, ftype, fid) = iprot.readFieldBegin()
19829 
      if ftype == TType.STOP:
19830 
        break
19831 
      if fid == 0:
19832 
        if ftype == TType.LIST:
19833 
          self.success = []
6188 rajveer 19834 
          (_etype474, _size471) = iprot.readListBegin()
19835 
          for _i475 in xrange(_size471):
19836 
            _elem476 = iprot.readI64();
19837 
            self.success.append(_elem476)
4008 mandeep.dh 19838 
          iprot.readListEnd()
19839 
        else:
19840 
          iprot.skip(ftype)
19841 
      else:
19842 
        iprot.skip(ftype)
19843 
      iprot.readFieldEnd()
19844 
    iprot.readStructEnd()
19845 
 
19846 
  def write(self, oprot):
19847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19849 
      return
19850 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19851 
    if self.success is not None:
19852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19853 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19854 
      for iter477 in self.success:
19855 
        oprot.writeI64(iter477)
4008 mandeep.dh 19856 
      oprot.writeListEnd()
19857 
      oprot.writeFieldEnd()
19858 
    oprot.writeFieldStop()
19859 
    oprot.writeStructEnd()
19860 
 
19861 
  def validate(self):
19862 
    return
19863 
 
19864 
 
19865 
  def __repr__(self):
19866 
    L = ['%s=%r' % (key, value)
19867 
      for key, value in self.__dict__.iteritems()]
19868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19869 
 
19870 
  def __eq__(self, other):
19871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19872 
 
19873 
  def __ne__(self, other):
19874 
    return not (self == other)
19875 
 
19876 
class markTransactionAsProcessed_args:
19877 
  """
19878 
  Attributes:
19879 
   - transactionId
19880 
   - category
19881 
  """
19882 
 
19883 
  thrift_spec = (
19884 
    None, # 0
19885 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19886 
    (2, TType.I32, 'category', None, None, ), # 2
19887 
  )
19888 
 
19889 
  def __init__(self, transactionId=None, category=None,):
19890 
    self.transactionId = transactionId
19891 
    self.category = category
19892 
 
19893 
  def read(self, iprot):
19894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19896 
      return
19897 
    iprot.readStructBegin()
19898 
    while True:
19899 
      (fname, ftype, fid) = iprot.readFieldBegin()
19900 
      if ftype == TType.STOP:
19901 
        break
19902 
      if fid == 1:
19903 
        if ftype == TType.I64:
19904 
          self.transactionId = iprot.readI64();
19905 
        else:
19906 
          iprot.skip(ftype)
19907 
      elif fid == 2:
19908 
        if ftype == TType.I32:
19909 
          self.category = iprot.readI32();
19910 
        else:
19911 
          iprot.skip(ftype)
19912 
      else:
19913 
        iprot.skip(ftype)
19914 
      iprot.readFieldEnd()
19915 
    iprot.readStructEnd()
19916 
 
19917 
  def write(self, oprot):
19918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19920 
      return
19921 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19922 
    if self.transactionId is not None:
19923 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19924 
      oprot.writeI64(self.transactionId)
19925 
      oprot.writeFieldEnd()
19926 
    if self.category is not None:
19927 
      oprot.writeFieldBegin('category', TType.I32, 2)
19928 
      oprot.writeI32(self.category)
19929 
      oprot.writeFieldEnd()
19930 
    oprot.writeFieldStop()
19931 
    oprot.writeStructEnd()
19932 
 
19933 
  def validate(self):
19934 
    return
19935 
 
19936 
 
19937 
  def __repr__(self):
19938 
    L = ['%s=%r' % (key, value)
19939 
      for key, value in self.__dict__.iteritems()]
19940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19941 
 
19942 
  def __eq__(self, other):
19943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19944 
 
19945 
  def __ne__(self, other):
19946 
    return not (self == other)
19947 
 
19948 
class markTransactionAsProcessed_result:
19949 
 
19950 
  thrift_spec = (
19951 
  )
19952 
 
19953 
  def read(self, iprot):
19954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19956 
      return
19957 
    iprot.readStructBegin()
19958 
    while True:
19959 
      (fname, ftype, fid) = iprot.readFieldBegin()
19960 
      if ftype == TType.STOP:
19961 
        break
19962 
      else:
19963 
        iprot.skip(ftype)
19964 
      iprot.readFieldEnd()
19965 
    iprot.readStructEnd()
19966 
 
19967 
  def write(self, oprot):
19968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19970 
      return
19971 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19972 
    oprot.writeFieldStop()
19973 
    oprot.writeStructEnd()
19974 
 
19975 
  def validate(self):
19976 
    return
19977 
 
19978 
 
19979 
  def __repr__(self):
19980 
    L = ['%s=%r' % (key, value)
19981 
      for key, value in self.__dict__.iteritems()]
19982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19983 
 
19984 
  def __eq__(self, other):
19985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19986 
 
19987 
  def __ne__(self, other):
19988 
    return not (self == other)
4018 chandransh 19989 
 
19990 
class getItemWiseRiskyOrdersCount_args:
19991 
 
19992 
  thrift_spec = (
19993 
  )
19994 
 
19995 
  def read(self, iprot):
19996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19998 
      return
19999 
    iprot.readStructBegin()
20000 
    while True:
20001 
      (fname, ftype, fid) = iprot.readFieldBegin()
20002 
      if ftype == TType.STOP:
20003 
        break
20004 
      else:
20005 
        iprot.skip(ftype)
20006 
      iprot.readFieldEnd()
20007 
    iprot.readStructEnd()
20008 
 
20009 
  def write(self, oprot):
20010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20012 
      return
20013 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20014 
    oprot.writeFieldStop()
20015 
    oprot.writeStructEnd()
20016 
 
20017 
  def validate(self):
20018 
    return
20019 
 
20020 
 
20021 
  def __repr__(self):
20022 
    L = ['%s=%r' % (key, value)
20023 
      for key, value in self.__dict__.iteritems()]
20024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20025 
 
20026 
  def __eq__(self, other):
20027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20028 
 
20029 
  def __ne__(self, other):
20030 
    return not (self == other)
20031 
 
20032 
class getItemWiseRiskyOrdersCount_result:
20033 
  """
20034 
  Attributes:
20035 
   - success
20036 
  """
20037 
 
20038 
  thrift_spec = (
20039 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20040 
  )
20041 
 
20042 
  def __init__(self, success=None,):
20043 
    self.success = success
20044 
 
20045 
  def read(self, iprot):
20046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20048 
      return
20049 
    iprot.readStructBegin()
20050 
    while True:
20051 
      (fname, ftype, fid) = iprot.readFieldBegin()
20052 
      if ftype == TType.STOP:
20053 
        break
20054 
      if fid == 0:
20055 
        if ftype == TType.MAP:
20056 
          self.success = {}
6188 rajveer 20057 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20058 
          for _i482 in xrange(_size478):
20059 
            _key483 = iprot.readI64();
20060 
            _val484 = iprot.readI64();
20061 
            self.success[_key483] = _val484
4018 chandransh 20062 
          iprot.readMapEnd()
20063 
        else:
20064 
          iprot.skip(ftype)
20065 
      else:
20066 
        iprot.skip(ftype)
20067 
      iprot.readFieldEnd()
20068 
    iprot.readStructEnd()
20069 
 
20070 
  def write(self, oprot):
20071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20073 
      return
20074 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20075 
    if self.success is not None:
20076 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20077 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20078 
      for kiter485,viter486 in self.success.items():
20079 
        oprot.writeI64(kiter485)
20080 
        oprot.writeI64(viter486)
4018 chandransh 20081 
      oprot.writeMapEnd()
20082 
      oprot.writeFieldEnd()
20083 
    oprot.writeFieldStop()
20084 
    oprot.writeStructEnd()
20085 
 
20086 
  def validate(self):
20087 
    return
20088 
 
20089 
 
20090 
  def __repr__(self):
20091 
    L = ['%s=%r' % (key, value)
20092 
      for key, value in self.__dict__.iteritems()]
20093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20094 
 
20095 
  def __eq__(self, other):
20096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20097 
 
20098 
  def __ne__(self, other):
20099 
    return not (self == other)
4247 rajveer 20100 
 
4295 varun.gupt 20101 
class getOrdersForItemIds_args:
20102 
  """
20103 
  Attributes:
20104 
   - itemIds
20105 
  """
20106 
 
20107 
  thrift_spec = (
20108 
    None, # 0
20109 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20110 
  )
20111 
 
20112 
  def __init__(self, itemIds=None,):
20113 
    self.itemIds = itemIds
20114 
 
20115 
  def read(self, iprot):
20116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20118 
      return
20119 
    iprot.readStructBegin()
20120 
    while True:
20121 
      (fname, ftype, fid) = iprot.readFieldBegin()
20122 
      if ftype == TType.STOP:
20123 
        break
20124 
      if fid == 1:
20125 
        if ftype == TType.LIST:
20126 
          self.itemIds = []
6188 rajveer 20127 
          (_etype490, _size487) = iprot.readListBegin()
20128 
          for _i491 in xrange(_size487):
20129 
            _elem492 = iprot.readI64();
20130 
            self.itemIds.append(_elem492)
4295 varun.gupt 20131 
          iprot.readListEnd()
20132 
        else:
20133 
          iprot.skip(ftype)
20134 
      else:
20135 
        iprot.skip(ftype)
20136 
      iprot.readFieldEnd()
20137 
    iprot.readStructEnd()
20138 
 
20139 
  def write(self, oprot):
20140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20142 
      return
20143 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20144 
    if self.itemIds is not None:
20145 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20146 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20147 
      for iter493 in self.itemIds:
20148 
        oprot.writeI64(iter493)
4295 varun.gupt 20149 
      oprot.writeListEnd()
20150 
      oprot.writeFieldEnd()
20151 
    oprot.writeFieldStop()
20152 
    oprot.writeStructEnd()
20153 
 
20154 
  def validate(self):
20155 
    return
20156 
 
20157 
 
20158 
  def __repr__(self):
20159 
    L = ['%s=%r' % (key, value)
20160 
      for key, value in self.__dict__.iteritems()]
20161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20162 
 
20163 
  def __eq__(self, other):
20164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20165 
 
20166 
  def __ne__(self, other):
20167 
    return not (self == other)
20168 
 
20169 
class getOrdersForItemIds_result:
20170 
  """
20171 
  Attributes:
20172 
   - success
20173 
  """
20174 
 
20175 
  thrift_spec = (
20176 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20177 
  )
20178 
 
20179 
  def __init__(self, success=None,):
20180 
    self.success = success
20181 
 
20182 
  def read(self, iprot):
20183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20185 
      return
20186 
    iprot.readStructBegin()
20187 
    while True:
20188 
      (fname, ftype, fid) = iprot.readFieldBegin()
20189 
      if ftype == TType.STOP:
20190 
        break
20191 
      if fid == 0:
20192 
        if ftype == TType.LIST:
20193 
          self.success = []
6188 rajveer 20194 
          (_etype497, _size494) = iprot.readListBegin()
20195 
          for _i498 in xrange(_size494):
20196 
            _elem499 = Order()
20197 
            _elem499.read(iprot)
20198 
            self.success.append(_elem499)
4295 varun.gupt 20199 
          iprot.readListEnd()
20200 
        else:
20201 
          iprot.skip(ftype)
20202 
      else:
20203 
        iprot.skip(ftype)
20204 
      iprot.readFieldEnd()
20205 
    iprot.readStructEnd()
20206 
 
20207 
  def write(self, oprot):
20208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20210 
      return
20211 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20212 
    if self.success is not None:
20213 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20214 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20215 
      for iter500 in self.success:
20216 
        iter500.write(oprot)
4295 varun.gupt 20217 
      oprot.writeListEnd()
20218 
      oprot.writeFieldEnd()
20219 
    oprot.writeFieldStop()
20220 
    oprot.writeStructEnd()
20221 
 
20222 
  def validate(self):
20223 
    return
20224 
 
20225 
 
20226 
  def __repr__(self):
20227 
    L = ['%s=%r' % (key, value)
20228 
      for key, value in self.__dict__.iteritems()]
20229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20230 
 
20231 
  def __eq__(self, other):
20232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20233 
 
20234 
  def __ne__(self, other):
20235 
    return not (self == other)
20236 
 
4247 rajveer 20237 
class markOrderCancellationRequestReceived_args:
20238 
  """
20239 
  Attributes:
20240 
   - orderId
20241 
  """
20242 
 
20243 
  thrift_spec = (
20244 
    None, # 0
20245 
    (1, TType.I64, 'orderId', None, None, ), # 1
20246 
  )
20247 
 
20248 
  def __init__(self, orderId=None,):
20249 
    self.orderId = orderId
20250 
 
20251 
  def read(self, iprot):
20252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20254 
      return
20255 
    iprot.readStructBegin()
20256 
    while True:
20257 
      (fname, ftype, fid) = iprot.readFieldBegin()
20258 
      if ftype == TType.STOP:
20259 
        break
20260 
      if fid == 1:
20261 
        if ftype == TType.I64:
20262 
          self.orderId = iprot.readI64();
20263 
        else:
20264 
          iprot.skip(ftype)
20265 
      else:
20266 
        iprot.skip(ftype)
20267 
      iprot.readFieldEnd()
20268 
    iprot.readStructEnd()
20269 
 
20270 
  def write(self, oprot):
20271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20273 
      return
20274 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20275 
    if self.orderId is not None:
20276 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20277 
      oprot.writeI64(self.orderId)
20278 
      oprot.writeFieldEnd()
20279 
    oprot.writeFieldStop()
20280 
    oprot.writeStructEnd()
20281 
 
20282 
  def validate(self):
20283 
    return
20284 
 
20285 
 
20286 
  def __repr__(self):
20287 
    L = ['%s=%r' % (key, value)
20288 
      for key, value in self.__dict__.iteritems()]
20289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20290 
 
20291 
  def __eq__(self, other):
20292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20293 
 
20294 
  def __ne__(self, other):
20295 
    return not (self == other)
20296 
 
20297 
class markOrderCancellationRequestReceived_result:
20298 
  """
20299 
  Attributes:
20300 
   - ex
20301 
  """
20302 
 
20303 
  thrift_spec = (
20304 
    None, # 0
20305 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20306 
  )
20307 
 
20308 
  def __init__(self, ex=None,):
20309 
    self.ex = ex
20310 
 
20311 
  def read(self, iprot):
20312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20314 
      return
20315 
    iprot.readStructBegin()
20316 
    while True:
20317 
      (fname, ftype, fid) = iprot.readFieldBegin()
20318 
      if ftype == TType.STOP:
20319 
        break
20320 
      if fid == 1:
20321 
        if ftype == TType.STRUCT:
20322 
          self.ex = TransactionServiceException()
20323 
          self.ex.read(iprot)
20324 
        else:
20325 
          iprot.skip(ftype)
20326 
      else:
20327 
        iprot.skip(ftype)
20328 
      iprot.readFieldEnd()
20329 
    iprot.readStructEnd()
20330 
 
20331 
  def write(self, oprot):
20332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20334 
      return
20335 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20336 
    if self.ex is not None:
20337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20338 
      self.ex.write(oprot)
20339 
      oprot.writeFieldEnd()
20340 
    oprot.writeFieldStop()
20341 
    oprot.writeStructEnd()
20342 
 
20343 
  def validate(self):
20344 
    return
20345 
 
20346 
 
20347 
  def __repr__(self):
20348 
    L = ['%s=%r' % (key, value)
20349 
      for key, value in self.__dict__.iteritems()]
20350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20351 
 
20352 
  def __eq__(self, other):
20353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20354 
 
20355 
  def __ne__(self, other):
20356 
    return not (self == other)
20357 
 
20358 
class markOrderCancellationRequestConfirmed_args:
20359 
  """
20360 
  Attributes:
20361 
   - orderId
20362 
  """
20363 
 
20364 
  thrift_spec = (
20365 
    None, # 0
20366 
    (1, TType.I64, 'orderId', None, None, ), # 1
20367 
  )
20368 
 
20369 
  def __init__(self, orderId=None,):
20370 
    self.orderId = orderId
20371 
 
20372 
  def read(self, iprot):
20373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20375 
      return
20376 
    iprot.readStructBegin()
20377 
    while True:
20378 
      (fname, ftype, fid) = iprot.readFieldBegin()
20379 
      if ftype == TType.STOP:
20380 
        break
20381 
      if fid == 1:
20382 
        if ftype == TType.I64:
20383 
          self.orderId = iprot.readI64();
20384 
        else:
20385 
          iprot.skip(ftype)
20386 
      else:
20387 
        iprot.skip(ftype)
20388 
      iprot.readFieldEnd()
20389 
    iprot.readStructEnd()
20390 
 
20391 
  def write(self, oprot):
20392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20394 
      return
20395 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20396 
    if self.orderId is not None:
20397 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20398 
      oprot.writeI64(self.orderId)
20399 
      oprot.writeFieldEnd()
20400 
    oprot.writeFieldStop()
20401 
    oprot.writeStructEnd()
20402 
 
20403 
  def validate(self):
20404 
    return
20405 
 
20406 
 
20407 
  def __repr__(self):
20408 
    L = ['%s=%r' % (key, value)
20409 
      for key, value in self.__dict__.iteritems()]
20410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20411 
 
20412 
  def __eq__(self, other):
20413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20414 
 
20415 
  def __ne__(self, other):
20416 
    return not (self == other)
20417 
 
20418 
class markOrderCancellationRequestConfirmed_result:
20419 
  """
20420 
  Attributes:
20421 
   - ex
20422 
  """
20423 
 
20424 
  thrift_spec = (
20425 
    None, # 0
20426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20427 
  )
20428 
 
20429 
  def __init__(self, ex=None,):
20430 
    self.ex = ex
20431 
 
20432 
  def read(self, iprot):
20433 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20434 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20435 
      return
20436 
    iprot.readStructBegin()
20437 
    while True:
20438 
      (fname, ftype, fid) = iprot.readFieldBegin()
20439 
      if ftype == TType.STOP:
20440 
        break
20441 
      if fid == 1:
20442 
        if ftype == TType.STRUCT:
20443 
          self.ex = TransactionServiceException()
20444 
          self.ex.read(iprot)
20445 
        else:
20446 
          iprot.skip(ftype)
20447 
      else:
20448 
        iprot.skip(ftype)
20449 
      iprot.readFieldEnd()
20450 
    iprot.readStructEnd()
20451 
 
20452 
  def write(self, oprot):
20453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20455 
      return
20456 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20457 
    if self.ex is not None:
20458 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20459 
      self.ex.write(oprot)
20460 
      oprot.writeFieldEnd()
20461 
    oprot.writeFieldStop()
20462 
    oprot.writeStructEnd()
20463 
 
20464 
  def validate(self):
20465 
    return
20466 
 
20467 
 
20468 
  def __repr__(self):
20469 
    L = ['%s=%r' % (key, value)
20470 
      for key, value in self.__dict__.iteritems()]
20471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20472 
 
20473 
  def __eq__(self, other):
20474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20475 
 
20476 
  def __ne__(self, other):
20477 
    return not (self == other)
20478 
 
20479 
class markOrderCancellationRequestDenied_args:
20480 
  """
20481 
  Attributes:
20482 
   - orderId
20483 
  """
20484 
 
20485 
  thrift_spec = (
20486 
    None, # 0
20487 
    (1, TType.I64, 'orderId', None, None, ), # 1
20488 
  )
20489 
 
20490 
  def __init__(self, orderId=None,):
20491 
    self.orderId = orderId
20492 
 
20493 
  def read(self, iprot):
20494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20496 
      return
20497 
    iprot.readStructBegin()
20498 
    while True:
20499 
      (fname, ftype, fid) = iprot.readFieldBegin()
20500 
      if ftype == TType.STOP:
20501 
        break
20502 
      if fid == 1:
20503 
        if ftype == TType.I64:
20504 
          self.orderId = iprot.readI64();
20505 
        else:
20506 
          iprot.skip(ftype)
20507 
      else:
20508 
        iprot.skip(ftype)
20509 
      iprot.readFieldEnd()
20510 
    iprot.readStructEnd()
20511 
 
20512 
  def write(self, oprot):
20513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20515 
      return
20516 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20517 
    if self.orderId is not None:
20518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20519 
      oprot.writeI64(self.orderId)
20520 
      oprot.writeFieldEnd()
20521 
    oprot.writeFieldStop()
20522 
    oprot.writeStructEnd()
20523 
 
20524 
  def validate(self):
20525 
    return
20526 
 
20527 
 
20528 
  def __repr__(self):
20529 
    L = ['%s=%r' % (key, value)
20530 
      for key, value in self.__dict__.iteritems()]
20531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20532 
 
20533 
  def __eq__(self, other):
20534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20535 
 
20536 
  def __ne__(self, other):
20537 
    return not (self == other)
20538 
 
20539 
class markOrderCancellationRequestDenied_result:
20540 
  """
20541 
  Attributes:
20542 
   - ex
20543 
  """
20544 
 
20545 
  thrift_spec = (
20546 
    None, # 0
20547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20548 
  )
20549 
 
20550 
  def __init__(self, ex=None,):
20551 
    self.ex = ex
20552 
 
20553 
  def read(self, iprot):
20554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20556 
      return
20557 
    iprot.readStructBegin()
20558 
    while True:
20559 
      (fname, ftype, fid) = iprot.readFieldBegin()
20560 
      if ftype == TType.STOP:
20561 
        break
20562 
      if fid == 1:
20563 
        if ftype == TType.STRUCT:
20564 
          self.ex = TransactionServiceException()
20565 
          self.ex.read(iprot)
20566 
        else:
20567 
          iprot.skip(ftype)
20568 
      else:
20569 
        iprot.skip(ftype)
20570 
      iprot.readFieldEnd()
20571 
    iprot.readStructEnd()
20572 
 
20573 
  def write(self, oprot):
20574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20576 
      return
20577 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20578 
    if self.ex is not None:
20579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20580 
      self.ex.write(oprot)
20581 
      oprot.writeFieldEnd()
20582 
    oprot.writeFieldStop()
20583 
    oprot.writeStructEnd()
20584 
 
20585 
  def validate(self):
20586 
    return
20587 
 
20588 
 
20589 
  def __repr__(self):
20590 
    L = ['%s=%r' % (key, value)
20591 
      for key, value in self.__dict__.iteritems()]
20592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20593 
 
20594 
  def __eq__(self, other):
20595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20596 
 
20597 
  def __ne__(self, other):
20598 
    return not (self == other)
20599 
 
4258 rajveer 20600 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20601 
  """
20602 
  Attributes:
4258 rajveer 20603 
   - transactionId
4247 rajveer 20604 
  """
20605 
 
20606 
  thrift_spec = (
20607 
    None, # 0
4258 rajveer 20608 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20609 
  )
20610 
 
4258 rajveer 20611 
  def __init__(self, transactionId=None,):
20612 
    self.transactionId = transactionId
4247 rajveer 20613 
 
20614 
  def read(self, iprot):
20615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20617 
      return
20618 
    iprot.readStructBegin()
20619 
    while True:
20620 
      (fname, ftype, fid) = iprot.readFieldBegin()
20621 
      if ftype == TType.STOP:
20622 
        break
20623 
      if fid == 1:
20624 
        if ftype == TType.I64:
4258 rajveer 20625 
          self.transactionId = iprot.readI64();
4247 rajveer 20626 
        else:
20627 
          iprot.skip(ftype)
20628 
      else:
20629 
        iprot.skip(ftype)
20630 
      iprot.readFieldEnd()
20631 
    iprot.readStructEnd()
20632 
 
20633 
  def write(self, oprot):
20634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20636 
      return
4258 rajveer 20637 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20638 
    if self.transactionId is not None:
20639 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20640 
      oprot.writeI64(self.transactionId)
4247 rajveer 20641 
      oprot.writeFieldEnd()
20642 
    oprot.writeFieldStop()
20643 
    oprot.writeStructEnd()
20644 
 
20645 
  def validate(self):
20646 
    return
20647 
 
20648 
 
20649 
  def __repr__(self):
20650 
    L = ['%s=%r' % (key, value)
20651 
      for key, value in self.__dict__.iteritems()]
20652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20653 
 
20654 
  def __eq__(self, other):
20655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20656 
 
20657 
  def __ne__(self, other):
20658 
    return not (self == other)
20659 
 
4258 rajveer 20660 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20661 
  """
20662 
  Attributes:
20663 
   - ex
20664 
  """
20665 
 
20666 
  thrift_spec = (
20667 
    None, # 0
20668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20669 
  )
20670 
 
20671 
  def __init__(self, ex=None,):
20672 
    self.ex = ex
20673 
 
20674 
  def read(self, iprot):
20675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20677 
      return
20678 
    iprot.readStructBegin()
20679 
    while True:
20680 
      (fname, ftype, fid) = iprot.readFieldBegin()
20681 
      if ftype == TType.STOP:
20682 
        break
20683 
      if fid == 1:
20684 
        if ftype == TType.STRUCT:
20685 
          self.ex = TransactionServiceException()
20686 
          self.ex.read(iprot)
20687 
        else:
20688 
          iprot.skip(ftype)
20689 
      else:
20690 
        iprot.skip(ftype)
20691 
      iprot.readFieldEnd()
20692 
    iprot.readStructEnd()
20693 
 
20694 
  def write(self, oprot):
20695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20697 
      return
4258 rajveer 20698 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20699 
    if self.ex is not None:
20700 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20701 
      self.ex.write(oprot)
20702 
      oprot.writeFieldEnd()
20703 
    oprot.writeFieldStop()
20704 
    oprot.writeStructEnd()
20705 
 
20706 
  def validate(self):
20707 
    return
20708 
 
20709 
 
20710 
  def __repr__(self):
20711 
    L = ['%s=%r' % (key, value)
20712 
      for key, value in self.__dict__.iteritems()]
20713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20714 
 
20715 
  def __eq__(self, other):
20716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20717 
 
20718 
  def __ne__(self, other):
20719 
    return not (self == other)
4259 anupam.sin 20720 
 
20721 
class refundTransaction_args:
20722 
  """
20723 
  Attributes:
20724 
   - transactionId
20725 
   - refundedBy
20726 
   - reason
20727 
  """
20728 
 
20729 
  thrift_spec = (
20730 
    None, # 0
20731 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20732 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20733 
    (3, TType.STRING, 'reason', None, None, ), # 3
20734 
  )
20735 
 
20736 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20737 
    self.transactionId = transactionId
20738 
    self.refundedBy = refundedBy
20739 
    self.reason = reason
20740 
 
20741 
  def read(self, iprot):
20742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20744 
      return
20745 
    iprot.readStructBegin()
20746 
    while True:
20747 
      (fname, ftype, fid) = iprot.readFieldBegin()
20748 
      if ftype == TType.STOP:
20749 
        break
20750 
      if fid == 1:
20751 
        if ftype == TType.I64:
20752 
          self.transactionId = iprot.readI64();
20753 
        else:
20754 
          iprot.skip(ftype)
20755 
      elif fid == 2:
20756 
        if ftype == TType.STRING:
20757 
          self.refundedBy = iprot.readString();
20758 
        else:
20759 
          iprot.skip(ftype)
20760 
      elif fid == 3:
20761 
        if ftype == TType.STRING:
20762 
          self.reason = iprot.readString();
20763 
        else:
20764 
          iprot.skip(ftype)
20765 
      else:
20766 
        iprot.skip(ftype)
20767 
      iprot.readFieldEnd()
20768 
    iprot.readStructEnd()
20769 
 
20770 
  def write(self, oprot):
20771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20773 
      return
20774 
    oprot.writeStructBegin('refundTransaction_args')
20775 
    if self.transactionId is not None:
20776 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20777 
      oprot.writeI64(self.transactionId)
20778 
      oprot.writeFieldEnd()
20779 
    if self.refundedBy is not None:
20780 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20781 
      oprot.writeString(self.refundedBy)
20782 
      oprot.writeFieldEnd()
20783 
    if self.reason is not None:
20784 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20785 
      oprot.writeString(self.reason)
20786 
      oprot.writeFieldEnd()
20787 
    oprot.writeFieldStop()
20788 
    oprot.writeStructEnd()
20789 
 
20790 
  def validate(self):
20791 
    return
20792 
 
20793 
 
20794 
  def __repr__(self):
20795 
    L = ['%s=%r' % (key, value)
20796 
      for key, value in self.__dict__.iteritems()]
20797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20798 
 
20799 
  def __eq__(self, other):
20800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20801 
 
20802 
  def __ne__(self, other):
20803 
    return not (self == other)
20804 
 
20805 
class refundTransaction_result:
20806 
  """
20807 
  Attributes:
20808 
   - ex
20809 
  """
20810 
 
20811 
  thrift_spec = (
20812 
    None, # 0
20813 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20814 
  )
20815 
 
20816 
  def __init__(self, ex=None,):
20817 
    self.ex = ex
20818 
 
20819 
  def read(self, iprot):
20820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20822 
      return
20823 
    iprot.readStructBegin()
20824 
    while True:
20825 
      (fname, ftype, fid) = iprot.readFieldBegin()
20826 
      if ftype == TType.STOP:
20827 
        break
20828 
      if fid == 1:
20829 
        if ftype == TType.STRUCT:
20830 
          self.ex = TransactionServiceException()
20831 
          self.ex.read(iprot)
20832 
        else:
20833 
          iprot.skip(ftype)
20834 
      else:
20835 
        iprot.skip(ftype)
20836 
      iprot.readFieldEnd()
20837 
    iprot.readStructEnd()
20838 
 
20839 
  def write(self, oprot):
20840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20842 
      return
20843 
    oprot.writeStructBegin('refundTransaction_result')
20844 
    if self.ex is not None:
20845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20846 
      self.ex.write(oprot)
20847 
      oprot.writeFieldEnd()
20848 
    oprot.writeFieldStop()
20849 
    oprot.writeStructEnd()
20850 
 
20851 
  def validate(self):
20852 
    return
20853 
 
20854 
 
20855 
  def __repr__(self):
20856 
    L = ['%s=%r' % (key, value)
20857 
      for key, value in self.__dict__.iteritems()]
20858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20859 
 
20860 
  def __eq__(self, other):
20861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20862 
 
20863 
  def __ne__(self, other):
20864 
    return not (self == other)
4285 rajveer 20865 
 
4324 mandeep.dh 20866 
class updateShipmentAddress_args:
20867 
  """
20868 
  Attributes:
20869 
   - orderId
20870 
   - addressId
20871 
  """
20872 
 
20873 
  thrift_spec = (
20874 
    None, # 0
20875 
    (1, TType.I64, 'orderId', None, None, ), # 1
20876 
    (2, TType.I64, 'addressId', None, None, ), # 2
20877 
  )
20878 
 
20879 
  def __init__(self, orderId=None, addressId=None,):
20880 
    self.orderId = orderId
20881 
    self.addressId = addressId
20882 
 
20883 
  def read(self, iprot):
20884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20886 
      return
20887 
    iprot.readStructBegin()
20888 
    while True:
20889 
      (fname, ftype, fid) = iprot.readFieldBegin()
20890 
      if ftype == TType.STOP:
20891 
        break
20892 
      if fid == 1:
20893 
        if ftype == TType.I64:
20894 
          self.orderId = iprot.readI64();
20895 
        else:
20896 
          iprot.skip(ftype)
20897 
      elif fid == 2:
20898 
        if ftype == TType.I64:
20899 
          self.addressId = iprot.readI64();
20900 
        else:
20901 
          iprot.skip(ftype)
20902 
      else:
20903 
        iprot.skip(ftype)
20904 
      iprot.readFieldEnd()
20905 
    iprot.readStructEnd()
20906 
 
20907 
  def write(self, oprot):
20908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20910 
      return
20911 
    oprot.writeStructBegin('updateShipmentAddress_args')
20912 
    if self.orderId is not None:
20913 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20914 
      oprot.writeI64(self.orderId)
20915 
      oprot.writeFieldEnd()
20916 
    if self.addressId is not None:
20917 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20918 
      oprot.writeI64(self.addressId)
20919 
      oprot.writeFieldEnd()
20920 
    oprot.writeFieldStop()
20921 
    oprot.writeStructEnd()
20922 
 
20923 
  def validate(self):
20924 
    return
20925 
 
20926 
 
20927 
  def __repr__(self):
20928 
    L = ['%s=%r' % (key, value)
20929 
      for key, value in self.__dict__.iteritems()]
20930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20931 
 
20932 
  def __eq__(self, other):
20933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20934 
 
20935 
  def __ne__(self, other):
20936 
    return not (self == other)
20937 
 
20938 
class updateShipmentAddress_result:
20939 
  """
20940 
  Attributes:
20941 
   - ex
20942 
  """
20943 
 
20944 
  thrift_spec = (
20945 
    None, # 0
20946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20947 
  )
20948 
 
20949 
  def __init__(self, ex=None,):
20950 
    self.ex = ex
20951 
 
20952 
  def read(self, iprot):
20953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20955 
      return
20956 
    iprot.readStructBegin()
20957 
    while True:
20958 
      (fname, ftype, fid) = iprot.readFieldBegin()
20959 
      if ftype == TType.STOP:
20960 
        break
20961 
      if fid == 1:
20962 
        if ftype == TType.STRUCT:
20963 
          self.ex = TransactionServiceException()
20964 
          self.ex.read(iprot)
20965 
        else:
20966 
          iprot.skip(ftype)
20967 
      else:
20968 
        iprot.skip(ftype)
20969 
      iprot.readFieldEnd()
20970 
    iprot.readStructEnd()
20971 
 
20972 
  def write(self, oprot):
20973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20975 
      return
20976 
    oprot.writeStructBegin('updateShipmentAddress_result')
20977 
    if self.ex is not None:
20978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20979 
      self.ex.write(oprot)
20980 
      oprot.writeFieldEnd()
20981 
    oprot.writeFieldStop()
20982 
    oprot.writeStructEnd()
20983 
 
20984 
  def validate(self):
20985 
    return
20986 
 
20987 
 
20988 
  def __repr__(self):
20989 
    L = ['%s=%r' % (key, value)
20990 
      for key, value in self.__dict__.iteritems()]
20991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20992 
 
20993 
  def __eq__(self, other):
20994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20995 
 
20996 
  def __ne__(self, other):
20997 
    return not (self == other)
20998 
 
4285 rajveer 20999 
class acceptOrdersForItemId_args:
21000 
  """
21001 
  Attributes:
21002 
   - itemId
21003 
   - inventory
21004 
  """
21005 
 
21006 
  thrift_spec = (
21007 
    None, # 0
21008 
    (1, TType.I64, 'itemId', None, None, ), # 1
21009 
    (2, TType.I64, 'inventory', None, None, ), # 2
21010 
  )
21011 
 
21012 
  def __init__(self, itemId=None, inventory=None,):
21013 
    self.itemId = itemId
21014 
    self.inventory = inventory
21015 
 
21016 
  def read(self, iprot):
21017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21019 
      return
21020 
    iprot.readStructBegin()
21021 
    while True:
21022 
      (fname, ftype, fid) = iprot.readFieldBegin()
21023 
      if ftype == TType.STOP:
21024 
        break
21025 
      if fid == 1:
21026 
        if ftype == TType.I64:
21027 
          self.itemId = iprot.readI64();
21028 
        else:
21029 
          iprot.skip(ftype)
21030 
      elif fid == 2:
21031 
        if ftype == TType.I64:
21032 
          self.inventory = iprot.readI64();
21033 
        else:
21034 
          iprot.skip(ftype)
21035 
      else:
21036 
        iprot.skip(ftype)
21037 
      iprot.readFieldEnd()
21038 
    iprot.readStructEnd()
21039 
 
21040 
  def write(self, oprot):
21041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21043 
      return
21044 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21045 
    if self.itemId is not None:
21046 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21047 
      oprot.writeI64(self.itemId)
21048 
      oprot.writeFieldEnd()
21049 
    if self.inventory is not None:
21050 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21051 
      oprot.writeI64(self.inventory)
21052 
      oprot.writeFieldEnd()
21053 
    oprot.writeFieldStop()
21054 
    oprot.writeStructEnd()
21055 
 
21056 
  def validate(self):
21057 
    return
21058 
 
21059 
 
21060 
  def __repr__(self):
21061 
    L = ['%s=%r' % (key, value)
21062 
      for key, value in self.__dict__.iteritems()]
21063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21064 
 
21065 
  def __eq__(self, other):
21066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21067 
 
21068 
  def __ne__(self, other):
21069 
    return not (self == other)
21070 
 
21071 
class acceptOrdersForItemId_result:
21072 
  """
21073 
  Attributes:
21074 
   - success
21075 
   - ex
21076 
  """
21077 
 
21078 
  thrift_spec = (
21079 
    (0, TType.BOOL, 'success', None, None, ), # 0
21080 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21081 
  )
21082 
 
21083 
  def __init__(self, success=None, ex=None,):
21084 
    self.success = success
21085 
    self.ex = ex
21086 
 
21087 
  def read(self, iprot):
21088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21090 
      return
21091 
    iprot.readStructBegin()
21092 
    while True:
21093 
      (fname, ftype, fid) = iprot.readFieldBegin()
21094 
      if ftype == TType.STOP:
21095 
        break
21096 
      if fid == 0:
21097 
        if ftype == TType.BOOL:
21098 
          self.success = iprot.readBool();
21099 
        else:
21100 
          iprot.skip(ftype)
21101 
      elif fid == 1:
21102 
        if ftype == TType.STRUCT:
21103 
          self.ex = TransactionServiceException()
21104 
          self.ex.read(iprot)
21105 
        else:
21106 
          iprot.skip(ftype)
21107 
      else:
21108 
        iprot.skip(ftype)
21109 
      iprot.readFieldEnd()
21110 
    iprot.readStructEnd()
21111 
 
21112 
  def write(self, oprot):
21113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21115 
      return
21116 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21117 
    if self.success is not None:
21118 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21119 
      oprot.writeBool(self.success)
21120 
      oprot.writeFieldEnd()
21121 
    if self.ex is not None:
21122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21123 
      self.ex.write(oprot)
21124 
      oprot.writeFieldEnd()
21125 
    oprot.writeFieldStop()
21126 
    oprot.writeStructEnd()
21127 
 
21128 
  def validate(self):
21129 
    return
21130 
 
21131 
 
21132 
  def __repr__(self):
21133 
    L = ['%s=%r' % (key, value)
21134 
      for key, value in self.__dict__.iteritems()]
21135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21136 
 
21137 
  def __eq__(self, other):
21138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21139 
 
21140 
  def __ne__(self, other):
21141 
    return not (self == other)
4303 rajveer 21142 
 
21143 
class markOrdersAsPORaised_args:
21144 
  """
21145 
  Attributes:
21146 
   - vendorId
21147 
   - itemId
21148 
   - quantity
21149 
   - estimate
4369 rajveer 21150 
   - isReminder
4303 rajveer 21151 
  """
21152 
 
21153 
  thrift_spec = (
21154 
    None, # 0
21155 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21156 
    (2, TType.I64, 'itemId', None, None, ), # 2
21157 
    (3, TType.I64, 'quantity', None, None, ), # 3
21158 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21159 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21160 
  )
21161 
 
4369 rajveer 21162 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21163 
    self.vendorId = vendorId
21164 
    self.itemId = itemId
21165 
    self.quantity = quantity
21166 
    self.estimate = estimate
4369 rajveer 21167 
    self.isReminder = isReminder
4303 rajveer 21168 
 
21169 
  def read(self, iprot):
21170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21172 
      return
21173 
    iprot.readStructBegin()
21174 
    while True:
21175 
      (fname, ftype, fid) = iprot.readFieldBegin()
21176 
      if ftype == TType.STOP:
21177 
        break
21178 
      if fid == 1:
21179 
        if ftype == TType.I64:
21180 
          self.vendorId = iprot.readI64();
21181 
        else:
21182 
          iprot.skip(ftype)
21183 
      elif fid == 2:
21184 
        if ftype == TType.I64:
21185 
          self.itemId = iprot.readI64();
21186 
        else:
21187 
          iprot.skip(ftype)
21188 
      elif fid == 3:
21189 
        if ftype == TType.I64:
21190 
          self.quantity = iprot.readI64();
21191 
        else:
21192 
          iprot.skip(ftype)
21193 
      elif fid == 4:
21194 
        if ftype == TType.I64:
21195 
          self.estimate = iprot.readI64();
21196 
        else:
21197 
          iprot.skip(ftype)
4369 rajveer 21198 
      elif fid == 5:
21199 
        if ftype == TType.BOOL:
21200 
          self.isReminder = iprot.readBool();
21201 
        else:
21202 
          iprot.skip(ftype)
4303 rajveer 21203 
      else:
21204 
        iprot.skip(ftype)
21205 
      iprot.readFieldEnd()
21206 
    iprot.readStructEnd()
21207 
 
21208 
  def write(self, oprot):
21209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21211 
      return
21212 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21213 
    if self.vendorId is not None:
21214 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21215 
      oprot.writeI64(self.vendorId)
21216 
      oprot.writeFieldEnd()
21217 
    if self.itemId is not None:
21218 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21219 
      oprot.writeI64(self.itemId)
21220 
      oprot.writeFieldEnd()
21221 
    if self.quantity is not None:
21222 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21223 
      oprot.writeI64(self.quantity)
21224 
      oprot.writeFieldEnd()
21225 
    if self.estimate is not None:
21226 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21227 
      oprot.writeI64(self.estimate)
21228 
      oprot.writeFieldEnd()
4369 rajveer 21229 
    if self.isReminder is not None:
21230 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21231 
      oprot.writeBool(self.isReminder)
21232 
      oprot.writeFieldEnd()
4303 rajveer 21233 
    oprot.writeFieldStop()
21234 
    oprot.writeStructEnd()
21235 
 
21236 
  def validate(self):
21237 
    return
21238 
 
21239 
 
21240 
  def __repr__(self):
21241 
    L = ['%s=%r' % (key, value)
21242 
      for key, value in self.__dict__.iteritems()]
21243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21244 
 
21245 
  def __eq__(self, other):
21246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21247 
 
21248 
  def __ne__(self, other):
21249 
    return not (self == other)
21250 
 
21251 
class markOrdersAsPORaised_result:
21252 
  """
21253 
  Attributes:
21254 
   - ex
21255 
  """
21256 
 
21257 
  thrift_spec = (
21258 
    None, # 0
21259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21260 
  )
21261 
 
21262 
  def __init__(self, ex=None,):
21263 
    self.ex = ex
21264 
 
21265 
  def read(self, iprot):
21266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21268 
      return
21269 
    iprot.readStructBegin()
21270 
    while True:
21271 
      (fname, ftype, fid) = iprot.readFieldBegin()
21272 
      if ftype == TType.STOP:
21273 
        break
21274 
      if fid == 1:
21275 
        if ftype == TType.STRUCT:
21276 
          self.ex = TransactionServiceException()
21277 
          self.ex.read(iprot)
21278 
        else:
21279 
          iprot.skip(ftype)
21280 
      else:
21281 
        iprot.skip(ftype)
21282 
      iprot.readFieldEnd()
21283 
    iprot.readStructEnd()
21284 
 
21285 
  def write(self, oprot):
21286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21288 
      return
21289 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21290 
    if self.ex is not None:
21291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21292 
      self.ex.write(oprot)
21293 
      oprot.writeFieldEnd()
21294 
    oprot.writeFieldStop()
21295 
    oprot.writeStructEnd()
21296 
 
21297 
  def validate(self):
21298 
    return
21299 
 
21300 
 
21301 
  def __repr__(self):
21302 
    L = ['%s=%r' % (key, value)
21303 
      for key, value in self.__dict__.iteritems()]
21304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21305 
 
21306 
  def __eq__(self, other):
21307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21308 
 
21309 
  def __ne__(self, other):
21310 
    return not (self == other)
21311 
 
21312 
class markOrdersAsReversalInitiated_args:
21313 
  """
21314 
  Attributes:
21315 
   - vendorId
21316 
   - itemId
21317 
   - quantity
21318 
   - estimate
4369 rajveer 21319 
   - isReminder
4303 rajveer 21320 
  """
21321 
 
21322 
  thrift_spec = (
21323 
    None, # 0
21324 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21325 
    (2, TType.I64, 'itemId', None, None, ), # 2
21326 
    (3, TType.I64, 'quantity', None, None, ), # 3
21327 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21328 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21329 
  )
21330 
 
4369 rajveer 21331 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21332 
    self.vendorId = vendorId
21333 
    self.itemId = itemId
21334 
    self.quantity = quantity
21335 
    self.estimate = estimate
4369 rajveer 21336 
    self.isReminder = isReminder
4303 rajveer 21337 
 
21338 
  def read(self, iprot):
21339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21341 
      return
21342 
    iprot.readStructBegin()
21343 
    while True:
21344 
      (fname, ftype, fid) = iprot.readFieldBegin()
21345 
      if ftype == TType.STOP:
21346 
        break
21347 
      if fid == 1:
21348 
        if ftype == TType.I64:
21349 
          self.vendorId = iprot.readI64();
21350 
        else:
21351 
          iprot.skip(ftype)
21352 
      elif fid == 2:
21353 
        if ftype == TType.I64:
21354 
          self.itemId = iprot.readI64();
21355 
        else:
21356 
          iprot.skip(ftype)
21357 
      elif fid == 3:
21358 
        if ftype == TType.I64:
21359 
          self.quantity = iprot.readI64();
21360 
        else:
21361 
          iprot.skip(ftype)
21362 
      elif fid == 4:
21363 
        if ftype == TType.I64:
21364 
          self.estimate = iprot.readI64();
21365 
        else:
21366 
          iprot.skip(ftype)
4369 rajveer 21367 
      elif fid == 5:
21368 
        if ftype == TType.BOOL:
21369 
          self.isReminder = iprot.readBool();
21370 
        else:
21371 
          iprot.skip(ftype)
4303 rajveer 21372 
      else:
21373 
        iprot.skip(ftype)
21374 
      iprot.readFieldEnd()
21375 
    iprot.readStructEnd()
21376 
 
21377 
  def write(self, oprot):
21378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21380 
      return
21381 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21382 
    if self.vendorId is not None:
21383 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21384 
      oprot.writeI64(self.vendorId)
21385 
      oprot.writeFieldEnd()
21386 
    if self.itemId is not None:
21387 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21388 
      oprot.writeI64(self.itemId)
21389 
      oprot.writeFieldEnd()
21390 
    if self.quantity is not None:
21391 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21392 
      oprot.writeI64(self.quantity)
21393 
      oprot.writeFieldEnd()
21394 
    if self.estimate is not None:
21395 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21396 
      oprot.writeI64(self.estimate)
21397 
      oprot.writeFieldEnd()
4369 rajveer 21398 
    if self.isReminder is not None:
21399 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21400 
      oprot.writeBool(self.isReminder)
21401 
      oprot.writeFieldEnd()
4303 rajveer 21402 
    oprot.writeFieldStop()
21403 
    oprot.writeStructEnd()
21404 
 
21405 
  def validate(self):
21406 
    return
21407 
 
21408 
 
21409 
  def __repr__(self):
21410 
    L = ['%s=%r' % (key, value)
21411 
      for key, value in self.__dict__.iteritems()]
21412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21413 
 
21414 
  def __eq__(self, other):
21415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21416 
 
21417 
  def __ne__(self, other):
21418 
    return not (self == other)
21419 
 
21420 
class markOrdersAsReversalInitiated_result:
21421 
  """
21422 
  Attributes:
21423 
   - ex
21424 
  """
21425 
 
21426 
  thrift_spec = (
21427 
    None, # 0
21428 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21429 
  )
21430 
 
21431 
  def __init__(self, ex=None,):
21432 
    self.ex = ex
21433 
 
21434 
  def read(self, iprot):
21435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21437 
      return
21438 
    iprot.readStructBegin()
21439 
    while True:
21440 
      (fname, ftype, fid) = iprot.readFieldBegin()
21441 
      if ftype == TType.STOP:
21442 
        break
21443 
      if fid == 1:
21444 
        if ftype == TType.STRUCT:
21445 
          self.ex = TransactionServiceException()
21446 
          self.ex.read(iprot)
21447 
        else:
21448 
          iprot.skip(ftype)
21449 
      else:
21450 
        iprot.skip(ftype)
21451 
      iprot.readFieldEnd()
21452 
    iprot.readStructEnd()
21453 
 
21454 
  def write(self, oprot):
21455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21457 
      return
21458 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21459 
    if self.ex is not None:
21460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21461 
      self.ex.write(oprot)
21462 
      oprot.writeFieldEnd()
21463 
    oprot.writeFieldStop()
21464 
    oprot.writeStructEnd()
21465 
 
21466 
  def validate(self):
21467 
    return
21468 
 
21469 
 
21470 
  def __repr__(self):
21471 
    L = ['%s=%r' % (key, value)
21472 
      for key, value in self.__dict__.iteritems()]
21473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21474 
 
21475 
  def __eq__(self, other):
21476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21477 
 
21478 
  def __ne__(self, other):
21479 
    return not (self == other)
21480 
 
21481 
class markOrdersAsNotAvailabke_args:
21482 
  """
21483 
  Attributes:
21484 
   - vendorId
21485 
   - itemId
21486 
   - quantity
21487 
   - estimate
4369 rajveer 21488 
   - isReminder
4303 rajveer 21489 
  """
21490 
 
21491 
  thrift_spec = (
21492 
    None, # 0
21493 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21494 
    (2, TType.I64, 'itemId', None, None, ), # 2
21495 
    (3, TType.I64, 'quantity', None, None, ), # 3
21496 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21497 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21498 
  )
21499 
 
4369 rajveer 21500 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21501 
    self.vendorId = vendorId
21502 
    self.itemId = itemId
21503 
    self.quantity = quantity
21504 
    self.estimate = estimate
4369 rajveer 21505 
    self.isReminder = isReminder
4303 rajveer 21506 
 
21507 
  def read(self, iprot):
21508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21510 
      return
21511 
    iprot.readStructBegin()
21512 
    while True:
21513 
      (fname, ftype, fid) = iprot.readFieldBegin()
21514 
      if ftype == TType.STOP:
21515 
        break
21516 
      if fid == 1:
21517 
        if ftype == TType.I64:
21518 
          self.vendorId = iprot.readI64();
21519 
        else:
21520 
          iprot.skip(ftype)
21521 
      elif fid == 2:
21522 
        if ftype == TType.I64:
21523 
          self.itemId = iprot.readI64();
21524 
        else:
21525 
          iprot.skip(ftype)
21526 
      elif fid == 3:
21527 
        if ftype == TType.I64:
21528 
          self.quantity = iprot.readI64();
21529 
        else:
21530 
          iprot.skip(ftype)
21531 
      elif fid == 4:
21532 
        if ftype == TType.I64:
21533 
          self.estimate = iprot.readI64();
21534 
        else:
21535 
          iprot.skip(ftype)
4369 rajveer 21536 
      elif fid == 5:
21537 
        if ftype == TType.BOOL:
21538 
          self.isReminder = iprot.readBool();
21539 
        else:
21540 
          iprot.skip(ftype)
4303 rajveer 21541 
      else:
21542 
        iprot.skip(ftype)
21543 
      iprot.readFieldEnd()
21544 
    iprot.readStructEnd()
21545 
 
21546 
  def write(self, oprot):
21547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21549 
      return
21550 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21551 
    if self.vendorId is not None:
21552 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21553 
      oprot.writeI64(self.vendorId)
21554 
      oprot.writeFieldEnd()
21555 
    if self.itemId is not None:
21556 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21557 
      oprot.writeI64(self.itemId)
21558 
      oprot.writeFieldEnd()
21559 
    if self.quantity is not None:
21560 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21561 
      oprot.writeI64(self.quantity)
21562 
      oprot.writeFieldEnd()
21563 
    if self.estimate is not None:
21564 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21565 
      oprot.writeI64(self.estimate)
21566 
      oprot.writeFieldEnd()
4369 rajveer 21567 
    if self.isReminder is not None:
21568 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21569 
      oprot.writeBool(self.isReminder)
21570 
      oprot.writeFieldEnd()
4303 rajveer 21571 
    oprot.writeFieldStop()
21572 
    oprot.writeStructEnd()
21573 
 
21574 
  def validate(self):
21575 
    return
21576 
 
21577 
 
21578 
  def __repr__(self):
21579 
    L = ['%s=%r' % (key, value)
21580 
      for key, value in self.__dict__.iteritems()]
21581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21582 
 
21583 
  def __eq__(self, other):
21584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21585 
 
21586 
  def __ne__(self, other):
21587 
    return not (self == other)
21588 
 
21589 
class markOrdersAsNotAvailabke_result:
21590 
  """
21591 
  Attributes:
21592 
   - ex
21593 
  """
21594 
 
21595 
  thrift_spec = (
21596 
    None, # 0
21597 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21598 
  )
21599 
 
21600 
  def __init__(self, ex=None,):
21601 
    self.ex = ex
21602 
 
21603 
  def read(self, iprot):
21604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21606 
      return
21607 
    iprot.readStructBegin()
21608 
    while True:
21609 
      (fname, ftype, fid) = iprot.readFieldBegin()
21610 
      if ftype == TType.STOP:
21611 
        break
21612 
      if fid == 1:
21613 
        if ftype == TType.STRUCT:
21614 
          self.ex = TransactionServiceException()
21615 
          self.ex.read(iprot)
21616 
        else:
21617 
          iprot.skip(ftype)
21618 
      else:
21619 
        iprot.skip(ftype)
21620 
      iprot.readFieldEnd()
21621 
    iprot.readStructEnd()
21622 
 
21623 
  def write(self, oprot):
21624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21626 
      return
21627 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21628 
    if self.ex is not None:
21629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21630 
      self.ex.write(oprot)
21631 
      oprot.writeFieldEnd()
21632 
    oprot.writeFieldStop()
21633 
    oprot.writeStructEnd()
21634 
 
21635 
  def validate(self):
21636 
    return
21637 
 
21638 
 
21639 
  def __repr__(self):
21640 
    L = ['%s=%r' % (key, value)
21641 
      for key, value in self.__dict__.iteritems()]
21642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21643 
 
21644 
  def __eq__(self, other):
21645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21646 
 
21647 
  def __ne__(self, other):
21648 
    return not (self == other)
4369 rajveer 21649 
 
21650 
class markOrdersAsTimeout_args:
21651 
  """
21652 
  Attributes:
21653 
   - vendorId
21654 
  """
21655 
 
21656 
  thrift_spec = (
21657 
    None, # 0
21658 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21659 
  )
21660 
 
21661 
  def __init__(self, vendorId=None,):
21662 
    self.vendorId = vendorId
21663 
 
21664 
  def read(self, iprot):
21665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21667 
      return
21668 
    iprot.readStructBegin()
21669 
    while True:
21670 
      (fname, ftype, fid) = iprot.readFieldBegin()
21671 
      if ftype == TType.STOP:
21672 
        break
21673 
      if fid == 1:
21674 
        if ftype == TType.I64:
21675 
          self.vendorId = iprot.readI64();
21676 
        else:
21677 
          iprot.skip(ftype)
21678 
      else:
21679 
        iprot.skip(ftype)
21680 
      iprot.readFieldEnd()
21681 
    iprot.readStructEnd()
21682 
 
21683 
  def write(self, oprot):
21684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21686 
      return
21687 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21688 
    if self.vendorId is not None:
21689 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21690 
      oprot.writeI64(self.vendorId)
21691 
      oprot.writeFieldEnd()
21692 
    oprot.writeFieldStop()
21693 
    oprot.writeStructEnd()
21694 
 
21695 
  def validate(self):
21696 
    return
21697 
 
21698 
 
21699 
  def __repr__(self):
21700 
    L = ['%s=%r' % (key, value)
21701 
      for key, value in self.__dict__.iteritems()]
21702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21703 
 
21704 
  def __eq__(self, other):
21705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21706 
 
21707 
  def __ne__(self, other):
21708 
    return not (self == other)
21709 
 
21710 
class markOrdersAsTimeout_result:
21711 
  """
21712 
  Attributes:
21713 
   - success
21714 
   - ex
21715 
  """
21716 
 
21717 
  thrift_spec = (
21718 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21719 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21720 
  )
21721 
 
21722 
  def __init__(self, success=None, ex=None,):
21723 
    self.success = success
21724 
    self.ex = ex
21725 
 
21726 
  def read(self, iprot):
21727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21729 
      return
21730 
    iprot.readStructBegin()
21731 
    while True:
21732 
      (fname, ftype, fid) = iprot.readFieldBegin()
21733 
      if ftype == TType.STOP:
21734 
        break
21735 
      if fid == 0:
21736 
        if ftype == TType.MAP:
21737 
          self.success = {}
6188 rajveer 21738 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21739 
          for _i505 in xrange(_size501):
21740 
            _key506 = iprot.readI32();
21741 
            _val507 = TimeoutSummary()
21742 
            _val507.read(iprot)
21743 
            self.success[_key506] = _val507
4369 rajveer 21744 
          iprot.readMapEnd()
21745 
        else:
21746 
          iprot.skip(ftype)
21747 
      elif fid == 1:
21748 
        if ftype == TType.STRUCT:
21749 
          self.ex = TransactionServiceException()
21750 
          self.ex.read(iprot)
21751 
        else:
21752 
          iprot.skip(ftype)
21753 
      else:
21754 
        iprot.skip(ftype)
21755 
      iprot.readFieldEnd()
21756 
    iprot.readStructEnd()
21757 
 
21758 
  def write(self, oprot):
21759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21761 
      return
21762 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21763 
    if self.success is not None:
21764 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21765 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21766 
      for kiter508,viter509 in self.success.items():
21767 
        oprot.writeI32(kiter508)
21768 
        viter509.write(oprot)
4369 rajveer 21769 
      oprot.writeMapEnd()
21770 
      oprot.writeFieldEnd()
21771 
    if self.ex is not None:
21772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21773 
      self.ex.write(oprot)
21774 
      oprot.writeFieldEnd()
21775 
    oprot.writeFieldStop()
21776 
    oprot.writeStructEnd()
21777 
 
21778 
  def validate(self):
21779 
    return
21780 
 
21781 
 
21782 
  def __repr__(self):
21783 
    L = ['%s=%r' % (key, value)
21784 
      for key, value in self.__dict__.iteritems()]
21785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21786 
 
21787 
  def __eq__(self, other):
21788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21789 
 
21790 
  def __ne__(self, other):
21791 
    return not (self == other)
4386 anupam.sin 21792 
 
4662 rajveer 21793 
class markOrderAsLostInTransit_args:
21794 
  """
21795 
  Attributes:
21796 
   - orderId
21797 
  """
21798 
 
21799 
  thrift_spec = (
21800 
    None, # 0
21801 
    (1, TType.I64, 'orderId', None, None, ), # 1
21802 
  )
21803 
 
21804 
  def __init__(self, orderId=None,):
21805 
    self.orderId = orderId
21806 
 
21807 
  def read(self, iprot):
21808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21810 
      return
21811 
    iprot.readStructBegin()
21812 
    while True:
21813 
      (fname, ftype, fid) = iprot.readFieldBegin()
21814 
      if ftype == TType.STOP:
21815 
        break
21816 
      if fid == 1:
21817 
        if ftype == TType.I64:
21818 
          self.orderId = iprot.readI64();
21819 
        else:
21820 
          iprot.skip(ftype)
21821 
      else:
21822 
        iprot.skip(ftype)
21823 
      iprot.readFieldEnd()
21824 
    iprot.readStructEnd()
21825 
 
21826 
  def write(self, oprot):
21827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21829 
      return
21830 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21831 
    if self.orderId is not None:
21832 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21833 
      oprot.writeI64(self.orderId)
21834 
      oprot.writeFieldEnd()
21835 
    oprot.writeFieldStop()
21836 
    oprot.writeStructEnd()
21837 
 
21838 
  def validate(self):
21839 
    return
21840 
 
21841 
 
21842 
  def __repr__(self):
21843 
    L = ['%s=%r' % (key, value)
21844 
      for key, value in self.__dict__.iteritems()]
21845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21846 
 
21847 
  def __eq__(self, other):
21848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21849 
 
21850 
  def __ne__(self, other):
21851 
    return not (self == other)
21852 
 
21853 
class markOrderAsLostInTransit_result:
21854 
  """
21855 
  Attributes:
21856 
   - success
21857 
   - ex
21858 
  """
21859 
 
21860 
  thrift_spec = (
21861 
    (0, TType.BOOL, 'success', None, None, ), # 0
21862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21863 
  )
21864 
 
21865 
  def __init__(self, success=None, ex=None,):
21866 
    self.success = success
21867 
    self.ex = ex
21868 
 
21869 
  def read(self, iprot):
21870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21872 
      return
21873 
    iprot.readStructBegin()
21874 
    while True:
21875 
      (fname, ftype, fid) = iprot.readFieldBegin()
21876 
      if ftype == TType.STOP:
21877 
        break
21878 
      if fid == 0:
21879 
        if ftype == TType.BOOL:
21880 
          self.success = iprot.readBool();
21881 
        else:
21882 
          iprot.skip(ftype)
21883 
      elif fid == 1:
21884 
        if ftype == TType.STRUCT:
21885 
          self.ex = TransactionServiceException()
21886 
          self.ex.read(iprot)
21887 
        else:
21888 
          iprot.skip(ftype)
21889 
      else:
21890 
        iprot.skip(ftype)
21891 
      iprot.readFieldEnd()
21892 
    iprot.readStructEnd()
21893 
 
21894 
  def write(self, oprot):
21895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21897 
      return
21898 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21899 
    if self.success is not None:
21900 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21901 
      oprot.writeBool(self.success)
21902 
      oprot.writeFieldEnd()
21903 
    if self.ex is not None:
21904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21905 
      self.ex.write(oprot)
21906 
      oprot.writeFieldEnd()
21907 
    oprot.writeFieldStop()
21908 
    oprot.writeStructEnd()
21909 
 
21910 
  def validate(self):
21911 
    return
21912 
 
21913 
 
21914 
  def __repr__(self):
21915 
    L = ['%s=%r' % (key, value)
21916 
      for key, value in self.__dict__.iteritems()]
21917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21918 
 
21919 
  def __eq__(self, other):
21920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21921 
 
21922 
  def __ne__(self, other):
21923 
    return not (self == other)
21924 
 
4386 anupam.sin 21925 
class getOrderForAwb_args:
21926 
  """
21927 
  Attributes:
21928 
   - awb
21929 
  """
21930 
 
21931 
  thrift_spec = (
21932 
    None, # 0
21933 
    (1, TType.STRING, 'awb', None, None, ), # 1
21934 
  )
21935 
 
21936 
  def __init__(self, awb=None,):
21937 
    self.awb = awb
21938 
 
21939 
  def read(self, iprot):
21940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21942 
      return
21943 
    iprot.readStructBegin()
21944 
    while True:
21945 
      (fname, ftype, fid) = iprot.readFieldBegin()
21946 
      if ftype == TType.STOP:
21947 
        break
21948 
      if fid == 1:
21949 
        if ftype == TType.STRING:
21950 
          self.awb = iprot.readString();
21951 
        else:
21952 
          iprot.skip(ftype)
21953 
      else:
21954 
        iprot.skip(ftype)
21955 
      iprot.readFieldEnd()
21956 
    iprot.readStructEnd()
21957 
 
21958 
  def write(self, oprot):
21959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21961 
      return
21962 
    oprot.writeStructBegin('getOrderForAwb_args')
21963 
    if self.awb is not None:
21964 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21965 
      oprot.writeString(self.awb)
21966 
      oprot.writeFieldEnd()
21967 
    oprot.writeFieldStop()
21968 
    oprot.writeStructEnd()
21969 
 
21970 
  def validate(self):
21971 
    return
21972 
 
21973 
 
21974 
  def __repr__(self):
21975 
    L = ['%s=%r' % (key, value)
21976 
      for key, value in self.__dict__.iteritems()]
21977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21978 
 
21979 
  def __eq__(self, other):
21980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21981 
 
21982 
  def __ne__(self, other):
21983 
    return not (self == other)
21984 
 
21985 
class getOrderForAwb_result:
21986 
  """
21987 
  Attributes:
21988 
   - success
21989 
   - ex
21990 
  """
21991 
 
21992 
  thrift_spec = (
21993 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21995 
  )
21996 
 
21997 
  def __init__(self, success=None, ex=None,):
21998 
    self.success = success
21999 
    self.ex = ex
22000 
 
22001 
  def read(self, iprot):
22002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22004 
      return
22005 
    iprot.readStructBegin()
22006 
    while True:
22007 
      (fname, ftype, fid) = iprot.readFieldBegin()
22008 
      if ftype == TType.STOP:
22009 
        break
22010 
      if fid == 0:
22011 
        if ftype == TType.STRUCT:
22012 
          self.success = Order()
22013 
          self.success.read(iprot)
22014 
        else:
22015 
          iprot.skip(ftype)
22016 
      elif fid == 1:
22017 
        if ftype == TType.STRUCT:
22018 
          self.ex = TransactionServiceException()
22019 
          self.ex.read(iprot)
22020 
        else:
22021 
          iprot.skip(ftype)
22022 
      else:
22023 
        iprot.skip(ftype)
22024 
      iprot.readFieldEnd()
22025 
    iprot.readStructEnd()
22026 
 
22027 
  def write(self, oprot):
22028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22030 
      return
22031 
    oprot.writeStructBegin('getOrderForAwb_result')
22032 
    if self.success is not None:
22033 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22034 
      self.success.write(oprot)
22035 
      oprot.writeFieldEnd()
22036 
    if self.ex is not None:
22037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22038 
      self.ex.write(oprot)
22039 
      oprot.writeFieldEnd()
22040 
    oprot.writeFieldStop()
22041 
    oprot.writeStructEnd()
22042 
 
22043 
  def validate(self):
22044 
    return
22045 
 
22046 
 
22047 
  def __repr__(self):
22048 
    L = ['%s=%r' % (key, value)
22049 
      for key, value in self.__dict__.iteritems()]
22050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22051 
 
22052 
  def __eq__(self, other):
22053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22054 
 
22055 
  def __ne__(self, other):
22056 
    return not (self == other)
4506 phani.kuma 22057 
 
22058 
class getOrdersForProviderForStatus_args:
22059 
  """
22060 
  Attributes:
22061 
   - logistics_provider_id
4910 phani.kuma 22062 
   - order_status_list
4506 phani.kuma 22063 
  """
22064 
 
22065 
  thrift_spec = (
22066 
    None, # 0
22067 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22068 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22069 
  )
22070 
 
4910 phani.kuma 22071 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22072 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22073 
    self.order_status_list = order_status_list
4506 phani.kuma 22074 
 
22075 
  def read(self, iprot):
22076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22078 
      return
22079 
    iprot.readStructBegin()
22080 
    while True:
22081 
      (fname, ftype, fid) = iprot.readFieldBegin()
22082 
      if ftype == TType.STOP:
22083 
        break
22084 
      if fid == 1:
22085 
        if ftype == TType.I64:
22086 
          self.logistics_provider_id = iprot.readI64();
22087 
        else:
22088 
          iprot.skip(ftype)
22089 
      elif fid == 2:
4910 phani.kuma 22090 
        if ftype == TType.LIST:
22091 
          self.order_status_list = []
6188 rajveer 22092 
          (_etype513, _size510) = iprot.readListBegin()
22093 
          for _i514 in xrange(_size510):
22094 
            _elem515 = iprot.readI32();
22095 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22096 
          iprot.readListEnd()
4506 phani.kuma 22097 
        else:
22098 
          iprot.skip(ftype)
22099 
      else:
22100 
        iprot.skip(ftype)
22101 
      iprot.readFieldEnd()
22102 
    iprot.readStructEnd()
22103 
 
22104 
  def write(self, oprot):
22105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22107 
      return
22108 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22109 
    if self.logistics_provider_id is not None:
22110 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22111 
      oprot.writeI64(self.logistics_provider_id)
22112 
      oprot.writeFieldEnd()
4910 phani.kuma 22113 
    if self.order_status_list is not None:
22114 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22115 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22116 
      for iter516 in self.order_status_list:
22117 
        oprot.writeI32(iter516)
4910 phani.kuma 22118 
      oprot.writeListEnd()
4506 phani.kuma 22119 
      oprot.writeFieldEnd()
22120 
    oprot.writeFieldStop()
22121 
    oprot.writeStructEnd()
22122 
 
22123 
  def validate(self):
22124 
    return
22125 
 
22126 
 
22127 
  def __repr__(self):
22128 
    L = ['%s=%r' % (key, value)
22129 
      for key, value in self.__dict__.iteritems()]
22130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22131 
 
22132 
  def __eq__(self, other):
22133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22134 
 
22135 
  def __ne__(self, other):
22136 
    return not (self == other)
22137 
 
22138 
class getOrdersForProviderForStatus_result:
22139 
  """
22140 
  Attributes:
22141 
   - success
22142 
   - ex
22143 
  """
22144 
 
22145 
  thrift_spec = (
22146 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22147 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22148 
  )
22149 
 
22150 
  def __init__(self, success=None, ex=None,):
22151 
    self.success = success
22152 
    self.ex = ex
22153 
 
22154 
  def read(self, iprot):
22155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22157 
      return
22158 
    iprot.readStructBegin()
22159 
    while True:
22160 
      (fname, ftype, fid) = iprot.readFieldBegin()
22161 
      if ftype == TType.STOP:
22162 
        break
22163 
      if fid == 0:
22164 
        if ftype == TType.LIST:
22165 
          self.success = []
6188 rajveer 22166 
          (_etype520, _size517) = iprot.readListBegin()
22167 
          for _i521 in xrange(_size517):
22168 
            _elem522 = Order()
22169 
            _elem522.read(iprot)
22170 
            self.success.append(_elem522)
4506 phani.kuma 22171 
          iprot.readListEnd()
22172 
        else:
22173 
          iprot.skip(ftype)
22174 
      elif fid == 1:
22175 
        if ftype == TType.STRUCT:
22176 
          self.ex = TransactionServiceException()
22177 
          self.ex.read(iprot)
22178 
        else:
22179 
          iprot.skip(ftype)
22180 
      else:
22181 
        iprot.skip(ftype)
22182 
      iprot.readFieldEnd()
22183 
    iprot.readStructEnd()
22184 
 
22185 
  def write(self, oprot):
22186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22188 
      return
22189 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22190 
    if self.success is not None:
22191 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22192 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22193 
      for iter523 in self.success:
22194 
        iter523.write(oprot)
4506 phani.kuma 22195 
      oprot.writeListEnd()
22196 
      oprot.writeFieldEnd()
22197 
    if self.ex is not None:
22198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22199 
      self.ex.write(oprot)
22200 
      oprot.writeFieldEnd()
22201 
    oprot.writeFieldStop()
22202 
    oprot.writeStructEnd()
22203 
 
22204 
  def validate(self):
22205 
    return
22206 
 
22207 
 
22208 
  def __repr__(self):
22209 
    L = ['%s=%r' % (key, value)
22210 
      for key, value in self.__dict__.iteritems()]
22211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22212 
 
22213 
  def __eq__(self, other):
22214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22215 
 
22216 
  def __ne__(self, other):
22217 
    return not (self == other)
4600 varun.gupt 22218 
 
22219 
class getBilledOrdersForVendor_args:
22220 
  """
22221 
  Attributes:
22222 
   - vendorId
22223 
   - billingDateFrom
22224 
   - billingDateTo
22225 
  """
22226 
 
22227 
  thrift_spec = (
22228 
    None, # 0
22229 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22230 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22231 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22232 
  )
22233 
 
22234 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22235 
    self.vendorId = vendorId
22236 
    self.billingDateFrom = billingDateFrom
22237 
    self.billingDateTo = billingDateTo
22238 
 
22239 
  def read(self, iprot):
22240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22242 
      return
22243 
    iprot.readStructBegin()
22244 
    while True:
22245 
      (fname, ftype, fid) = iprot.readFieldBegin()
22246 
      if ftype == TType.STOP:
22247 
        break
22248 
      if fid == 1:
22249 
        if ftype == TType.I64:
22250 
          self.vendorId = iprot.readI64();
22251 
        else:
22252 
          iprot.skip(ftype)
22253 
      elif fid == 2:
22254 
        if ftype == TType.I64:
22255 
          self.billingDateFrom = iprot.readI64();
22256 
        else:
22257 
          iprot.skip(ftype)
22258 
      elif fid == 3:
22259 
        if ftype == TType.I64:
22260 
          self.billingDateTo = iprot.readI64();
22261 
        else:
22262 
          iprot.skip(ftype)
22263 
      else:
22264 
        iprot.skip(ftype)
22265 
      iprot.readFieldEnd()
22266 
    iprot.readStructEnd()
22267 
 
22268 
  def write(self, oprot):
22269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22271 
      return
22272 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22273 
    if self.vendorId is not None:
22274 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22275 
      oprot.writeI64(self.vendorId)
22276 
      oprot.writeFieldEnd()
22277 
    if self.billingDateFrom is not None:
22278 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22279 
      oprot.writeI64(self.billingDateFrom)
22280 
      oprot.writeFieldEnd()
22281 
    if self.billingDateTo is not None:
22282 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22283 
      oprot.writeI64(self.billingDateTo)
22284 
      oprot.writeFieldEnd()
22285 
    oprot.writeFieldStop()
22286 
    oprot.writeStructEnd()
22287 
 
22288 
  def validate(self):
22289 
    return
22290 
 
22291 
 
22292 
  def __repr__(self):
22293 
    L = ['%s=%r' % (key, value)
22294 
      for key, value in self.__dict__.iteritems()]
22295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22296 
 
22297 
  def __eq__(self, other):
22298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22299 
 
22300 
  def __ne__(self, other):
22301 
    return not (self == other)
22302 
 
22303 
class getBilledOrdersForVendor_result:
22304 
  """
22305 
  Attributes:
22306 
   - success
22307 
   - ex
22308 
  """
22309 
 
22310 
  thrift_spec = (
22311 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22312 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22313 
  )
22314 
 
22315 
  def __init__(self, success=None, ex=None,):
22316 
    self.success = success
22317 
    self.ex = ex
22318 
 
22319 
  def read(self, iprot):
22320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22322 
      return
22323 
    iprot.readStructBegin()
22324 
    while True:
22325 
      (fname, ftype, fid) = iprot.readFieldBegin()
22326 
      if ftype == TType.STOP:
22327 
        break
22328 
      if fid == 0:
22329 
        if ftype == TType.LIST:
22330 
          self.success = []
6188 rajveer 22331 
          (_etype527, _size524) = iprot.readListBegin()
22332 
          for _i528 in xrange(_size524):
22333 
            _elem529 = Order()
22334 
            _elem529.read(iprot)
22335 
            self.success.append(_elem529)
4600 varun.gupt 22336 
          iprot.readListEnd()
22337 
        else:
22338 
          iprot.skip(ftype)
22339 
      elif fid == 1:
22340 
        if ftype == TType.STRUCT:
22341 
          self.ex = TransactionServiceException()
22342 
          self.ex.read(iprot)
22343 
        else:
22344 
          iprot.skip(ftype)
22345 
      else:
22346 
        iprot.skip(ftype)
22347 
      iprot.readFieldEnd()
22348 
    iprot.readStructEnd()
22349 
 
22350 
  def write(self, oprot):
22351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22353 
      return
22354 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22355 
    if self.success is not None:
22356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22358 
      for iter530 in self.success:
22359 
        iter530.write(oprot)
4600 varun.gupt 22360 
      oprot.writeListEnd()
22361 
      oprot.writeFieldEnd()
22362 
    if self.ex is not None:
22363 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22364 
      self.ex.write(oprot)
22365 
      oprot.writeFieldEnd()
22366 
    oprot.writeFieldStop()
22367 
    oprot.writeStructEnd()
22368 
 
22369 
  def validate(self):
22370 
    return
22371 
 
22372 
 
22373 
  def __repr__(self):
22374 
    L = ['%s=%r' % (key, value)
22375 
      for key, value in self.__dict__.iteritems()]
22376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22377 
 
22378 
  def __eq__(self, other):
22379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22380 
 
22381 
  def __ne__(self, other):
22382 
    return not (self == other)
22383 
 
4607 rajveer 22384 
class getSlippedSippingDateOrders_args:
22385 
 
22386 
  thrift_spec = (
22387 
  )
22388 
 
22389 
  def read(self, iprot):
22390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22392 
      return
22393 
    iprot.readStructBegin()
22394 
    while True:
22395 
      (fname, ftype, fid) = iprot.readFieldBegin()
22396 
      if ftype == TType.STOP:
22397 
        break
22398 
      else:
22399 
        iprot.skip(ftype)
22400 
      iprot.readFieldEnd()
22401 
    iprot.readStructEnd()
22402 
 
22403 
  def write(self, oprot):
22404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22406 
      return
22407 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22408 
    oprot.writeFieldStop()
22409 
    oprot.writeStructEnd()
22410 
 
22411 
  def validate(self):
22412 
    return
22413 
 
22414 
 
22415 
  def __repr__(self):
22416 
    L = ['%s=%r' % (key, value)
22417 
      for key, value in self.__dict__.iteritems()]
22418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22419 
 
22420 
  def __eq__(self, other):
22421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22422 
 
22423 
  def __ne__(self, other):
22424 
    return not (self == other)
22425 
 
22426 
class getSlippedSippingDateOrders_result:
22427 
  """
22428 
  Attributes:
22429 
   - success
22430 
   - ex
22431 
  """
22432 
 
22433 
  thrift_spec = (
22434 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22436 
  )
22437 
 
22438 
  def __init__(self, success=None, ex=None,):
22439 
    self.success = success
22440 
    self.ex = ex
22441 
 
22442 
  def read(self, iprot):
22443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22445 
      return
22446 
    iprot.readStructBegin()
22447 
    while True:
22448 
      (fname, ftype, fid) = iprot.readFieldBegin()
22449 
      if ftype == TType.STOP:
22450 
        break
22451 
      if fid == 0:
22452 
        if ftype == TType.LIST:
22453 
          self.success = []
6188 rajveer 22454 
          (_etype534, _size531) = iprot.readListBegin()
22455 
          for _i535 in xrange(_size531):
22456 
            _elem536 = Order()
22457 
            _elem536.read(iprot)
22458 
            self.success.append(_elem536)
4607 rajveer 22459 
          iprot.readListEnd()
22460 
        else:
22461 
          iprot.skip(ftype)
22462 
      elif fid == 1:
22463 
        if ftype == TType.STRUCT:
22464 
          self.ex = TransactionServiceException()
22465 
          self.ex.read(iprot)
22466 
        else:
22467 
          iprot.skip(ftype)
22468 
      else:
22469 
        iprot.skip(ftype)
22470 
      iprot.readFieldEnd()
22471 
    iprot.readStructEnd()
22472 
 
22473 
  def write(self, oprot):
22474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22476 
      return
22477 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22478 
    if self.success is not None:
22479 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22480 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22481 
      for iter537 in self.success:
22482 
        iter537.write(oprot)
4607 rajveer 22483 
      oprot.writeListEnd()
22484 
      oprot.writeFieldEnd()
22485 
    if self.ex is not None:
22486 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22487 
      self.ex.write(oprot)
22488 
      oprot.writeFieldEnd()
22489 
    oprot.writeFieldStop()
22490 
    oprot.writeStructEnd()
22491 
 
22492 
  def validate(self):
22493 
    return
22494 
 
22495 
 
22496 
  def __repr__(self):
22497 
    L = ['%s=%r' % (key, value)
22498 
      for key, value in self.__dict__.iteritems()]
22499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22500 
 
22501 
  def __eq__(self, other):
22502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22503 
 
22504 
  def __ne__(self, other):
22505 
    return not (self == other)
22506 
 
4709 rajveer 22507 
class getCancelledOrders_args:
22508 
  """
22509 
  Attributes:
22510 
   - cancelDateFrom
22511 
   - cancelDateTo
22512 
  """
22513 
 
22514 
  thrift_spec = (
22515 
    None, # 0
22516 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22517 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22518 
  )
22519 
 
22520 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22521 
    self.cancelDateFrom = cancelDateFrom
22522 
    self.cancelDateTo = cancelDateTo
22523 
 
22524 
  def read(self, iprot):
22525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22527 
      return
22528 
    iprot.readStructBegin()
22529 
    while True:
22530 
      (fname, ftype, fid) = iprot.readFieldBegin()
22531 
      if ftype == TType.STOP:
22532 
        break
22533 
      if fid == 1:
22534 
        if ftype == TType.I64:
22535 
          self.cancelDateFrom = iprot.readI64();
22536 
        else:
22537 
          iprot.skip(ftype)
22538 
      elif fid == 2:
22539 
        if ftype == TType.I64:
22540 
          self.cancelDateTo = iprot.readI64();
22541 
        else:
22542 
          iprot.skip(ftype)
22543 
      else:
22544 
        iprot.skip(ftype)
22545 
      iprot.readFieldEnd()
22546 
    iprot.readStructEnd()
22547 
 
22548 
  def write(self, oprot):
22549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22551 
      return
22552 
    oprot.writeStructBegin('getCancelledOrders_args')
22553 
    if self.cancelDateFrom is not None:
22554 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22555 
      oprot.writeI64(self.cancelDateFrom)
22556 
      oprot.writeFieldEnd()
22557 
    if self.cancelDateTo is not None:
22558 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22559 
      oprot.writeI64(self.cancelDateTo)
22560 
      oprot.writeFieldEnd()
22561 
    oprot.writeFieldStop()
22562 
    oprot.writeStructEnd()
22563 
 
22564 
  def validate(self):
22565 
    return
22566 
 
22567 
 
22568 
  def __repr__(self):
22569 
    L = ['%s=%r' % (key, value)
22570 
      for key, value in self.__dict__.iteritems()]
22571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22572 
 
22573 
  def __eq__(self, other):
22574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22575 
 
22576 
  def __ne__(self, other):
22577 
    return not (self == other)
22578 
 
22579 
class getCancelledOrders_result:
22580 
  """
22581 
  Attributes:
22582 
   - success
22583 
   - ex
22584 
  """
22585 
 
22586 
  thrift_spec = (
22587 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22588 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22589 
  )
22590 
 
22591 
  def __init__(self, success=None, ex=None,):
22592 
    self.success = success
22593 
    self.ex = ex
22594 
 
22595 
  def read(self, iprot):
22596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22598 
      return
22599 
    iprot.readStructBegin()
22600 
    while True:
22601 
      (fname, ftype, fid) = iprot.readFieldBegin()
22602 
      if ftype == TType.STOP:
22603 
        break
22604 
      if fid == 0:
22605 
        if ftype == TType.LIST:
22606 
          self.success = []
6188 rajveer 22607 
          (_etype541, _size538) = iprot.readListBegin()
22608 
          for _i542 in xrange(_size538):
22609 
            _elem543 = Order()
22610 
            _elem543.read(iprot)
22611 
            self.success.append(_elem543)
4709 rajveer 22612 
          iprot.readListEnd()
22613 
        else:
22614 
          iprot.skip(ftype)
22615 
      elif fid == 1:
22616 
        if ftype == TType.STRUCT:
22617 
          self.ex = TransactionServiceException()
22618 
          self.ex.read(iprot)
22619 
        else:
22620 
          iprot.skip(ftype)
22621 
      else:
22622 
        iprot.skip(ftype)
22623 
      iprot.readFieldEnd()
22624 
    iprot.readStructEnd()
22625 
 
22626 
  def write(self, oprot):
22627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22629 
      return
22630 
    oprot.writeStructBegin('getCancelledOrders_result')
22631 
    if self.success is not None:
22632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22633 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22634 
      for iter544 in self.success:
22635 
        iter544.write(oprot)
4709 rajveer 22636 
      oprot.writeListEnd()
22637 
      oprot.writeFieldEnd()
22638 
    if self.ex is not None:
22639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22640 
      self.ex.write(oprot)
22641 
      oprot.writeFieldEnd()
22642 
    oprot.writeFieldStop()
22643 
    oprot.writeStructEnd()
22644 
 
22645 
  def validate(self):
22646 
    return
22647 
 
22648 
 
22649 
  def __repr__(self):
22650 
    L = ['%s=%r' % (key, value)
22651 
      for key, value in self.__dict__.iteritems()]
22652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22653 
 
22654 
  def __eq__(self, other):
22655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22656 
 
22657 
  def __ne__(self, other):
22658 
    return not (self == other)
22659 
 
4600 varun.gupt 22660 
class saveBluedartSettlements_args:
22661 
  """
22662 
  Attributes:
22663 
   - mapAWBAndAmount
22664 
  """
22665 
 
22666 
  thrift_spec = (
22667 
    None, # 0
22668 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22669 
  )
22670 
 
22671 
  def __init__(self, mapAWBAndAmount=None,):
22672 
    self.mapAWBAndAmount = mapAWBAndAmount
22673 
 
22674 
  def read(self, iprot):
22675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22677 
      return
22678 
    iprot.readStructBegin()
22679 
    while True:
22680 
      (fname, ftype, fid) = iprot.readFieldBegin()
22681 
      if ftype == TType.STOP:
22682 
        break
22683 
      if fid == 1:
22684 
        if ftype == TType.MAP:
22685 
          self.mapAWBAndAmount = {}
6188 rajveer 22686 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22687 
          for _i549 in xrange(_size545):
22688 
            _key550 = iprot.readI64();
22689 
            _val551 = iprot.readDouble();
22690 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22691 
          iprot.readMapEnd()
22692 
        else:
22693 
          iprot.skip(ftype)
22694 
      else:
22695 
        iprot.skip(ftype)
22696 
      iprot.readFieldEnd()
22697 
    iprot.readStructEnd()
22698 
 
22699 
  def write(self, oprot):
22700 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22701 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22702 
      return
22703 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22704 
    if self.mapAWBAndAmount is not None:
22705 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22706 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22707 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22708 
        oprot.writeI64(kiter552)
22709 
        oprot.writeDouble(viter553)
4600 varun.gupt 22710 
      oprot.writeMapEnd()
22711 
      oprot.writeFieldEnd()
22712 
    oprot.writeFieldStop()
22713 
    oprot.writeStructEnd()
22714 
 
22715 
  def validate(self):
22716 
    return
22717 
 
22718 
 
22719 
  def __repr__(self):
22720 
    L = ['%s=%r' % (key, value)
22721 
      for key, value in self.__dict__.iteritems()]
22722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22723 
 
22724 
  def __eq__(self, other):
22725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22726 
 
22727 
  def __ne__(self, other):
22728 
    return not (self == other)
22729 
 
22730 
class saveBluedartSettlements_result:
22731 
  """
22732 
  Attributes:
22733 
   - ex
22734 
  """
22735 
 
22736 
  thrift_spec = (
22737 
    None, # 0
22738 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22739 
  )
22740 
 
22741 
  def __init__(self, ex=None,):
22742 
    self.ex = ex
22743 
 
22744 
  def read(self, iprot):
22745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22747 
      return
22748 
    iprot.readStructBegin()
22749 
    while True:
22750 
      (fname, ftype, fid) = iprot.readFieldBegin()
22751 
      if ftype == TType.STOP:
22752 
        break
22753 
      if fid == 1:
22754 
        if ftype == TType.STRUCT:
22755 
          self.ex = TransactionServiceException()
22756 
          self.ex.read(iprot)
22757 
        else:
22758 
          iprot.skip(ftype)
22759 
      else:
22760 
        iprot.skip(ftype)
22761 
      iprot.readFieldEnd()
22762 
    iprot.readStructEnd()
22763 
 
22764 
  def write(self, oprot):
22765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22767 
      return
22768 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22769 
    if self.ex is not None:
22770 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22771 
      self.ex.write(oprot)
22772 
      oprot.writeFieldEnd()
22773 
    oprot.writeFieldStop()
22774 
    oprot.writeStructEnd()
22775 
 
22776 
  def validate(self):
22777 
    return
22778 
 
22779 
 
22780 
  def __repr__(self):
22781 
    L = ['%s=%r' % (key, value)
22782 
      for key, value in self.__dict__.iteritems()]
22783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22784 
 
22785 
  def __eq__(self, other):
22786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22787 
 
22788 
  def __ne__(self, other):
22789 
    return not (self == other)
22790 
 
22791 
class savePaymentSettlements_args:
22792 
  """
22793 
  Attributes:
22794 
   - settlementDate
22795 
   - paymentGatewayId
4905 varun.gupt 22796 
   - referenceId
4600 varun.gupt 22797 
   - serviceTax
22798 
   - otherCharges
22799 
   - netCollection
22800 
  """
22801 
 
22802 
  thrift_spec = (
22803 
    None, # 0
22804 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22805 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22806 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22807 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22808 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22809 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22810 
  )
22811 
 
4905 varun.gupt 22812 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22813 
    self.settlementDate = settlementDate
22814 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22815 
    self.referenceId = referenceId
4600 varun.gupt 22816 
    self.serviceTax = serviceTax
22817 
    self.otherCharges = otherCharges
22818 
    self.netCollection = netCollection
22819 
 
22820 
  def read(self, iprot):
22821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22823 
      return
22824 
    iprot.readStructBegin()
22825 
    while True:
22826 
      (fname, ftype, fid) = iprot.readFieldBegin()
22827 
      if ftype == TType.STOP:
22828 
        break
22829 
      if fid == 1:
22830 
        if ftype == TType.I64:
22831 
          self.settlementDate = iprot.readI64();
22832 
        else:
22833 
          iprot.skip(ftype)
22834 
      elif fid == 2:
22835 
        if ftype == TType.I64:
22836 
          self.paymentGatewayId = iprot.readI64();
22837 
        else:
22838 
          iprot.skip(ftype)
22839 
      elif fid == 3:
22840 
        if ftype == TType.I64:
4905 varun.gupt 22841 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22842 
        else:
22843 
          iprot.skip(ftype)
22844 
      elif fid == 4:
22845 
        if ftype == TType.DOUBLE:
22846 
          self.serviceTax = iprot.readDouble();
22847 
        else:
22848 
          iprot.skip(ftype)
22849 
      elif fid == 5:
22850 
        if ftype == TType.DOUBLE:
22851 
          self.otherCharges = iprot.readDouble();
22852 
        else:
22853 
          iprot.skip(ftype)
22854 
      elif fid == 6:
22855 
        if ftype == TType.DOUBLE:
22856 
          self.netCollection = iprot.readDouble();
22857 
        else:
22858 
          iprot.skip(ftype)
22859 
      else:
22860 
        iprot.skip(ftype)
22861 
      iprot.readFieldEnd()
22862 
    iprot.readStructEnd()
22863 
 
22864 
  def write(self, oprot):
22865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22867 
      return
22868 
    oprot.writeStructBegin('savePaymentSettlements_args')
22869 
    if self.settlementDate is not None:
22870 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22871 
      oprot.writeI64(self.settlementDate)
22872 
      oprot.writeFieldEnd()
22873 
    if self.paymentGatewayId is not None:
22874 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22875 
      oprot.writeI64(self.paymentGatewayId)
22876 
      oprot.writeFieldEnd()
4905 varun.gupt 22877 
    if self.referenceId is not None:
22878 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22879 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22880 
      oprot.writeFieldEnd()
22881 
    if self.serviceTax is not None:
22882 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22883 
      oprot.writeDouble(self.serviceTax)
22884 
      oprot.writeFieldEnd()
22885 
    if self.otherCharges is not None:
22886 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22887 
      oprot.writeDouble(self.otherCharges)
22888 
      oprot.writeFieldEnd()
22889 
    if self.netCollection is not None:
22890 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22891 
      oprot.writeDouble(self.netCollection)
22892 
      oprot.writeFieldEnd()
22893 
    oprot.writeFieldStop()
22894 
    oprot.writeStructEnd()
22895 
 
22896 
  def validate(self):
22897 
    return
22898 
 
22899 
 
22900 
  def __repr__(self):
22901 
    L = ['%s=%r' % (key, value)
22902 
      for key, value in self.__dict__.iteritems()]
22903 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22904 
 
22905 
  def __eq__(self, other):
22906 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22907 
 
22908 
  def __ne__(self, other):
22909 
    return not (self == other)
22910 
 
22911 
class savePaymentSettlements_result:
22912 
  """
22913 
  Attributes:
22914 
   - ex
22915 
  """
22916 
 
22917 
  thrift_spec = (
22918 
    None, # 0
22919 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22920 
  )
22921 
 
22922 
  def __init__(self, ex=None,):
22923 
    self.ex = ex
22924 
 
22925 
  def read(self, iprot):
22926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22928 
      return
22929 
    iprot.readStructBegin()
22930 
    while True:
22931 
      (fname, ftype, fid) = iprot.readFieldBegin()
22932 
      if ftype == TType.STOP:
22933 
        break
22934 
      if fid == 1:
22935 
        if ftype == TType.STRUCT:
22936 
          self.ex = TransactionServiceException()
22937 
          self.ex.read(iprot)
22938 
        else:
22939 
          iprot.skip(ftype)
22940 
      else:
22941 
        iprot.skip(ftype)
22942 
      iprot.readFieldEnd()
22943 
    iprot.readStructEnd()
22944 
 
22945 
  def write(self, oprot):
22946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22948 
      return
22949 
    oprot.writeStructBegin('savePaymentSettlements_result')
22950 
    if self.ex is not None:
22951 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22952 
      self.ex.write(oprot)
22953 
      oprot.writeFieldEnd()
22954 
    oprot.writeFieldStop()
22955 
    oprot.writeStructEnd()
22956 
 
22957 
  def validate(self):
22958 
    return
22959 
 
22960 
 
22961 
  def __repr__(self):
22962 
    L = ['%s=%r' % (key, value)
22963 
      for key, value in self.__dict__.iteritems()]
22964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22965 
 
22966 
  def __eq__(self, other):
22967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22968 
 
22969 
  def __ne__(self, other):
22970 
    return not (self == other)
22971 
 
22972 
class saveEBSSettlementSummary_args:
22973 
  """
22974 
  Attributes:
22975 
   - settlementId
22976 
   - settlementDate
22977 
   - transactionDateFrom
22978 
   - transactionDateTo
22979 
   - amount
22980 
  """
22981 
 
22982 
  thrift_spec = (
22983 
    None, # 0
22984 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22985 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22986 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22987 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22988 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22989 
  )
22990 
 
22991 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22992 
    self.settlementId = settlementId
22993 
    self.settlementDate = settlementDate
22994 
    self.transactionDateFrom = transactionDateFrom
22995 
    self.transactionDateTo = transactionDateTo
22996 
    self.amount = amount
22997 
 
22998 
  def read(self, iprot):
22999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23001 
      return
23002 
    iprot.readStructBegin()
23003 
    while True:
23004 
      (fname, ftype, fid) = iprot.readFieldBegin()
23005 
      if ftype == TType.STOP:
23006 
        break
23007 
      if fid == 1:
23008 
        if ftype == TType.I64:
23009 
          self.settlementId = iprot.readI64();
23010 
        else:
23011 
          iprot.skip(ftype)
23012 
      elif fid == 2:
23013 
        if ftype == TType.I64:
23014 
          self.settlementDate = iprot.readI64();
23015 
        else:
23016 
          iprot.skip(ftype)
23017 
      elif fid == 3:
23018 
        if ftype == TType.I64:
23019 
          self.transactionDateFrom = iprot.readI64();
23020 
        else:
23021 
          iprot.skip(ftype)
23022 
      elif fid == 4:
23023 
        if ftype == TType.I64:
23024 
          self.transactionDateTo = iprot.readI64();
23025 
        else:
23026 
          iprot.skip(ftype)
23027 
      elif fid == 5:
23028 
        if ftype == TType.DOUBLE:
23029 
          self.amount = iprot.readDouble();
23030 
        else:
23031 
          iprot.skip(ftype)
23032 
      else:
23033 
        iprot.skip(ftype)
23034 
      iprot.readFieldEnd()
23035 
    iprot.readStructEnd()
23036 
 
23037 
  def write(self, oprot):
23038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23040 
      return
23041 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23042 
    if self.settlementId is not None:
23043 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23044 
      oprot.writeI64(self.settlementId)
23045 
      oprot.writeFieldEnd()
23046 
    if self.settlementDate is not None:
23047 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23048 
      oprot.writeI64(self.settlementDate)
23049 
      oprot.writeFieldEnd()
23050 
    if self.transactionDateFrom is not None:
23051 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23052 
      oprot.writeI64(self.transactionDateFrom)
23053 
      oprot.writeFieldEnd()
23054 
    if self.transactionDateTo is not None:
23055 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23056 
      oprot.writeI64(self.transactionDateTo)
23057 
      oprot.writeFieldEnd()
23058 
    if self.amount is not None:
23059 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23060 
      oprot.writeDouble(self.amount)
23061 
      oprot.writeFieldEnd()
23062 
    oprot.writeFieldStop()
23063 
    oprot.writeStructEnd()
23064 
 
23065 
  def validate(self):
23066 
    return
23067 
 
23068 
 
23069 
  def __repr__(self):
23070 
    L = ['%s=%r' % (key, value)
23071 
      for key, value in self.__dict__.iteritems()]
23072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23073 
 
23074 
  def __eq__(self, other):
23075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23076 
 
23077 
  def __ne__(self, other):
23078 
    return not (self == other)
23079 
 
23080 
class saveEBSSettlementSummary_result:
23081 
  """
23082 
  Attributes:
23083 
   - ex
23084 
  """
23085 
 
23086 
  thrift_spec = (
23087 
    None, # 0
23088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23089 
  )
23090 
 
23091 
  def __init__(self, ex=None,):
23092 
    self.ex = ex
23093 
 
23094 
  def read(self, iprot):
23095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23097 
      return
23098 
    iprot.readStructBegin()
23099 
    while True:
23100 
      (fname, ftype, fid) = iprot.readFieldBegin()
23101 
      if ftype == TType.STOP:
23102 
        break
23103 
      if fid == 1:
23104 
        if ftype == TType.STRUCT:
23105 
          self.ex = TransactionServiceException()
23106 
          self.ex.read(iprot)
23107 
        else:
23108 
          iprot.skip(ftype)
23109 
      else:
23110 
        iprot.skip(ftype)
23111 
      iprot.readFieldEnd()
23112 
    iprot.readStructEnd()
23113 
 
23114 
  def write(self, oprot):
23115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23117 
      return
23118 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23119 
    if self.ex is not None:
23120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23121 
      self.ex.write(oprot)
23122 
      oprot.writeFieldEnd()
23123 
    oprot.writeFieldStop()
23124 
    oprot.writeStructEnd()
23125 
 
23126 
  def validate(self):
23127 
    return
23128 
 
23129 
 
23130 
  def __repr__(self):
23131 
    L = ['%s=%r' % (key, value)
23132 
      for key, value in self.__dict__.iteritems()]
23133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23134 
 
23135 
  def __eq__(self, other):
23136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23137 
 
23138 
  def __ne__(self, other):
23139 
    return not (self == other)
23140 
 
5386 phani.kuma 23141 
class getSettlementForPrepaid_args:
4600 varun.gupt 23142 
  """
23143 
  Attributes:
5189 varun.gupt 23144 
   - referenceId
23145 
   - isRefund
4600 varun.gupt 23146 
  """
23147 
 
23148 
  thrift_spec = (
23149 
    None, # 0
5189 varun.gupt 23150 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23151 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23152 
  )
23153 
 
5386 phani.kuma 23154 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23155 
    self.referenceId = referenceId
23156 
    self.isRefund = isRefund
4600 varun.gupt 23157 
 
23158 
  def read(self, iprot):
23159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23161 
      return
23162 
    iprot.readStructBegin()
23163 
    while True:
23164 
      (fname, ftype, fid) = iprot.readFieldBegin()
23165 
      if ftype == TType.STOP:
23166 
        break
23167 
      if fid == 1:
23168 
        if ftype == TType.I64:
5189 varun.gupt 23169 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23170 
        else:
23171 
          iprot.skip(ftype)
5189 varun.gupt 23172 
      elif fid == 2:
23173 
        if ftype == TType.BOOL:
23174 
          self.isRefund = iprot.readBool();
23175 
        else:
23176 
          iprot.skip(ftype)
4600 varun.gupt 23177 
      else:
23178 
        iprot.skip(ftype)
23179 
      iprot.readFieldEnd()
23180 
    iprot.readStructEnd()
23181 
 
23182 
  def write(self, oprot):
23183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23185 
      return
5386 phani.kuma 23186 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23187 
    if self.referenceId is not None:
23188 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23189 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23190 
      oprot.writeFieldEnd()
5386 phani.kuma 23191 
    if self.isRefund is not None:
23192 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23193 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23194 
      oprot.writeFieldEnd()
5386 phani.kuma 23195 
    oprot.writeFieldStop()
23196 
    oprot.writeStructEnd()
23197 
 
23198 
  def validate(self):
23199 
    return
23200 
 
23201 
 
23202 
  def __repr__(self):
23203 
    L = ['%s=%r' % (key, value)
23204 
      for key, value in self.__dict__.iteritems()]
23205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23206 
 
23207 
  def __eq__(self, other):
23208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23209 
 
23210 
  def __ne__(self, other):
23211 
    return not (self == other)
23212 
 
23213 
class getSettlementForPrepaid_result:
23214 
  """
23215 
  Attributes:
23216 
   - success
23217 
   - ex
23218 
  """
23219 
 
23220 
  thrift_spec = (
23221 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23222 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23223 
  )
23224 
 
23225 
  def __init__(self, success=None, ex=None,):
23226 
    self.success = success
23227 
    self.ex = ex
23228 
 
23229 
  def read(self, iprot):
23230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23232 
      return
23233 
    iprot.readStructBegin()
23234 
    while True:
23235 
      (fname, ftype, fid) = iprot.readFieldBegin()
23236 
      if ftype == TType.STOP:
23237 
        break
23238 
      if fid == 0:
23239 
        if ftype == TType.STRUCT:
23240 
          self.success = PaymentSettlement()
23241 
          self.success.read(iprot)
23242 
        else:
23243 
          iprot.skip(ftype)
23244 
      elif fid == 1:
23245 
        if ftype == TType.STRUCT:
23246 
          self.ex = TransactionServiceException()
23247 
          self.ex.read(iprot)
23248 
        else:
23249 
          iprot.skip(ftype)
23250 
      else:
23251 
        iprot.skip(ftype)
23252 
      iprot.readFieldEnd()
23253 
    iprot.readStructEnd()
23254 
 
23255 
  def write(self, oprot):
23256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23258 
      return
23259 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23260 
    if self.success is not None:
23261 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23262 
      self.success.write(oprot)
23263 
      oprot.writeFieldEnd()
23264 
    if self.ex is not None:
23265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23266 
      self.ex.write(oprot)
23267 
      oprot.writeFieldEnd()
23268 
    oprot.writeFieldStop()
23269 
    oprot.writeStructEnd()
23270 
 
23271 
  def validate(self):
23272 
    return
23273 
 
23274 
 
23275 
  def __repr__(self):
23276 
    L = ['%s=%r' % (key, value)
23277 
      for key, value in self.__dict__.iteritems()]
23278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23279 
 
23280 
  def __eq__(self, other):
23281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23282 
 
23283 
  def __ne__(self, other):
23284 
    return not (self == other)
23285 
 
23286 
class getSettlementForCod_args:
23287 
  """
23288 
  Attributes:
23289 
   - orderId
23290 
   - isRefund
23291 
  """
23292 
 
23293 
  thrift_spec = (
23294 
    None, # 0
23295 
    (1, TType.I64, 'orderId', None, None, ), # 1
23296 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23297 
  )
23298 
 
23299 
  def __init__(self, orderId=None, isRefund=None,):
23300 
    self.orderId = orderId
23301 
    self.isRefund = isRefund
23302 
 
23303 
  def read(self, iprot):
23304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23306 
      return
23307 
    iprot.readStructBegin()
23308 
    while True:
23309 
      (fname, ftype, fid) = iprot.readFieldBegin()
23310 
      if ftype == TType.STOP:
23311 
        break
23312 
      if fid == 1:
23313 
        if ftype == TType.I64:
23314 
          self.orderId = iprot.readI64();
23315 
        else:
23316 
          iprot.skip(ftype)
23317 
      elif fid == 2:
23318 
        if ftype == TType.BOOL:
23319 
          self.isRefund = iprot.readBool();
23320 
        else:
23321 
          iprot.skip(ftype)
23322 
      else:
23323 
        iprot.skip(ftype)
23324 
      iprot.readFieldEnd()
23325 
    iprot.readStructEnd()
23326 
 
23327 
  def write(self, oprot):
23328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23330 
      return
23331 
    oprot.writeStructBegin('getSettlementForCod_args')
23332 
    if self.orderId is not None:
23333 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23334 
      oprot.writeI64(self.orderId)
23335 
      oprot.writeFieldEnd()
5189 varun.gupt 23336 
    if self.isRefund is not None:
5386 phani.kuma 23337 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23338 
      oprot.writeBool(self.isRefund)
23339 
      oprot.writeFieldEnd()
4600 varun.gupt 23340 
    oprot.writeFieldStop()
23341 
    oprot.writeStructEnd()
23342 
 
23343 
  def validate(self):
23344 
    return
23345 
 
23346 
 
23347 
  def __repr__(self):
23348 
    L = ['%s=%r' % (key, value)
23349 
      for key, value in self.__dict__.iteritems()]
23350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23351 
 
23352 
  def __eq__(self, other):
23353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23354 
 
23355 
  def __ne__(self, other):
23356 
    return not (self == other)
23357 
 
5386 phani.kuma 23358 
class getSettlementForCod_result:
4600 varun.gupt 23359 
  """
23360 
  Attributes:
23361 
   - success
23362 
   - ex
23363 
  """
23364 
 
23365 
  thrift_spec = (
23366 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23367 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23368 
  )
23369 
 
23370 
  def __init__(self, success=None, ex=None,):
23371 
    self.success = success
23372 
    self.ex = ex
23373 
 
23374 
  def read(self, iprot):
23375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23377 
      return
23378 
    iprot.readStructBegin()
23379 
    while True:
23380 
      (fname, ftype, fid) = iprot.readFieldBegin()
23381 
      if ftype == TType.STOP:
23382 
        break
23383 
      if fid == 0:
23384 
        if ftype == TType.STRUCT:
23385 
          self.success = PaymentSettlement()
23386 
          self.success.read(iprot)
23387 
        else:
23388 
          iprot.skip(ftype)
23389 
      elif fid == 1:
23390 
        if ftype == TType.STRUCT:
23391 
          self.ex = TransactionServiceException()
23392 
          self.ex.read(iprot)
23393 
        else:
23394 
          iprot.skip(ftype)
23395 
      else:
23396 
        iprot.skip(ftype)
23397 
      iprot.readFieldEnd()
23398 
    iprot.readStructEnd()
23399 
 
23400 
  def write(self, oprot):
23401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23403 
      return
5386 phani.kuma 23404 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23405 
    if self.success is not None:
23406 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23407 
      self.success.write(oprot)
23408 
      oprot.writeFieldEnd()
23409 
    if self.ex is not None:
23410 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23411 
      self.ex.write(oprot)
23412 
      oprot.writeFieldEnd()
23413 
    oprot.writeFieldStop()
23414 
    oprot.writeStructEnd()
23415 
 
23416 
  def validate(self):
23417 
    return
23418 
 
23419 
 
23420 
  def __repr__(self):
23421 
    L = ['%s=%r' % (key, value)
23422 
      for key, value in self.__dict__.iteritems()]
23423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23424 
 
23425 
  def __eq__(self, other):
23426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23427 
 
23428 
  def __ne__(self, other):
23429 
    return not (self == other)
23430 
 
23431 
class getEBSSettlementSummaries_args:
23432 
 
23433 
  thrift_spec = (
23434 
  )
23435 
 
23436 
  def read(self, iprot):
23437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23439 
      return
23440 
    iprot.readStructBegin()
23441 
    while True:
23442 
      (fname, ftype, fid) = iprot.readFieldBegin()
23443 
      if ftype == TType.STOP:
23444 
        break
23445 
      else:
23446 
        iprot.skip(ftype)
23447 
      iprot.readFieldEnd()
23448 
    iprot.readStructEnd()
23449 
 
23450 
  def write(self, oprot):
23451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23453 
      return
23454 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23455 
    oprot.writeFieldStop()
23456 
    oprot.writeStructEnd()
23457 
 
23458 
  def validate(self):
23459 
    return
23460 
 
23461 
 
23462 
  def __repr__(self):
23463 
    L = ['%s=%r' % (key, value)
23464 
      for key, value in self.__dict__.iteritems()]
23465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23466 
 
23467 
  def __eq__(self, other):
23468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23469 
 
23470 
  def __ne__(self, other):
23471 
    return not (self == other)
23472 
 
23473 
class getEBSSettlementSummaries_result:
23474 
  """
23475 
  Attributes:
23476 
   - success
23477 
   - ex
23478 
  """
23479 
 
23480 
  thrift_spec = (
23481 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23483 
  )
23484 
 
23485 
  def __init__(self, success=None, ex=None,):
23486 
    self.success = success
23487 
    self.ex = ex
23488 
 
23489 
  def read(self, iprot):
23490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23492 
      return
23493 
    iprot.readStructBegin()
23494 
    while True:
23495 
      (fname, ftype, fid) = iprot.readFieldBegin()
23496 
      if ftype == TType.STOP:
23497 
        break
23498 
      if fid == 0:
23499 
        if ftype == TType.MAP:
23500 
          self.success = {}
6188 rajveer 23501 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23502 
          for _i558 in xrange(_size554):
23503 
            _key559 = iprot.readI64();
23504 
            _val560 = iprot.readString();
23505 
            self.success[_key559] = _val560
4600 varun.gupt 23506 
          iprot.readMapEnd()
23507 
        else:
23508 
          iprot.skip(ftype)
23509 
      elif fid == 1:
23510 
        if ftype == TType.STRUCT:
23511 
          self.ex = TransactionServiceException()
23512 
          self.ex.read(iprot)
23513 
        else:
23514 
          iprot.skip(ftype)
23515 
      else:
23516 
        iprot.skip(ftype)
23517 
      iprot.readFieldEnd()
23518 
    iprot.readStructEnd()
23519 
 
23520 
  def write(self, oprot):
23521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23523 
      return
23524 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23525 
    if self.success is not None:
23526 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23527 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23528 
      for kiter561,viter562 in self.success.items():
23529 
        oprot.writeI64(kiter561)
23530 
        oprot.writeString(viter562)
4600 varun.gupt 23531 
      oprot.writeMapEnd()
23532 
      oprot.writeFieldEnd()
23533 
    if self.ex is not None:
23534 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23535 
      self.ex.write(oprot)
23536 
      oprot.writeFieldEnd()
23537 
    oprot.writeFieldStop()
23538 
    oprot.writeStructEnd()
23539 
 
23540 
  def validate(self):
23541 
    return
23542 
 
23543 
 
23544 
  def __repr__(self):
23545 
    L = ['%s=%r' % (key, value)
23546 
      for key, value in self.__dict__.iteritems()]
23547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23548 
 
23549 
  def __eq__(self, other):
23550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23551 
 
23552 
  def __ne__(self, other):
23553 
    return not (self == other)
23554 
 
23555 
class markEBSSettlementUploaded_args:
23556 
  """
23557 
  Attributes:
23558 
   - settlementId
23559 
  """
23560 
 
23561 
  thrift_spec = (
23562 
    None, # 0
23563 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23564 
  )
23565 
 
23566 
  def __init__(self, settlementId=None,):
23567 
    self.settlementId = settlementId
23568 
 
23569 
  def read(self, iprot):
23570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23572 
      return
23573 
    iprot.readStructBegin()
23574 
    while True:
23575 
      (fname, ftype, fid) = iprot.readFieldBegin()
23576 
      if ftype == TType.STOP:
23577 
        break
23578 
      if fid == 1:
23579 
        if ftype == TType.I64:
23580 
          self.settlementId = iprot.readI64();
23581 
        else:
23582 
          iprot.skip(ftype)
23583 
      else:
23584 
        iprot.skip(ftype)
23585 
      iprot.readFieldEnd()
23586 
    iprot.readStructEnd()
23587 
 
23588 
  def write(self, oprot):
23589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23591 
      return
23592 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23593 
    if self.settlementId is not None:
23594 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23595 
      oprot.writeI64(self.settlementId)
23596 
      oprot.writeFieldEnd()
23597 
    oprot.writeFieldStop()
23598 
    oprot.writeStructEnd()
23599 
 
23600 
  def validate(self):
23601 
    return
23602 
 
23603 
 
23604 
  def __repr__(self):
23605 
    L = ['%s=%r' % (key, value)
23606 
      for key, value in self.__dict__.iteritems()]
23607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23608 
 
23609 
  def __eq__(self, other):
23610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23611 
 
23612 
  def __ne__(self, other):
23613 
    return not (self == other)
23614 
 
23615 
class markEBSSettlementUploaded_result:
23616 
  """
23617 
  Attributes:
23618 
   - ex
23619 
  """
23620 
 
23621 
  thrift_spec = (
23622 
    None, # 0
23623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23624 
  )
23625 
 
23626 
  def __init__(self, ex=None,):
23627 
    self.ex = ex
23628 
 
23629 
  def read(self, iprot):
23630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23632 
      return
23633 
    iprot.readStructBegin()
23634 
    while True:
23635 
      (fname, ftype, fid) = iprot.readFieldBegin()
23636 
      if ftype == TType.STOP:
23637 
        break
23638 
      if fid == 1:
23639 
        if ftype == TType.STRUCT:
23640 
          self.ex = TransactionServiceException()
23641 
          self.ex.read(iprot)
23642 
        else:
23643 
          iprot.skip(ftype)
23644 
      else:
23645 
        iprot.skip(ftype)
23646 
      iprot.readFieldEnd()
23647 
    iprot.readStructEnd()
23648 
 
23649 
  def write(self, oprot):
23650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23652 
      return
23653 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23654 
    if self.ex is not None:
23655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23656 
      self.ex.write(oprot)
23657 
      oprot.writeFieldEnd()
23658 
    oprot.writeFieldStop()
23659 
    oprot.writeStructEnd()
23660 
 
23661 
  def validate(self):
23662 
    return
23663 
 
23664 
 
23665 
  def __repr__(self):
23666 
    L = ['%s=%r' % (key, value)
23667 
      for key, value in self.__dict__.iteritems()]
23668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23669 
 
23670 
  def __eq__(self, other):
23671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23672 
 
23673 
  def __ne__(self, other):
23674 
    return not (self == other)
23675 
 
23676 
class getEBSSettlementDate_args:
23677 
  """
23678 
  Attributes:
23679 
   - settlementId
23680 
  """
23681 
 
23682 
  thrift_spec = (
23683 
    None, # 0
23684 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23685 
  )
23686 
 
23687 
  def __init__(self, settlementId=None,):
23688 
    self.settlementId = settlementId
23689 
 
23690 
  def read(self, iprot):
23691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23693 
      return
23694 
    iprot.readStructBegin()
23695 
    while True:
23696 
      (fname, ftype, fid) = iprot.readFieldBegin()
23697 
      if ftype == TType.STOP:
23698 
        break
23699 
      if fid == 1:
23700 
        if ftype == TType.I64:
23701 
          self.settlementId = iprot.readI64();
23702 
        else:
23703 
          iprot.skip(ftype)
23704 
      else:
23705 
        iprot.skip(ftype)
23706 
      iprot.readFieldEnd()
23707 
    iprot.readStructEnd()
23708 
 
23709 
  def write(self, oprot):
23710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23712 
      return
23713 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23714 
    if self.settlementId is not None:
23715 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23716 
      oprot.writeI64(self.settlementId)
23717 
      oprot.writeFieldEnd()
23718 
    oprot.writeFieldStop()
23719 
    oprot.writeStructEnd()
23720 
 
23721 
  def validate(self):
23722 
    return
23723 
 
23724 
 
23725 
  def __repr__(self):
23726 
    L = ['%s=%r' % (key, value)
23727 
      for key, value in self.__dict__.iteritems()]
23728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23729 
 
23730 
  def __eq__(self, other):
23731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23732 
 
23733 
  def __ne__(self, other):
23734 
    return not (self == other)
23735 
 
23736 
class getEBSSettlementDate_result:
23737 
  """
23738 
  Attributes:
23739 
   - success
23740 
   - ex
23741 
  """
23742 
 
23743 
  thrift_spec = (
23744 
    (0, TType.I64, 'success', None, None, ), # 0
23745 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23746 
  )
23747 
 
23748 
  def __init__(self, success=None, ex=None,):
23749 
    self.success = success
23750 
    self.ex = ex
23751 
 
23752 
  def read(self, iprot):
23753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23755 
      return
23756 
    iprot.readStructBegin()
23757 
    while True:
23758 
      (fname, ftype, fid) = iprot.readFieldBegin()
23759 
      if ftype == TType.STOP:
23760 
        break
23761 
      if fid == 0:
23762 
        if ftype == TType.I64:
23763 
          self.success = iprot.readI64();
23764 
        else:
23765 
          iprot.skip(ftype)
23766 
      elif fid == 1:
23767 
        if ftype == TType.STRUCT:
23768 
          self.ex = TransactionServiceException()
23769 
          self.ex.read(iprot)
23770 
        else:
23771 
          iprot.skip(ftype)
23772 
      else:
23773 
        iprot.skip(ftype)
23774 
      iprot.readFieldEnd()
23775 
    iprot.readStructEnd()
23776 
 
23777 
  def write(self, oprot):
23778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23780 
      return
23781 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23782 
    if self.success is not None:
23783 
      oprot.writeFieldBegin('success', TType.I64, 0)
23784 
      oprot.writeI64(self.success)
23785 
      oprot.writeFieldEnd()
23786 
    if self.ex is not None:
23787 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23788 
      self.ex.write(oprot)
23789 
      oprot.writeFieldEnd()
23790 
    oprot.writeFieldStop()
23791 
    oprot.writeStructEnd()
23792 
 
23793 
  def validate(self):
23794 
    return
23795 
 
23796 
 
23797 
  def __repr__(self):
23798 
    L = ['%s=%r' % (key, value)
23799 
      for key, value in self.__dict__.iteritems()]
23800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23801 
 
23802 
  def __eq__(self, other):
23803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23804 
 
23805 
  def __ne__(self, other):
23806 
    return not (self == other)
4715 varun.gupt 23807 
 
23808 
class getSettlementsByDate_args:
23809 
  """
23810 
  Attributes:
23811 
   - settlementDateFrom
23812 
   - settlementDateTo
23813 
   - isRefund
23814 
  """
23815 
 
23816 
  thrift_spec = (
23817 
    None, # 0
23818 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23819 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23820 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23821 
  )
23822 
 
23823 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23824 
    self.settlementDateFrom = settlementDateFrom
23825 
    self.settlementDateTo = settlementDateTo
23826 
    self.isRefund = isRefund
23827 
 
23828 
  def read(self, iprot):
23829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23831 
      return
23832 
    iprot.readStructBegin()
23833 
    while True:
23834 
      (fname, ftype, fid) = iprot.readFieldBegin()
23835 
      if ftype == TType.STOP:
23836 
        break
23837 
      if fid == 1:
23838 
        if ftype == TType.I64:
23839 
          self.settlementDateFrom = iprot.readI64();
23840 
        else:
23841 
          iprot.skip(ftype)
23842 
      elif fid == 2:
23843 
        if ftype == TType.I64:
23844 
          self.settlementDateTo = iprot.readI64();
23845 
        else:
23846 
          iprot.skip(ftype)
23847 
      elif fid == 3:
23848 
        if ftype == TType.BOOL:
23849 
          self.isRefund = iprot.readBool();
23850 
        else:
23851 
          iprot.skip(ftype)
23852 
      else:
23853 
        iprot.skip(ftype)
23854 
      iprot.readFieldEnd()
23855 
    iprot.readStructEnd()
23856 
 
23857 
  def write(self, oprot):
23858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23860 
      return
23861 
    oprot.writeStructBegin('getSettlementsByDate_args')
23862 
    if self.settlementDateFrom is not None:
23863 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23864 
      oprot.writeI64(self.settlementDateFrom)
23865 
      oprot.writeFieldEnd()
23866 
    if self.settlementDateTo is not None:
23867 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23868 
      oprot.writeI64(self.settlementDateTo)
23869 
      oprot.writeFieldEnd()
23870 
    if self.isRefund is not None:
23871 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23872 
      oprot.writeBool(self.isRefund)
23873 
      oprot.writeFieldEnd()
23874 
    oprot.writeFieldStop()
23875 
    oprot.writeStructEnd()
23876 
 
23877 
  def validate(self):
23878 
    return
23879 
 
23880 
 
23881 
  def __repr__(self):
23882 
    L = ['%s=%r' % (key, value)
23883 
      for key, value in self.__dict__.iteritems()]
23884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23885 
 
23886 
  def __eq__(self, other):
23887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23888 
 
23889 
  def __ne__(self, other):
23890 
    return not (self == other)
23891 
 
23892 
class getSettlementsByDate_result:
23893 
  """
23894 
  Attributes:
23895 
   - success
23896 
   - ex
23897 
  """
23898 
 
23899 
  thrift_spec = (
23900 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23901 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23902 
  )
23903 
 
23904 
  def __init__(self, success=None, ex=None,):
23905 
    self.success = success
23906 
    self.ex = ex
23907 
 
23908 
  def read(self, iprot):
23909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23911 
      return
23912 
    iprot.readStructBegin()
23913 
    while True:
23914 
      (fname, ftype, fid) = iprot.readFieldBegin()
23915 
      if ftype == TType.STOP:
23916 
        break
23917 
      if fid == 0:
23918 
        if ftype == TType.LIST:
23919 
          self.success = []
6188 rajveer 23920 
          (_etype566, _size563) = iprot.readListBegin()
23921 
          for _i567 in xrange(_size563):
23922 
            _elem568 = PaymentSettlement()
23923 
            _elem568.read(iprot)
23924 
            self.success.append(_elem568)
4715 varun.gupt 23925 
          iprot.readListEnd()
23926 
        else:
23927 
          iprot.skip(ftype)
23928 
      elif fid == 1:
23929 
        if ftype == TType.STRUCT:
23930 
          self.ex = TransactionServiceException()
23931 
          self.ex.read(iprot)
23932 
        else:
23933 
          iprot.skip(ftype)
23934 
      else:
23935 
        iprot.skip(ftype)
23936 
      iprot.readFieldEnd()
23937 
    iprot.readStructEnd()
23938 
 
23939 
  def write(self, oprot):
23940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23942 
      return
23943 
    oprot.writeStructBegin('getSettlementsByDate_result')
23944 
    if self.success is not None:
23945 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23946 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23947 
      for iter569 in self.success:
23948 
        iter569.write(oprot)
4715 varun.gupt 23949 
      oprot.writeListEnd()
23950 
      oprot.writeFieldEnd()
23951 
    if self.ex is not None:
23952 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23953 
      self.ex.write(oprot)
23954 
      oprot.writeFieldEnd()
23955 
    oprot.writeFieldStop()
23956 
    oprot.writeStructEnd()
23957 
 
23958 
  def validate(self):
23959 
    return
23960 
 
23961 
 
23962 
  def __repr__(self):
23963 
    L = ['%s=%r' % (key, value)
23964 
      for key, value in self.__dict__.iteritems()]
23965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23966 
 
23967 
  def __eq__(self, other):
23968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23969 
 
23970 
  def __ne__(self, other):
23971 
    return not (self == other)
23972 
 
23973 
class getReshippedOrderIds_args:
23974 
  """
23975 
  Attributes:
23976 
   - orderIds
23977 
  """
23978 
 
23979 
  thrift_spec = (
23980 
    None, # 0
23981 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23982 
  )
23983 
 
23984 
  def __init__(self, orderIds=None,):
23985 
    self.orderIds = orderIds
23986 
 
23987 
  def read(self, iprot):
23988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23990 
      return
23991 
    iprot.readStructBegin()
23992 
    while True:
23993 
      (fname, ftype, fid) = iprot.readFieldBegin()
23994 
      if ftype == TType.STOP:
23995 
        break
23996 
      if fid == 1:
23997 
        if ftype == TType.LIST:
23998 
          self.orderIds = []
6188 rajveer 23999 
          (_etype573, _size570) = iprot.readListBegin()
24000 
          for _i574 in xrange(_size570):
24001 
            _elem575 = iprot.readI64();
24002 
            self.orderIds.append(_elem575)
4715 varun.gupt 24003 
          iprot.readListEnd()
24004 
        else:
24005 
          iprot.skip(ftype)
24006 
      else:
24007 
        iprot.skip(ftype)
24008 
      iprot.readFieldEnd()
24009 
    iprot.readStructEnd()
24010 
 
24011 
  def write(self, oprot):
24012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24014 
      return
24015 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24016 
    if self.orderIds is not None:
24017 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24018 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24019 
      for iter576 in self.orderIds:
24020 
        oprot.writeI64(iter576)
4715 varun.gupt 24021 
      oprot.writeListEnd()
24022 
      oprot.writeFieldEnd()
24023 
    oprot.writeFieldStop()
24024 
    oprot.writeStructEnd()
24025 
 
24026 
  def validate(self):
24027 
    return
24028 
 
24029 
 
24030 
  def __repr__(self):
24031 
    L = ['%s=%r' % (key, value)
24032 
      for key, value in self.__dict__.iteritems()]
24033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24034 
 
24035 
  def __eq__(self, other):
24036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24037 
 
24038 
  def __ne__(self, other):
24039 
    return not (self == other)
24040 
 
24041 
class getReshippedOrderIds_result:
24042 
  """
24043 
  Attributes:
24044 
   - success
24045 
   - ex
24046 
  """
24047 
 
24048 
  thrift_spec = (
24049 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24050 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24051 
  )
24052 
 
24053 
  def __init__(self, success=None, ex=None,):
24054 
    self.success = success
24055 
    self.ex = ex
24056 
 
24057 
  def read(self, iprot):
24058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24060 
      return
24061 
    iprot.readStructBegin()
24062 
    while True:
24063 
      (fname, ftype, fid) = iprot.readFieldBegin()
24064 
      if ftype == TType.STOP:
24065 
        break
24066 
      if fid == 0:
24067 
        if ftype == TType.LIST:
24068 
          self.success = []
6188 rajveer 24069 
          (_etype580, _size577) = iprot.readListBegin()
24070 
          for _i581 in xrange(_size577):
24071 
            _elem582 = iprot.readI64();
24072 
            self.success.append(_elem582)
4715 varun.gupt 24073 
          iprot.readListEnd()
24074 
        else:
24075 
          iprot.skip(ftype)
24076 
      elif fid == 1:
24077 
        if ftype == TType.STRUCT:
24078 
          self.ex = TransactionServiceException()
24079 
          self.ex.read(iprot)
24080 
        else:
24081 
          iprot.skip(ftype)
24082 
      else:
24083 
        iprot.skip(ftype)
24084 
      iprot.readFieldEnd()
24085 
    iprot.readStructEnd()
24086 
 
24087 
  def write(self, oprot):
24088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24090 
      return
24091 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24092 
    if self.success is not None:
24093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24094 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24095 
      for iter583 in self.success:
24096 
        oprot.writeI64(iter583)
4715 varun.gupt 24097 
      oprot.writeListEnd()
24098 
      oprot.writeFieldEnd()
24099 
    if self.ex is not None:
24100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24101 
      self.ex.write(oprot)
24102 
      oprot.writeFieldEnd()
24103 
    oprot.writeFieldStop()
24104 
    oprot.writeStructEnd()
24105 
 
24106 
  def validate(self):
24107 
    return
24108 
 
24109 
 
24110 
  def __repr__(self):
24111 
    L = ['%s=%r' % (key, value)
24112 
      for key, value in self.__dict__.iteritems()]
24113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24114 
 
24115 
  def __eq__(self, other):
24116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24117 
 
24118 
  def __ne__(self, other):
24119 
    return not (self == other)
4757 mandeep.dh 24120 
 
5481 phani.kuma 24121 
class getBilledOrders_args:
4875 varun.gupt 24122 
  """
24123 
  Attributes:
24124 
   - vendorId
5481 phani.kuma 24125 
   - onlyVendorNotPaid
24126 
   - billingDateFrom
24127 
   - billingDateTo
4875 varun.gupt 24128 
  """
24129 
 
24130 
  thrift_spec = (
24131 
    None, # 0
24132 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24133 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24134 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24135 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24136 
  )
24137 
 
5481 phani.kuma 24138 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24139 
    self.vendorId = vendorId
5481 phani.kuma 24140 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24141 
    self.billingDateFrom = billingDateFrom
24142 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24143 
 
24144 
  def read(self, iprot):
24145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24147 
      return
24148 
    iprot.readStructBegin()
24149 
    while True:
24150 
      (fname, ftype, fid) = iprot.readFieldBegin()
24151 
      if ftype == TType.STOP:
24152 
        break
24153 
      if fid == 1:
24154 
        if ftype == TType.I64:
24155 
          self.vendorId = iprot.readI64();
24156 
        else:
24157 
          iprot.skip(ftype)
5481 phani.kuma 24158 
      elif fid == 2:
24159 
        if ftype == TType.BOOL:
24160 
          self.onlyVendorNotPaid = iprot.readBool();
24161 
        else:
24162 
          iprot.skip(ftype)
24163 
      elif fid == 3:
24164 
        if ftype == TType.I64:
24165 
          self.billingDateFrom = iprot.readI64();
24166 
        else:
24167 
          iprot.skip(ftype)
24168 
      elif fid == 4:
24169 
        if ftype == TType.I64:
24170 
          self.billingDateTo = iprot.readI64();
24171 
        else:
24172 
          iprot.skip(ftype)
4875 varun.gupt 24173 
      else:
24174 
        iprot.skip(ftype)
24175 
      iprot.readFieldEnd()
24176 
    iprot.readStructEnd()
24177 
 
24178 
  def write(self, oprot):
24179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24181 
      return
5481 phani.kuma 24182 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24183 
    if self.vendorId is not None:
24184 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24185 
      oprot.writeI64(self.vendorId)
24186 
      oprot.writeFieldEnd()
5481 phani.kuma 24187 
    if self.onlyVendorNotPaid is not None:
24188 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24189 
      oprot.writeBool(self.onlyVendorNotPaid)
24190 
      oprot.writeFieldEnd()
24191 
    if self.billingDateFrom is not None:
24192 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24193 
      oprot.writeI64(self.billingDateFrom)
24194 
      oprot.writeFieldEnd()
24195 
    if self.billingDateTo is not None:
24196 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24197 
      oprot.writeI64(self.billingDateTo)
24198 
      oprot.writeFieldEnd()
4875 varun.gupt 24199 
    oprot.writeFieldStop()
24200 
    oprot.writeStructEnd()
24201 
 
24202 
  def validate(self):
24203 
    return
24204 
 
24205 
 
24206 
  def __repr__(self):
24207 
    L = ['%s=%r' % (key, value)
24208 
      for key, value in self.__dict__.iteritems()]
24209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24210 
 
24211 
  def __eq__(self, other):
24212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24213 
 
24214 
  def __ne__(self, other):
24215 
    return not (self == other)
24216 
 
5481 phani.kuma 24217 
class getBilledOrders_result:
4875 varun.gupt 24218 
  """
24219 
  Attributes:
24220 
   - success
24221 
   - ex
24222 
  """
24223 
 
24224 
  thrift_spec = (
24225 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24227 
  )
24228 
 
24229 
  def __init__(self, success=None, ex=None,):
24230 
    self.success = success
24231 
    self.ex = ex
24232 
 
24233 
  def read(self, iprot):
24234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24236 
      return
24237 
    iprot.readStructBegin()
24238 
    while True:
24239 
      (fname, ftype, fid) = iprot.readFieldBegin()
24240 
      if ftype == TType.STOP:
24241 
        break
24242 
      if fid == 0:
24243 
        if ftype == TType.LIST:
24244 
          self.success = []
6188 rajveer 24245 
          (_etype587, _size584) = iprot.readListBegin()
24246 
          for _i588 in xrange(_size584):
24247 
            _elem589 = Order()
24248 
            _elem589.read(iprot)
24249 
            self.success.append(_elem589)
4875 varun.gupt 24250 
          iprot.readListEnd()
24251 
        else:
24252 
          iprot.skip(ftype)
24253 
      elif fid == 1:
24254 
        if ftype == TType.STRUCT:
24255 
          self.ex = TransactionServiceException()
24256 
          self.ex.read(iprot)
24257 
        else:
24258 
          iprot.skip(ftype)
24259 
      else:
24260 
        iprot.skip(ftype)
24261 
      iprot.readFieldEnd()
24262 
    iprot.readStructEnd()
24263 
 
24264 
  def write(self, oprot):
24265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24267 
      return
5481 phani.kuma 24268 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24269 
    if self.success is not None:
24270 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24271 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24272 
      for iter590 in self.success:
24273 
        iter590.write(oprot)
4875 varun.gupt 24274 
      oprot.writeListEnd()
24275 
      oprot.writeFieldEnd()
24276 
    if self.ex is not None:
24277 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24278 
      self.ex.write(oprot)
24279 
      oprot.writeFieldEnd()
24280 
    oprot.writeFieldStop()
24281 
    oprot.writeStructEnd()
24282 
 
24283 
  def validate(self):
24284 
    return
24285 
 
24286 
 
24287 
  def __repr__(self):
24288 
    L = ['%s=%r' % (key, value)
24289 
      for key, value in self.__dict__.iteritems()]
24290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24291 
 
24292 
  def __eq__(self, other):
24293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24294 
 
24295 
  def __ne__(self, other):
24296 
    return not (self == other)
5031 varun.gupt 24297 
 
24298 
class getStatusDistributionOfOrders_args:
24299 
  """
24300 
  Attributes:
24301 
   - startDate
24302 
   - endDate
24303 
  """
24304 
 
24305 
  thrift_spec = (
24306 
    None, # 0
24307 
    (1, TType.I64, 'startDate', None, None, ), # 1
24308 
    (2, TType.I64, 'endDate', None, None, ), # 2
24309 
  )
24310 
 
24311 
  def __init__(self, startDate=None, endDate=None,):
24312 
    self.startDate = startDate
24313 
    self.endDate = endDate
24314 
 
24315 
  def read(self, iprot):
24316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24318 
      return
24319 
    iprot.readStructBegin()
24320 
    while True:
24321 
      (fname, ftype, fid) = iprot.readFieldBegin()
24322 
      if ftype == TType.STOP:
24323 
        break
24324 
      if fid == 1:
24325 
        if ftype == TType.I64:
24326 
          self.startDate = iprot.readI64();
24327 
        else:
24328 
          iprot.skip(ftype)
24329 
      elif fid == 2:
24330 
        if ftype == TType.I64:
24331 
          self.endDate = iprot.readI64();
24332 
        else:
24333 
          iprot.skip(ftype)
24334 
      else:
24335 
        iprot.skip(ftype)
24336 
      iprot.readFieldEnd()
24337 
    iprot.readStructEnd()
24338 
 
24339 
  def write(self, oprot):
24340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24342 
      return
24343 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24344 
    if self.startDate is not None:
24345 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24346 
      oprot.writeI64(self.startDate)
24347 
      oprot.writeFieldEnd()
24348 
    if self.endDate is not None:
24349 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24350 
      oprot.writeI64(self.endDate)
24351 
      oprot.writeFieldEnd()
24352 
    oprot.writeFieldStop()
24353 
    oprot.writeStructEnd()
24354 
 
24355 
  def validate(self):
24356 
    return
24357 
 
24358 
 
24359 
  def __repr__(self):
24360 
    L = ['%s=%r' % (key, value)
24361 
      for key, value in self.__dict__.iteritems()]
24362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24363 
 
24364 
  def __eq__(self, other):
24365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24366 
 
24367 
  def __ne__(self, other):
24368 
    return not (self == other)
24369 
 
24370 
class getStatusDistributionOfOrders_result:
24371 
  """
24372 
  Attributes:
24373 
   - success
24374 
   - ex
24375 
  """
24376 
 
24377 
  thrift_spec = (
24378 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24380 
  )
24381 
 
24382 
  def __init__(self, success=None, ex=None,):
24383 
    self.success = success
24384 
    self.ex = ex
24385 
 
24386 
  def read(self, iprot):
24387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24389 
      return
24390 
    iprot.readStructBegin()
24391 
    while True:
24392 
      (fname, ftype, fid) = iprot.readFieldBegin()
24393 
      if ftype == TType.STOP:
24394 
        break
24395 
      if fid == 0:
24396 
        if ftype == TType.MAP:
24397 
          self.success = {}
6188 rajveer 24398 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24399 
          for _i595 in xrange(_size591):
24400 
            _key596 = iprot.readI64();
24401 
            _val597 = iprot.readI64();
24402 
            self.success[_key596] = _val597
5031 varun.gupt 24403 
          iprot.readMapEnd()
24404 
        else:
24405 
          iprot.skip(ftype)
24406 
      elif fid == 1:
24407 
        if ftype == TType.STRUCT:
24408 
          self.ex = TransactionServiceException()
24409 
          self.ex.read(iprot)
24410 
        else:
24411 
          iprot.skip(ftype)
24412 
      else:
24413 
        iprot.skip(ftype)
24414 
      iprot.readFieldEnd()
24415 
    iprot.readStructEnd()
24416 
 
24417 
  def write(self, oprot):
24418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24420 
      return
24421 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24422 
    if self.success is not None:
24423 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24424 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24425 
      for kiter598,viter599 in self.success.items():
24426 
        oprot.writeI64(kiter598)
24427 
        oprot.writeI64(viter599)
5031 varun.gupt 24428 
      oprot.writeMapEnd()
24429 
      oprot.writeFieldEnd()
24430 
    if self.ex is not None:
24431 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24432 
      self.ex.write(oprot)
24433 
      oprot.writeFieldEnd()
24434 
    oprot.writeFieldStop()
24435 
    oprot.writeStructEnd()
24436 
 
24437 
  def validate(self):
24438 
    return
24439 
 
24440 
 
24441 
  def __repr__(self):
24442 
    L = ['%s=%r' % (key, value)
24443 
      for key, value in self.__dict__.iteritems()]
24444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24445 
 
24446 
  def __eq__(self, other):
24447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24448 
 
24449 
  def __ne__(self, other):
24450 
    return not (self == other)
5067 varun.gupt 24451 
 
24452 
class getOrderIdsForStatus_args:
24453 
  """
24454 
  Attributes:
24455 
   - status
24456 
   - startDatetime
24457 
   - endDatetime
24458 
  """
24459 
 
24460 
  thrift_spec = (
24461 
    None, # 0
24462 
    (1, TType.I64, 'status', None, None, ), # 1
24463 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24464 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24465 
  )
24466 
 
24467 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24468 
    self.status = status
24469 
    self.startDatetime = startDatetime
24470 
    self.endDatetime = endDatetime
24471 
 
24472 
  def read(self, iprot):
24473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24475 
      return
24476 
    iprot.readStructBegin()
24477 
    while True:
24478 
      (fname, ftype, fid) = iprot.readFieldBegin()
24479 
      if ftype == TType.STOP:
24480 
        break
24481 
      if fid == 1:
24482 
        if ftype == TType.I64:
24483 
          self.status = iprot.readI64();
24484 
        else:
24485 
          iprot.skip(ftype)
24486 
      elif fid == 2:
24487 
        if ftype == TType.I64:
24488 
          self.startDatetime = iprot.readI64();
24489 
        else:
24490 
          iprot.skip(ftype)
24491 
      elif fid == 3:
24492 
        if ftype == TType.I64:
24493 
          self.endDatetime = iprot.readI64();
24494 
        else:
24495 
          iprot.skip(ftype)
24496 
      else:
24497 
        iprot.skip(ftype)
24498 
      iprot.readFieldEnd()
24499 
    iprot.readStructEnd()
24500 
 
24501 
  def write(self, oprot):
24502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24504 
      return
24505 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24506 
    if self.status is not None:
24507 
      oprot.writeFieldBegin('status', TType.I64, 1)
24508 
      oprot.writeI64(self.status)
24509 
      oprot.writeFieldEnd()
24510 
    if self.startDatetime is not None:
24511 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24512 
      oprot.writeI64(self.startDatetime)
24513 
      oprot.writeFieldEnd()
24514 
    if self.endDatetime is not None:
24515 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24516 
      oprot.writeI64(self.endDatetime)
24517 
      oprot.writeFieldEnd()
24518 
    oprot.writeFieldStop()
24519 
    oprot.writeStructEnd()
24520 
 
24521 
  def validate(self):
24522 
    return
24523 
 
24524 
 
24525 
  def __repr__(self):
24526 
    L = ['%s=%r' % (key, value)
24527 
      for key, value in self.__dict__.iteritems()]
24528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24529 
 
24530 
  def __eq__(self, other):
24531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24532 
 
24533 
  def __ne__(self, other):
24534 
    return not (self == other)
24535 
 
24536 
class getOrderIdsForStatus_result:
24537 
  """
24538 
  Attributes:
24539 
   - success
24540 
   - ex
24541 
  """
24542 
 
24543 
  thrift_spec = (
24544 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24546 
  )
24547 
 
24548 
  def __init__(self, success=None, ex=None,):
24549 
    self.success = success
24550 
    self.ex = ex
24551 
 
24552 
  def read(self, iprot):
24553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24555 
      return
24556 
    iprot.readStructBegin()
24557 
    while True:
24558 
      (fname, ftype, fid) = iprot.readFieldBegin()
24559 
      if ftype == TType.STOP:
24560 
        break
24561 
      if fid == 0:
24562 
        if ftype == TType.LIST:
24563 
          self.success = []
6188 rajveer 24564 
          (_etype603, _size600) = iprot.readListBegin()
24565 
          for _i604 in xrange(_size600):
24566 
            _elem605 = iprot.readI64();
24567 
            self.success.append(_elem605)
5067 varun.gupt 24568 
          iprot.readListEnd()
24569 
        else:
24570 
          iprot.skip(ftype)
24571 
      elif fid == 1:
24572 
        if ftype == TType.STRUCT:
24573 
          self.ex = TransactionServiceException()
24574 
          self.ex.read(iprot)
24575 
        else:
24576 
          iprot.skip(ftype)
24577 
      else:
24578 
        iprot.skip(ftype)
24579 
      iprot.readFieldEnd()
24580 
    iprot.readStructEnd()
24581 
 
24582 
  def write(self, oprot):
24583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24585 
      return
24586 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24587 
    if self.success is not None:
24588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24589 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24590 
      for iter606 in self.success:
24591 
        oprot.writeI64(iter606)
5067 varun.gupt 24592 
      oprot.writeListEnd()
24593 
      oprot.writeFieldEnd()
24594 
    if self.ex is not None:
24595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24596 
      self.ex.write(oprot)
24597 
      oprot.writeFieldEnd()
24598 
    oprot.writeFieldStop()
24599 
    oprot.writeStructEnd()
24600 
 
24601 
  def validate(self):
24602 
    return
24603 
 
24604 
 
24605 
  def __repr__(self):
24606 
    L = ['%s=%r' % (key, value)
24607 
      for key, value in self.__dict__.iteritems()]
24608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24609 
 
24610 
  def __eq__(self, other):
24611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24612 
 
24613 
  def __ne__(self, other):
24614 
    return not (self == other)
5099 varun.gupt 24615 
 
5348 anupam.sin 24616 
class updateCODAgent_args:
24617 
  """
24618 
  Attributes:
24619 
   - agent
24620 
   - orderId
24621 
  """
24622 
 
24623 
  thrift_spec = (
24624 
    None, # 0
24625 
    (1, TType.STRING, 'agent', None, None, ), # 1
24626 
    (2, TType.I64, 'orderId', None, None, ), # 2
24627 
  )
24628 
 
24629 
  def __init__(self, agent=None, orderId=None,):
24630 
    self.agent = agent
24631 
    self.orderId = orderId
24632 
 
24633 
  def read(self, iprot):
24634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24636 
      return
24637 
    iprot.readStructBegin()
24638 
    while True:
24639 
      (fname, ftype, fid) = iprot.readFieldBegin()
24640 
      if ftype == TType.STOP:
24641 
        break
24642 
      if fid == 1:
24643 
        if ftype == TType.STRING:
24644 
          self.agent = iprot.readString();
24645 
        else:
24646 
          iprot.skip(ftype)
24647 
      elif fid == 2:
24648 
        if ftype == TType.I64:
24649 
          self.orderId = iprot.readI64();
24650 
        else:
24651 
          iprot.skip(ftype)
24652 
      else:
24653 
        iprot.skip(ftype)
24654 
      iprot.readFieldEnd()
24655 
    iprot.readStructEnd()
24656 
 
24657 
  def write(self, oprot):
24658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24660 
      return
24661 
    oprot.writeStructBegin('updateCODAgent_args')
24662 
    if self.agent is not None:
24663 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24664 
      oprot.writeString(self.agent)
24665 
      oprot.writeFieldEnd()
24666 
    if self.orderId is not None:
24667 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24668 
      oprot.writeI64(self.orderId)
24669 
      oprot.writeFieldEnd()
24670 
    oprot.writeFieldStop()
24671 
    oprot.writeStructEnd()
24672 
 
24673 
  def validate(self):
24674 
    return
24675 
 
24676 
 
24677 
  def __repr__(self):
24678 
    L = ['%s=%r' % (key, value)
24679 
      for key, value in self.__dict__.iteritems()]
24680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24681 
 
24682 
  def __eq__(self, other):
24683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24684 
 
24685 
  def __ne__(self, other):
24686 
    return not (self == other)
24687 
 
24688 
class updateCODAgent_result:
24689 
  """
24690 
  Attributes:
24691 
   - ex
24692 
  """
24693 
 
24694 
  thrift_spec = (
24695 
    None, # 0
24696 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24697 
  )
24698 
 
24699 
  def __init__(self, ex=None,):
24700 
    self.ex = ex
24701 
 
24702 
  def read(self, iprot):
24703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24705 
      return
24706 
    iprot.readStructBegin()
24707 
    while True:
24708 
      (fname, ftype, fid) = iprot.readFieldBegin()
24709 
      if ftype == TType.STOP:
24710 
        break
24711 
      if fid == 1:
24712 
        if ftype == TType.STRUCT:
24713 
          self.ex = TransactionServiceException()
24714 
          self.ex.read(iprot)
24715 
        else:
24716 
          iprot.skip(ftype)
24717 
      else:
24718 
        iprot.skip(ftype)
24719 
      iprot.readFieldEnd()
24720 
    iprot.readStructEnd()
24721 
 
24722 
  def write(self, oprot):
24723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24725 
      return
24726 
    oprot.writeStructBegin('updateCODAgent_result')
24727 
    if self.ex is not None:
24728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24729 
      self.ex.write(oprot)
24730 
      oprot.writeFieldEnd()
24731 
    oprot.writeFieldStop()
24732 
    oprot.writeStructEnd()
24733 
 
24734 
  def validate(self):
24735 
    return
24736 
 
24737 
 
24738 
  def __repr__(self):
24739 
    L = ['%s=%r' % (key, value)
24740 
      for key, value in self.__dict__.iteritems()]
24741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24742 
 
24743 
  def __eq__(self, other):
24744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24745 
 
24746 
  def __ne__(self, other):
24747 
    return not (self == other)
24748 
 
5099 varun.gupt 24749 
class updateOrderAsPaidToVendor_args:
24750 
  """
24751 
  Attributes:
24752 
   - orderId
24753 
  """
24754 
 
24755 
  thrift_spec = (
24756 
    None, # 0
24757 
    (1, TType.I64, 'orderId', None, None, ), # 1
24758 
  )
24759 
 
24760 
  def __init__(self, orderId=None,):
24761 
    self.orderId = orderId
24762 
 
24763 
  def read(self, iprot):
24764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24766 
      return
24767 
    iprot.readStructBegin()
24768 
    while True:
24769 
      (fname, ftype, fid) = iprot.readFieldBegin()
24770 
      if ftype == TType.STOP:
24771 
        break
24772 
      if fid == 1:
24773 
        if ftype == TType.I64:
24774 
          self.orderId = iprot.readI64();
24775 
        else:
24776 
          iprot.skip(ftype)
24777 
      else:
24778 
        iprot.skip(ftype)
24779 
      iprot.readFieldEnd()
24780 
    iprot.readStructEnd()
24781 
 
24782 
  def write(self, oprot):
24783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24785 
      return
24786 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24787 
    if self.orderId is not None:
24788 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24789 
      oprot.writeI64(self.orderId)
24790 
      oprot.writeFieldEnd()
24791 
    oprot.writeFieldStop()
24792 
    oprot.writeStructEnd()
24793 
 
24794 
  def validate(self):
24795 
    return
24796 
 
24797 
 
24798 
  def __repr__(self):
24799 
    L = ['%s=%r' % (key, value)
24800 
      for key, value in self.__dict__.iteritems()]
24801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24802 
 
24803 
  def __eq__(self, other):
24804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24805 
 
24806 
  def __ne__(self, other):
24807 
    return not (self == other)
24808 
 
24809 
class updateOrderAsPaidToVendor_result:
24810 
  """
24811 
  Attributes:
24812 
   - ex
24813 
  """
24814 
 
24815 
  thrift_spec = (
24816 
    None, # 0
24817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24818 
  )
24819 
 
24820 
  def __init__(self, ex=None,):
24821 
    self.ex = ex
24822 
 
24823 
  def read(self, iprot):
24824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24826 
      return
24827 
    iprot.readStructBegin()
24828 
    while True:
24829 
      (fname, ftype, fid) = iprot.readFieldBegin()
24830 
      if ftype == TType.STOP:
24831 
        break
24832 
      if fid == 1:
24833 
        if ftype == TType.STRUCT:
24834 
          self.ex = TransactionServiceException()
24835 
          self.ex.read(iprot)
24836 
        else:
24837 
          iprot.skip(ftype)
24838 
      else:
24839 
        iprot.skip(ftype)
24840 
      iprot.readFieldEnd()
24841 
    iprot.readStructEnd()
24842 
 
24843 
  def write(self, oprot):
24844 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24845 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24846 
      return
24847 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24848 
    if self.ex is not None:
24849 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24850 
      self.ex.write(oprot)
24851 
      oprot.writeFieldEnd()
24852 
    oprot.writeFieldStop()
24853 
    oprot.writeStructEnd()
24854 
 
24855 
  def validate(self):
24856 
    return
24857 
 
24858 
 
24859 
  def __repr__(self):
24860 
    L = ['%s=%r' % (key, value)
24861 
      for key, value in self.__dict__.iteritems()]
24862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24863 
 
24864 
  def __eq__(self, other):
24865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24866 
 
24867 
  def __ne__(self, other):
24868 
    return not (self == other)
5208 varun.gupt 24869 
 
5386 phani.kuma 24870 
class updateOrderOnlyAsPaidToVendor_args:
24871 
  """
24872 
  Attributes:
24873 
   - orderId
24874 
  """
24875 
 
24876 
  thrift_spec = (
24877 
    None, # 0
24878 
    (1, TType.I64, 'orderId', None, None, ), # 1
24879 
  )
24880 
 
24881 
  def __init__(self, orderId=None,):
24882 
    self.orderId = orderId
24883 
 
24884 
  def read(self, iprot):
24885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24887 
      return
24888 
    iprot.readStructBegin()
24889 
    while True:
24890 
      (fname, ftype, fid) = iprot.readFieldBegin()
24891 
      if ftype == TType.STOP:
24892 
        break
24893 
      if fid == 1:
24894 
        if ftype == TType.I64:
24895 
          self.orderId = iprot.readI64();
24896 
        else:
24897 
          iprot.skip(ftype)
24898 
      else:
24899 
        iprot.skip(ftype)
24900 
      iprot.readFieldEnd()
24901 
    iprot.readStructEnd()
24902 
 
24903 
  def write(self, oprot):
24904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24906 
      return
24907 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24908 
    if self.orderId is not None:
24909 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24910 
      oprot.writeI64(self.orderId)
24911 
      oprot.writeFieldEnd()
24912 
    oprot.writeFieldStop()
24913 
    oprot.writeStructEnd()
24914 
 
24915 
  def validate(self):
24916 
    return
24917 
 
24918 
 
24919 
  def __repr__(self):
24920 
    L = ['%s=%r' % (key, value)
24921 
      for key, value in self.__dict__.iteritems()]
24922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24923 
 
24924 
  def __eq__(self, other):
24925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24926 
 
24927 
  def __ne__(self, other):
24928 
    return not (self == other)
24929 
 
24930 
class updateOrderOnlyAsPaidToVendor_result:
24931 
  """
24932 
  Attributes:
24933 
   - ex
24934 
  """
24935 
 
24936 
  thrift_spec = (
24937 
    None, # 0
24938 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24939 
  )
24940 
 
24941 
  def __init__(self, ex=None,):
24942 
    self.ex = ex
24943 
 
24944 
  def read(self, iprot):
24945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24947 
      return
24948 
    iprot.readStructBegin()
24949 
    while True:
24950 
      (fname, ftype, fid) = iprot.readFieldBegin()
24951 
      if ftype == TType.STOP:
24952 
        break
24953 
      if fid == 1:
24954 
        if ftype == TType.STRUCT:
24955 
          self.ex = TransactionServiceException()
24956 
          self.ex.read(iprot)
24957 
        else:
24958 
          iprot.skip(ftype)
24959 
      else:
24960 
        iprot.skip(ftype)
24961 
      iprot.readFieldEnd()
24962 
    iprot.readStructEnd()
24963 
 
24964 
  def write(self, oprot):
24965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24967 
      return
24968 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24969 
    if self.ex is not None:
24970 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24971 
      self.ex.write(oprot)
24972 
      oprot.writeFieldEnd()
24973 
    oprot.writeFieldStop()
24974 
    oprot.writeStructEnd()
24975 
 
24976 
  def validate(self):
24977 
    return
24978 
 
24979 
 
24980 
  def __repr__(self):
24981 
    L = ['%s=%r' % (key, value)
24982 
      for key, value in self.__dict__.iteritems()]
24983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24984 
 
24985 
  def __eq__(self, other):
24986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24987 
 
24988 
  def __ne__(self, other):
24989 
    return not (self == other)
24990 
 
5208 varun.gupt 24991 
class getRefundedOrdersMarkedPaid_args:
24992 
 
24993 
  thrift_spec = (
24994 
  )
24995 
 
24996 
  def read(self, iprot):
24997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24999 
      return
25000 
    iprot.readStructBegin()
25001 
    while True:
25002 
      (fname, ftype, fid) = iprot.readFieldBegin()
25003 
      if ftype == TType.STOP:
25004 
        break
25005 
      else:
25006 
        iprot.skip(ftype)
25007 
      iprot.readFieldEnd()
25008 
    iprot.readStructEnd()
25009 
 
25010 
  def write(self, oprot):
25011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25013 
      return
25014 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25015 
    oprot.writeFieldStop()
25016 
    oprot.writeStructEnd()
25017 
 
25018 
  def validate(self):
25019 
    return
25020 
 
25021 
 
25022 
  def __repr__(self):
25023 
    L = ['%s=%r' % (key, value)
25024 
      for key, value in self.__dict__.iteritems()]
25025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25026 
 
25027 
  def __eq__(self, other):
25028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25029 
 
25030 
  def __ne__(self, other):
25031 
    return not (self == other)
25032 
 
25033 
class getRefundedOrdersMarkedPaid_result:
25034 
  """
25035 
  Attributes:
25036 
   - success
25037 
   - ex
25038 
  """
25039 
 
25040 
  thrift_spec = (
25041 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25042 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25043 
  )
25044 
 
25045 
  def __init__(self, success=None, ex=None,):
25046 
    self.success = success
25047 
    self.ex = ex
25048 
 
25049 
  def read(self, iprot):
25050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25052 
      return
25053 
    iprot.readStructBegin()
25054 
    while True:
25055 
      (fname, ftype, fid) = iprot.readFieldBegin()
25056 
      if ftype == TType.STOP:
25057 
        break
25058 
      if fid == 0:
25059 
        if ftype == TType.LIST:
25060 
          self.success = []
6188 rajveer 25061 
          (_etype610, _size607) = iprot.readListBegin()
25062 
          for _i611 in xrange(_size607):
25063 
            _elem612 = Order()
25064 
            _elem612.read(iprot)
25065 
            self.success.append(_elem612)
5208 varun.gupt 25066 
          iprot.readListEnd()
25067 
        else:
25068 
          iprot.skip(ftype)
25069 
      elif fid == 1:
25070 
        if ftype == TType.STRUCT:
25071 
          self.ex = TransactionServiceException()
25072 
          self.ex.read(iprot)
25073 
        else:
25074 
          iprot.skip(ftype)
25075 
      else:
25076 
        iprot.skip(ftype)
25077 
      iprot.readFieldEnd()
25078 
    iprot.readStructEnd()
25079 
 
25080 
  def write(self, oprot):
25081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25083 
      return
25084 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25085 
    if self.success is not None:
25086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25088 
      for iter613 in self.success:
25089 
        iter613.write(oprot)
5208 varun.gupt 25090 
      oprot.writeListEnd()
25091 
      oprot.writeFieldEnd()
25092 
    if self.ex is not None:
25093 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25094 
      self.ex.write(oprot)
25095 
      oprot.writeFieldEnd()
25096 
    oprot.writeFieldStop()
25097 
    oprot.writeStructEnd()
25098 
 
25099 
  def validate(self):
25100 
    return
25101 
 
25102 
 
25103 
  def __repr__(self):
25104 
    L = ['%s=%r' % (key, value)
25105 
      for key, value in self.__dict__.iteritems()]
25106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25107 
 
25108 
  def __eq__(self, other):
25109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25110 
 
25111 
  def __ne__(self, other):
25112 
    return not (self == other)
5447 anupam.sin 25113 
 
25114 
class getAllVerificationAgents_args:
25115 
  """
25116 
  Attributes:
25117 
   - minOrderId
25118 
   - maxOrderId
25119 
  """
25120 
 
25121 
  thrift_spec = (
25122 
    None, # 0
25123 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25124 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25125 
  )
25126 
 
25127 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25128 
    self.minOrderId = minOrderId
25129 
    self.maxOrderId = maxOrderId
25130 
 
25131 
  def read(self, iprot):
25132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25134 
      return
25135 
    iprot.readStructBegin()
25136 
    while True:
25137 
      (fname, ftype, fid) = iprot.readFieldBegin()
25138 
      if ftype == TType.STOP:
25139 
        break
25140 
      if fid == 1:
25141 
        if ftype == TType.I64:
25142 
          self.minOrderId = iprot.readI64();
25143 
        else:
25144 
          iprot.skip(ftype)
25145 
      elif fid == 2:
25146 
        if ftype == TType.I64:
25147 
          self.maxOrderId = iprot.readI64();
25148 
        else:
25149 
          iprot.skip(ftype)
25150 
      else:
25151 
        iprot.skip(ftype)
25152 
      iprot.readFieldEnd()
25153 
    iprot.readStructEnd()
25154 
 
25155 
  def write(self, oprot):
25156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25158 
      return
25159 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25160 
    if self.minOrderId is not None:
25161 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25162 
      oprot.writeI64(self.minOrderId)
25163 
      oprot.writeFieldEnd()
25164 
    if self.maxOrderId is not None:
25165 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25166 
      oprot.writeI64(self.maxOrderId)
25167 
      oprot.writeFieldEnd()
25168 
    oprot.writeFieldStop()
25169 
    oprot.writeStructEnd()
25170 
 
25171 
  def validate(self):
25172 
    return
25173 
 
25174 
 
25175 
  def __repr__(self):
25176 
    L = ['%s=%r' % (key, value)
25177 
      for key, value in self.__dict__.iteritems()]
25178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25179 
 
25180 
  def __eq__(self, other):
25181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25182 
 
25183 
  def __ne__(self, other):
25184 
    return not (self == other)
25185 
 
25186 
class getAllVerificationAgents_result:
25187 
  """
25188 
  Attributes:
25189 
   - success
25190 
  """
25191 
 
25192 
  thrift_spec = (
25193 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25194 
  )
25195 
 
25196 
  def __init__(self, success=None,):
25197 
    self.success = success
25198 
 
25199 
  def read(self, iprot):
25200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25202 
      return
25203 
    iprot.readStructBegin()
25204 
    while True:
25205 
      (fname, ftype, fid) = iprot.readFieldBegin()
25206 
      if ftype == TType.STOP:
25207 
        break
25208 
      if fid == 0:
25209 
        if ftype == TType.LIST:
25210 
          self.success = []
6188 rajveer 25211 
          (_etype617, _size614) = iprot.readListBegin()
25212 
          for _i618 in xrange(_size614):
25213 
            _elem619 = CODVerificationAgent()
25214 
            _elem619.read(iprot)
25215 
            self.success.append(_elem619)
5447 anupam.sin 25216 
          iprot.readListEnd()
25217 
        else:
25218 
          iprot.skip(ftype)
25219 
      else:
25220 
        iprot.skip(ftype)
25221 
      iprot.readFieldEnd()
25222 
    iprot.readStructEnd()
25223 
 
25224 
  def write(self, oprot):
25225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25227 
      return
25228 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25229 
    if self.success is not None:
25230 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25231 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25232 
      for iter620 in self.success:
25233 
        iter620.write(oprot)
5447 anupam.sin 25234 
      oprot.writeListEnd()
25235 
      oprot.writeFieldEnd()
25236 
    oprot.writeFieldStop()
25237 
    oprot.writeStructEnd()
25238 
 
25239 
  def validate(self):
25240 
    return
25241 
 
25242 
 
25243 
  def __repr__(self):
25244 
    L = ['%s=%r' % (key, value)
25245 
      for key, value in self.__dict__.iteritems()]
25246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25247 
 
25248 
  def __eq__(self, other):
25249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25250 
 
25251 
  def __ne__(self, other):
25252 
    return not (self == other)
5527 anupam.sin 25253 
 
25254 
class getAllAttributesForOrderId_args:
25255 
  """
25256 
  Attributes:
25257 
   - orderId
25258 
  """
25259 
 
25260 
  thrift_spec = (
25261 
    None, # 0
25262 
    (1, TType.I64, 'orderId', None, None, ), # 1
25263 
  )
25264 
 
25265 
  def __init__(self, orderId=None,):
25266 
    self.orderId = orderId
25267 
 
25268 
  def read(self, iprot):
25269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25271 
      return
25272 
    iprot.readStructBegin()
25273 
    while True:
25274 
      (fname, ftype, fid) = iprot.readFieldBegin()
25275 
      if ftype == TType.STOP:
25276 
        break
25277 
      if fid == 1:
25278 
        if ftype == TType.I64:
25279 
          self.orderId = iprot.readI64();
25280 
        else:
25281 
          iprot.skip(ftype)
25282 
      else:
25283 
        iprot.skip(ftype)
25284 
      iprot.readFieldEnd()
25285 
    iprot.readStructEnd()
25286 
 
25287 
  def write(self, oprot):
25288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25290 
      return
25291 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25292 
    if self.orderId is not None:
25293 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25294 
      oprot.writeI64(self.orderId)
25295 
      oprot.writeFieldEnd()
25296 
    oprot.writeFieldStop()
25297 
    oprot.writeStructEnd()
25298 
 
25299 
  def validate(self):
25300 
    return
25301 
 
25302 
 
25303 
  def __repr__(self):
25304 
    L = ['%s=%r' % (key, value)
25305 
      for key, value in self.__dict__.iteritems()]
25306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25307 
 
25308 
  def __eq__(self, other):
25309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25310 
 
25311 
  def __ne__(self, other):
25312 
    return not (self == other)
25313 
 
25314 
class getAllAttributesForOrderId_result:
25315 
  """
25316 
  Attributes:
25317 
   - success
25318 
  """
25319 
 
25320 
  thrift_spec = (
25321 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25322 
  )
25323 
 
25324 
  def __init__(self, success=None,):
25325 
    self.success = success
25326 
 
25327 
  def read(self, iprot):
25328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25330 
      return
25331 
    iprot.readStructBegin()
25332 
    while True:
25333 
      (fname, ftype, fid) = iprot.readFieldBegin()
25334 
      if ftype == TType.STOP:
25335 
        break
25336 
      if fid == 0:
25337 
        if ftype == TType.LIST:
25338 
          self.success = []
6188 rajveer 25339 
          (_etype624, _size621) = iprot.readListBegin()
25340 
          for _i625 in xrange(_size621):
25341 
            _elem626 = Attribute()
25342 
            _elem626.read(iprot)
25343 
            self.success.append(_elem626)
5527 anupam.sin 25344 
          iprot.readListEnd()
25345 
        else:
25346 
          iprot.skip(ftype)
25347 
      else:
25348 
        iprot.skip(ftype)
25349 
      iprot.readFieldEnd()
25350 
    iprot.readStructEnd()
25351 
 
25352 
  def write(self, oprot):
25353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25355 
      return
25356 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25357 
    if self.success is not None:
25358 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25359 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25360 
      for iter627 in self.success:
25361 
        iter627.write(oprot)
5527 anupam.sin 25362 
      oprot.writeListEnd()
25363 
      oprot.writeFieldEnd()
25364 
    oprot.writeFieldStop()
25365 
    oprot.writeStructEnd()
25366 
 
25367 
  def validate(self):
25368 
    return
25369 
 
25370 
 
25371 
  def __repr__(self):
25372 
    L = ['%s=%r' % (key, value)
25373 
      for key, value in self.__dict__.iteritems()]
25374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25375 
 
25376 
  def __eq__(self, other):
25377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25378 
 
25379 
  def __ne__(self, other):
25380 
    return not (self == other)
25381 
 
5676 rajveer 25382 
class setOrderAttributes_args:
25383 
  """
25384 
  Attributes:
25385 
   - orderId
25386 
   - attributes
25387 
  """
25388 
 
25389 
  thrift_spec = None
25390 
  def __init__(self, orderId=None, attributes=None,):
25391 
    self.orderId = orderId
25392 
    self.attributes = attributes
25393 
 
25394 
  def read(self, iprot):
25395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25397 
      return
25398 
    iprot.readStructBegin()
25399 
    while True:
25400 
      (fname, ftype, fid) = iprot.readFieldBegin()
25401 
      if ftype == TType.STOP:
25402 
        break
25403 
      if fid == 1:
25404 
        if ftype == TType.I64:
25405 
          self.orderId = iprot.readI64();
25406 
        else:
25407 
          iprot.skip(ftype)
25408 
      elif fid == -1:
25409 
        if ftype == TType.LIST:
25410 
          self.attributes = []
6188 rajveer 25411 
          (_etype631, _size628) = iprot.readListBegin()
25412 
          for _i632 in xrange(_size628):
25413 
            _elem633 = Attribute()
25414 
            _elem633.read(iprot)
25415 
            self.attributes.append(_elem633)
5676 rajveer 25416 
          iprot.readListEnd()
25417 
        else:
25418 
          iprot.skip(ftype)
25419 
      else:
25420 
        iprot.skip(ftype)
25421 
      iprot.readFieldEnd()
25422 
    iprot.readStructEnd()
25423 
 
25424 
  def write(self, oprot):
25425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25427 
      return
25428 
    oprot.writeStructBegin('setOrderAttributes_args')
25429 
    if self.attributes is not None:
25430 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25431 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25432 
      for iter634 in self.attributes:
25433 
        iter634.write(oprot)
5676 rajveer 25434 
      oprot.writeListEnd()
25435 
      oprot.writeFieldEnd()
25436 
    if self.orderId is not None:
25437 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25438 
      oprot.writeI64(self.orderId)
25439 
      oprot.writeFieldEnd()
25440 
    oprot.writeFieldStop()
25441 
    oprot.writeStructEnd()
25442 
 
25443 
  def validate(self):
25444 
    return
25445 
 
25446 
 
25447 
  def __repr__(self):
25448 
    L = ['%s=%r' % (key, value)
25449 
      for key, value in self.__dict__.iteritems()]
25450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25451 
 
25452 
  def __eq__(self, other):
25453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25454 
 
25455 
  def __ne__(self, other):
25456 
    return not (self == other)
25457 
 
25458 
class setOrderAttributes_result:
25459 
 
25460 
  thrift_spec = (
25461 
  )
25462 
 
25463 
  def read(self, iprot):
25464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25466 
      return
25467 
    iprot.readStructBegin()
25468 
    while True:
25469 
      (fname, ftype, fid) = iprot.readFieldBegin()
25470 
      if ftype == TType.STOP:
25471 
        break
25472 
      else:
25473 
        iprot.skip(ftype)
25474 
      iprot.readFieldEnd()
25475 
    iprot.readStructEnd()
25476 
 
25477 
  def write(self, oprot):
25478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25480 
      return
25481 
    oprot.writeStructBegin('setOrderAttributes_result')
25482 
    oprot.writeFieldStop()
25483 
    oprot.writeStructEnd()
25484 
 
25485 
  def validate(self):
25486 
    return
25487 
 
25488 
 
25489 
  def __repr__(self):
25490 
    L = ['%s=%r' % (key, value)
25491 
      for key, value in self.__dict__.iteritems()]
25492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25493 
 
25494 
  def __eq__(self, other):
25495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25496 
 
25497 
  def __ne__(self, other):
25498 
    return not (self == other)
25499 
 
5527 anupam.sin 25500 
class setOrderAttributeForTransaction_args:
25501 
  """
25502 
  Attributes:
25503 
   - transactionId
25504 
   - attribute
25505 
  """
25506 
 
25507 
  thrift_spec = None
25508 
  def __init__(self, transactionId=None, attribute=None,):
25509 
    self.transactionId = transactionId
25510 
    self.attribute = attribute
25511 
 
25512 
  def read(self, iprot):
25513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25515 
      return
25516 
    iprot.readStructBegin()
25517 
    while True:
25518 
      (fname, ftype, fid) = iprot.readFieldBegin()
25519 
      if ftype == TType.STOP:
25520 
        break
25521 
      if fid == 1:
25522 
        if ftype == TType.I64:
25523 
          self.transactionId = iprot.readI64();
25524 
        else:
25525 
          iprot.skip(ftype)
25526 
      elif fid == -1:
25527 
        if ftype == TType.STRUCT:
25528 
          self.attribute = Attribute()
25529 
          self.attribute.read(iprot)
25530 
        else:
25531 
          iprot.skip(ftype)
25532 
      else:
25533 
        iprot.skip(ftype)
25534 
      iprot.readFieldEnd()
25535 
    iprot.readStructEnd()
25536 
 
25537 
  def write(self, oprot):
25538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25540 
      return
25541 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25542 
    if self.attribute is not None:
25543 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25544 
      self.attribute.write(oprot)
25545 
      oprot.writeFieldEnd()
25546 
    if self.transactionId is not None:
25547 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25548 
      oprot.writeI64(self.transactionId)
25549 
      oprot.writeFieldEnd()
25550 
    oprot.writeFieldStop()
25551 
    oprot.writeStructEnd()
25552 
 
25553 
  def validate(self):
25554 
    return
25555 
 
25556 
 
25557 
  def __repr__(self):
25558 
    L = ['%s=%r' % (key, value)
25559 
      for key, value in self.__dict__.iteritems()]
25560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25561 
 
25562 
  def __eq__(self, other):
25563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25564 
 
25565 
  def __ne__(self, other):
25566 
    return not (self == other)
25567 
 
25568 
class setOrderAttributeForTransaction_result:
25569 
 
25570 
  thrift_spec = (
25571 
  )
25572 
 
25573 
  def read(self, iprot):
25574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25576 
      return
25577 
    iprot.readStructBegin()
25578 
    while True:
25579 
      (fname, ftype, fid) = iprot.readFieldBegin()
25580 
      if ftype == TType.STOP:
25581 
        break
25582 
      else:
25583 
        iprot.skip(ftype)
25584 
      iprot.readFieldEnd()
25585 
    iprot.readStructEnd()
25586 
 
25587 
  def write(self, oprot):
25588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25590 
      return
25591 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25592 
    oprot.writeFieldStop()
25593 
    oprot.writeStructEnd()
25594 
 
25595 
  def validate(self):
25596 
    return
25597 
 
25598 
 
25599 
  def __repr__(self):
25600 
    L = ['%s=%r' % (key, value)
25601 
      for key, value in self.__dict__.iteritems()]
25602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25603 
 
25604 
  def __eq__(self, other):
25605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25606 
 
25607 
  def __ne__(self, other):
25608 
    return not (self == other)
5553 rajveer 25609 
 
25610 
class getReceivePendingOrders_args:
25611 
  """
25612 
  Attributes:
25613 
   - storeId
25614 
  """
25615 
 
25616 
  thrift_spec = (
25617 
    None, # 0
25618 
    (1, TType.I64, 'storeId', None, None, ), # 1
25619 
  )
25620 
 
25621 
  def __init__(self, storeId=None,):
25622 
    self.storeId = storeId
25623 
 
25624 
  def read(self, iprot):
25625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25627 
      return
25628 
    iprot.readStructBegin()
25629 
    while True:
25630 
      (fname, ftype, fid) = iprot.readFieldBegin()
25631 
      if ftype == TType.STOP:
25632 
        break
25633 
      if fid == 1:
25634 
        if ftype == TType.I64:
25635 
          self.storeId = iprot.readI64();
25636 
        else:
25637 
          iprot.skip(ftype)
25638 
      else:
25639 
        iprot.skip(ftype)
25640 
      iprot.readFieldEnd()
25641 
    iprot.readStructEnd()
25642 
 
25643 
  def write(self, oprot):
25644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25646 
      return
25647 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25648 
    if self.storeId is not None:
25649 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25650 
      oprot.writeI64(self.storeId)
25651 
      oprot.writeFieldEnd()
25652 
    oprot.writeFieldStop()
25653 
    oprot.writeStructEnd()
25654 
 
25655 
  def validate(self):
25656 
    return
25657 
 
25658 
 
25659 
  def __repr__(self):
25660 
    L = ['%s=%r' % (key, value)
25661 
      for key, value in self.__dict__.iteritems()]
25662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25663 
 
25664 
  def __eq__(self, other):
25665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25666 
 
25667 
  def __ne__(self, other):
25668 
    return not (self == other)
25669 
 
25670 
class getReceivePendingOrders_result:
25671 
  """
25672 
  Attributes:
25673 
   - success
25674 
  """
25675 
 
25676 
  thrift_spec = (
25677 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25678 
  )
25679 
 
25680 
  def __init__(self, success=None,):
25681 
    self.success = success
25682 
 
25683 
  def read(self, iprot):
25684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25686 
      return
25687 
    iprot.readStructBegin()
25688 
    while True:
25689 
      (fname, ftype, fid) = iprot.readFieldBegin()
25690 
      if ftype == TType.STOP:
25691 
        break
25692 
      if fid == 0:
25693 
        if ftype == TType.LIST:
25694 
          self.success = []
6188 rajveer 25695 
          (_etype638, _size635) = iprot.readListBegin()
25696 
          for _i639 in xrange(_size635):
25697 
            _elem640 = Order()
25698 
            _elem640.read(iprot)
25699 
            self.success.append(_elem640)
5553 rajveer 25700 
          iprot.readListEnd()
25701 
        else:
25702 
          iprot.skip(ftype)
25703 
      else:
25704 
        iprot.skip(ftype)
25705 
      iprot.readFieldEnd()
25706 
    iprot.readStructEnd()
25707 
 
25708 
  def write(self, oprot):
25709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25711 
      return
25712 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25713 
    if self.success is not None:
25714 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25715 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25716 
      for iter641 in self.success:
25717 
        iter641.write(oprot)
5553 rajveer 25718 
      oprot.writeListEnd()
25719 
      oprot.writeFieldEnd()
25720 
    oprot.writeFieldStop()
25721 
    oprot.writeStructEnd()
25722 
 
25723 
  def validate(self):
25724 
    return
25725 
 
25726 
 
25727 
  def __repr__(self):
25728 
    L = ['%s=%r' % (key, value)
25729 
      for key, value in self.__dict__.iteritems()]
25730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25731 
 
25732 
  def __eq__(self, other):
25733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25734 
 
25735 
  def __ne__(self, other):
25736 
    return not (self == other)
25737 
 
25738 
class getReceivedAtStoreOrders_args:
25739 
  """
25740 
  Attributes:
25741 
   - storeId
25742 
  """
25743 
 
25744 
  thrift_spec = (
25745 
    None, # 0
25746 
    (1, TType.I64, 'storeId', None, None, ), # 1
25747 
  )
25748 
 
25749 
  def __init__(self, storeId=None,):
25750 
    self.storeId = storeId
25751 
 
25752 
  def read(self, iprot):
25753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25755 
      return
25756 
    iprot.readStructBegin()
25757 
    while True:
25758 
      (fname, ftype, fid) = iprot.readFieldBegin()
25759 
      if ftype == TType.STOP:
25760 
        break
25761 
      if fid == 1:
25762 
        if ftype == TType.I64:
25763 
          self.storeId = iprot.readI64();
25764 
        else:
25765 
          iprot.skip(ftype)
25766 
      else:
25767 
        iprot.skip(ftype)
25768 
      iprot.readFieldEnd()
25769 
    iprot.readStructEnd()
25770 
 
25771 
  def write(self, oprot):
25772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25774 
      return
25775 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25776 
    if self.storeId is not None:
25777 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25778 
      oprot.writeI64(self.storeId)
25779 
      oprot.writeFieldEnd()
25780 
    oprot.writeFieldStop()
25781 
    oprot.writeStructEnd()
25782 
 
25783 
  def validate(self):
25784 
    return
25785 
 
25786 
 
25787 
  def __repr__(self):
25788 
    L = ['%s=%r' % (key, value)
25789 
      for key, value in self.__dict__.iteritems()]
25790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25791 
 
25792 
  def __eq__(self, other):
25793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25794 
 
25795 
  def __ne__(self, other):
25796 
    return not (self == other)
25797 
 
25798 
class getReceivedAtStoreOrders_result:
25799 
  """
25800 
  Attributes:
25801 
   - success
25802 
  """
25803 
 
25804 
  thrift_spec = (
25805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25806 
  )
25807 
 
25808 
  def __init__(self, success=None,):
25809 
    self.success = success
25810 
 
25811 
  def read(self, iprot):
25812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25814 
      return
25815 
    iprot.readStructBegin()
25816 
    while True:
25817 
      (fname, ftype, fid) = iprot.readFieldBegin()
25818 
      if ftype == TType.STOP:
25819 
        break
25820 
      if fid == 0:
25821 
        if ftype == TType.LIST:
25822 
          self.success = []
6188 rajveer 25823 
          (_etype645, _size642) = iprot.readListBegin()
25824 
          for _i646 in xrange(_size642):
25825 
            _elem647 = Order()
25826 
            _elem647.read(iprot)
25827 
            self.success.append(_elem647)
5553 rajveer 25828 
          iprot.readListEnd()
25829 
        else:
25830 
          iprot.skip(ftype)
25831 
      else:
25832 
        iprot.skip(ftype)
25833 
      iprot.readFieldEnd()
25834 
    iprot.readStructEnd()
25835 
 
25836 
  def write(self, oprot):
25837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25839 
      return
25840 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25841 
    if self.success is not None:
25842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25843 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25844 
      for iter648 in self.success:
25845 
        iter648.write(oprot)
5553 rajveer 25846 
      oprot.writeListEnd()
25847 
      oprot.writeFieldEnd()
25848 
    oprot.writeFieldStop()
25849 
    oprot.writeStructEnd()
25850 
 
25851 
  def validate(self):
25852 
    return
25853 
 
25854 
 
25855 
  def __repr__(self):
25856 
    L = ['%s=%r' % (key, value)
25857 
      for key, value in self.__dict__.iteritems()]
25858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25859 
 
25860 
  def __eq__(self, other):
25861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25862 
 
25863 
  def __ne__(self, other):
25864 
    return not (self == other)
5593 mandeep.dh 25865 
 
5713 rajveer 25866 
class getOrdersCollectionAtStore_args:
25867 
  """
25868 
  Attributes:
25869 
   - storeId
25870 
   - fromDate
25871 
   - toDate
25872 
   - onlyCod
25873 
  """
25874 
 
25875 
  thrift_spec = (
25876 
    None, # 0
25877 
    (1, TType.I64, 'storeId', None, None, ), # 1
25878 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25879 
    (3, TType.I64, 'toDate', None, None, ), # 3
25880 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25881 
  )
25882 
 
25883 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25884 
    self.storeId = storeId
25885 
    self.fromDate = fromDate
25886 
    self.toDate = toDate
25887 
    self.onlyCod = onlyCod
25888 
 
25889 
  def read(self, iprot):
25890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25892 
      return
25893 
    iprot.readStructBegin()
25894 
    while True:
25895 
      (fname, ftype, fid) = iprot.readFieldBegin()
25896 
      if ftype == TType.STOP:
25897 
        break
25898 
      if fid == 1:
25899 
        if ftype == TType.I64:
25900 
          self.storeId = iprot.readI64();
25901 
        else:
25902 
          iprot.skip(ftype)
25903 
      elif fid == 2:
25904 
        if ftype == TType.I64:
25905 
          self.fromDate = iprot.readI64();
25906 
        else:
25907 
          iprot.skip(ftype)
25908 
      elif fid == 3:
25909 
        if ftype == TType.I64:
25910 
          self.toDate = iprot.readI64();
25911 
        else:
25912 
          iprot.skip(ftype)
25913 
      elif fid == 4:
25914 
        if ftype == TType.BOOL:
25915 
          self.onlyCod = iprot.readBool();
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('getOrdersCollectionAtStore_args')
25928 
    if self.storeId is not None:
25929 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25930 
      oprot.writeI64(self.storeId)
25931 
      oprot.writeFieldEnd()
25932 
    if self.fromDate is not None:
25933 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25934 
      oprot.writeI64(self.fromDate)
25935 
      oprot.writeFieldEnd()
25936 
    if self.toDate is not None:
25937 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25938 
      oprot.writeI64(self.toDate)
25939 
      oprot.writeFieldEnd()
25940 
    if self.onlyCod is not None:
25941 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25942 
      oprot.writeBool(self.onlyCod)
25943 
      oprot.writeFieldEnd()
25944 
    oprot.writeFieldStop()
25945 
    oprot.writeStructEnd()
25946 
 
25947 
  def validate(self):
25948 
    return
25949 
 
25950 
 
25951 
  def __repr__(self):
25952 
    L = ['%s=%r' % (key, value)
25953 
      for key, value in self.__dict__.iteritems()]
25954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25955 
 
25956 
  def __eq__(self, other):
25957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25958 
 
25959 
  def __ne__(self, other):
25960 
    return not (self == other)
25961 
 
25962 
class getOrdersCollectionAtStore_result:
25963 
  """
25964 
  Attributes:
25965 
   - success
25966 
  """
25967 
 
25968 
  thrift_spec = (
25969 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25970 
  )
25971 
 
25972 
  def __init__(self, success=None,):
25973 
    self.success = success
25974 
 
25975 
  def read(self, iprot):
25976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25978 
      return
25979 
    iprot.readStructBegin()
25980 
    while True:
25981 
      (fname, ftype, fid) = iprot.readFieldBegin()
25982 
      if ftype == TType.STOP:
25983 
        break
25984 
      if fid == 0:
25985 
        if ftype == TType.LIST:
25986 
          self.success = []
6188 rajveer 25987 
          (_etype652, _size649) = iprot.readListBegin()
25988 
          for _i653 in xrange(_size649):
25989 
            _elem654 = Order()
25990 
            _elem654.read(iprot)
25991 
            self.success.append(_elem654)
5713 rajveer 25992 
          iprot.readListEnd()
25993 
        else:
25994 
          iprot.skip(ftype)
25995 
      else:
25996 
        iprot.skip(ftype)
25997 
      iprot.readFieldEnd()
25998 
    iprot.readStructEnd()
25999 
 
26000 
  def write(self, oprot):
26001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26003 
      return
26004 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26005 
    if self.success is not None:
26006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26008 
      for iter655 in self.success:
26009 
        iter655.write(oprot)
5713 rajveer 26010 
      oprot.writeListEnd()
26011 
      oprot.writeFieldEnd()
26012 
    oprot.writeFieldStop()
26013 
    oprot.writeStructEnd()
26014 
 
26015 
  def validate(self):
26016 
    return
26017 
 
26018 
 
26019 
  def __repr__(self):
26020 
    L = ['%s=%r' % (key, value)
26021 
      for key, value in self.__dict__.iteritems()]
26022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26023 
 
26024 
  def __eq__(self, other):
26025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26026 
 
26027 
  def __ne__(self, other):
26028 
    return not (self == other)
26029 
 
5833 rajveer 26030 
class getOrderAttributeValue_args:
26031 
  """
26032 
  Attributes:
26033 
   - orderId
26034 
   - attributeName
26035 
  """
26036 
 
26037 
  thrift_spec = None
26038 
  def __init__(self, orderId=None, attributeName=None,):
26039 
    self.orderId = orderId
26040 
    self.attributeName = attributeName
26041 
 
26042 
  def read(self, iprot):
26043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26045 
      return
26046 
    iprot.readStructBegin()
26047 
    while True:
26048 
      (fname, ftype, fid) = iprot.readFieldBegin()
26049 
      if ftype == TType.STOP:
26050 
        break
26051 
      if fid == 1:
26052 
        if ftype == TType.I64:
26053 
          self.orderId = iprot.readI64();
26054 
        else:
26055 
          iprot.skip(ftype)
26056 
      elif fid == -1:
26057 
        if ftype == TType.STRING:
26058 
          self.attributeName = iprot.readString();
26059 
        else:
26060 
          iprot.skip(ftype)
26061 
      else:
26062 
        iprot.skip(ftype)
26063 
      iprot.readFieldEnd()
26064 
    iprot.readStructEnd()
26065 
 
26066 
  def write(self, oprot):
26067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26069 
      return
26070 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26071 
    if self.attributeName is not None:
26072 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26073 
      oprot.writeString(self.attributeName)
26074 
      oprot.writeFieldEnd()
26075 
    if self.orderId is not None:
26076 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26077 
      oprot.writeI64(self.orderId)
26078 
      oprot.writeFieldEnd()
26079 
    oprot.writeFieldStop()
26080 
    oprot.writeStructEnd()
26081 
 
26082 
  def validate(self):
26083 
    return
26084 
 
26085 
 
26086 
  def __repr__(self):
26087 
    L = ['%s=%r' % (key, value)
26088 
      for key, value in self.__dict__.iteritems()]
26089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26090 
 
26091 
  def __eq__(self, other):
26092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26093 
 
26094 
  def __ne__(self, other):
26095 
    return not (self == other)
26096 
 
26097 
class getOrderAttributeValue_result:
26098 
  """
26099 
  Attributes:
26100 
   - success
26101 
  """
26102 
 
26103 
  thrift_spec = (
26104 
    (0, TType.STRING, 'success', None, None, ), # 0
26105 
  )
26106 
 
26107 
  def __init__(self, success=None,):
26108 
    self.success = success
26109 
 
26110 
  def read(self, iprot):
26111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26113 
      return
26114 
    iprot.readStructBegin()
26115 
    while True:
26116 
      (fname, ftype, fid) = iprot.readFieldBegin()
26117 
      if ftype == TType.STOP:
26118 
        break
26119 
      if fid == 0:
26120 
        if ftype == TType.STRING:
26121 
          self.success = iprot.readString();
26122 
        else:
26123 
          iprot.skip(ftype)
26124 
      else:
26125 
        iprot.skip(ftype)
26126 
      iprot.readFieldEnd()
26127 
    iprot.readStructEnd()
26128 
 
26129 
  def write(self, oprot):
26130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26132 
      return
26133 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26134 
    if self.success is not None:
26135 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26136 
      oprot.writeString(self.success)
26137 
      oprot.writeFieldEnd()
26138 
    oprot.writeFieldStop()
26139 
    oprot.writeStructEnd()
26140 
 
26141 
  def validate(self):
26142 
    return
26143 
 
26144 
 
26145 
  def __repr__(self):
26146 
    L = ['%s=%r' % (key, value)
26147 
      for key, value in self.__dict__.iteritems()]
26148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26149 
 
26150 
  def __eq__(self, other):
26151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26152 
 
26153 
  def __ne__(self, other):
26154 
    return not (self == other)
26155 
 
6019 rajveer 26156 
class changeJacketNumber_args:
26157 
  """
26158 
  Attributes:
26159 
   - orderId
26160 
   - jacketNumber
26161 
  """
26162 
 
26163 
  thrift_spec = (
26164 
    None, # 0
26165 
    (1, TType.I64, 'orderId', None, None, ), # 1
26166 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26167 
  )
26168 
 
26169 
  def __init__(self, orderId=None, jacketNumber=None,):
26170 
    self.orderId = orderId
26171 
    self.jacketNumber = jacketNumber
26172 
 
26173 
  def read(self, iprot):
26174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26176 
      return
26177 
    iprot.readStructBegin()
26178 
    while True:
26179 
      (fname, ftype, fid) = iprot.readFieldBegin()
26180 
      if ftype == TType.STOP:
26181 
        break
26182 
      if fid == 1:
26183 
        if ftype == TType.I64:
26184 
          self.orderId = iprot.readI64();
26185 
        else:
26186 
          iprot.skip(ftype)
26187 
      elif fid == 2:
26188 
        if ftype == TType.I64:
26189 
          self.jacketNumber = iprot.readI64();
26190 
        else:
26191 
          iprot.skip(ftype)
26192 
      else:
26193 
        iprot.skip(ftype)
26194 
      iprot.readFieldEnd()
26195 
    iprot.readStructEnd()
26196 
 
26197 
  def write(self, oprot):
26198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26200 
      return
26201 
    oprot.writeStructBegin('changeJacketNumber_args')
26202 
    if self.orderId is not None:
26203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26204 
      oprot.writeI64(self.orderId)
26205 
      oprot.writeFieldEnd()
26206 
    if self.jacketNumber is not None:
26207 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26208 
      oprot.writeI64(self.jacketNumber)
26209 
      oprot.writeFieldEnd()
26210 
    oprot.writeFieldStop()
26211 
    oprot.writeStructEnd()
26212 
 
26213 
  def validate(self):
26214 
    return
26215 
 
26216 
 
26217 
  def __repr__(self):
26218 
    L = ['%s=%r' % (key, value)
26219 
      for key, value in self.__dict__.iteritems()]
26220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26221 
 
26222 
  def __eq__(self, other):
26223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26224 
 
26225 
  def __ne__(self, other):
26226 
    return not (self == other)
26227 
 
26228 
class changeJacketNumber_result:
26229 
  """
26230 
  Attributes:
26231 
   - success
26232 
  """
26233 
 
26234 
  thrift_spec = (
26235 
    (0, TType.BOOL, 'success', None, None, ), # 0
26236 
  )
26237 
 
26238 
  def __init__(self, success=None,):
26239 
    self.success = success
26240 
 
26241 
  def read(self, iprot):
26242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26244 
      return
26245 
    iprot.readStructBegin()
26246 
    while True:
26247 
      (fname, ftype, fid) = iprot.readFieldBegin()
26248 
      if ftype == TType.STOP:
26249 
        break
26250 
      if fid == 0:
26251 
        if ftype == TType.BOOL:
26252 
          self.success = iprot.readBool();
26253 
        else:
26254 
          iprot.skip(ftype)
26255 
      else:
26256 
        iprot.skip(ftype)
26257 
      iprot.readFieldEnd()
26258 
    iprot.readStructEnd()
26259 
 
26260 
  def write(self, oprot):
26261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26263 
      return
26264 
    oprot.writeStructBegin('changeJacketNumber_result')
26265 
    if self.success is not None:
26266 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26267 
      oprot.writeBool(self.success)
26268 
      oprot.writeFieldEnd()
26269 
    oprot.writeFieldStop()
26270 
    oprot.writeStructEnd()
26271 
 
26272 
  def validate(self):
26273 
    return
26274 
 
26275 
 
26276 
  def __repr__(self):
26277 
    L = ['%s=%r' % (key, value)
26278 
      for key, value in self.__dict__.iteritems()]
26279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26280 
 
26281 
  def __eq__(self, other):
26282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26283 
 
26284 
  def __ne__(self, other):
26285 
    return not (self == other)
26286 
 
26287 
class markOrderAsRtoInTransit_args:
26288 
  """
26289 
  Attributes:
26290 
   - orderId
26291 
  """
26292 
 
26293 
  thrift_spec = (
26294 
    None, # 0
26295 
    (1, TType.I64, 'orderId', None, None, ), # 1
26296 
  )
26297 
 
26298 
  def __init__(self, orderId=None,):
26299 
    self.orderId = orderId
26300 
 
26301 
  def read(self, iprot):
26302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26304 
      return
26305 
    iprot.readStructBegin()
26306 
    while True:
26307 
      (fname, ftype, fid) = iprot.readFieldBegin()
26308 
      if ftype == TType.STOP:
26309 
        break
26310 
      if fid == 1:
26311 
        if ftype == TType.I64:
26312 
          self.orderId = iprot.readI64();
26313 
        else:
26314 
          iprot.skip(ftype)
26315 
      else:
26316 
        iprot.skip(ftype)
26317 
      iprot.readFieldEnd()
26318 
    iprot.readStructEnd()
26319 
 
26320 
  def write(self, oprot):
26321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26323 
      return
26324 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26325 
    if self.orderId is not None:
26326 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26327 
      oprot.writeI64(self.orderId)
26328 
      oprot.writeFieldEnd()
26329 
    oprot.writeFieldStop()
26330 
    oprot.writeStructEnd()
26331 
 
26332 
  def validate(self):
26333 
    return
26334 
 
26335 
 
26336 
  def __repr__(self):
26337 
    L = ['%s=%r' % (key, value)
26338 
      for key, value in self.__dict__.iteritems()]
26339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26340 
 
26341 
  def __eq__(self, other):
26342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26343 
 
26344 
  def __ne__(self, other):
26345 
    return not (self == other)
26346 
 
26347 
class markOrderAsRtoInTransit_result:
26348 
  """
26349 
  Attributes:
26350 
   - success
26351 
  """
26352 
 
26353 
  thrift_spec = (
26354 
    (0, TType.BOOL, 'success', None, None, ), # 0
26355 
  )
26356 
 
26357 
  def __init__(self, success=None,):
26358 
    self.success = success
26359 
 
26360 
  def read(self, iprot):
26361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26363 
      return
26364 
    iprot.readStructBegin()
26365 
    while True:
26366 
      (fname, ftype, fid) = iprot.readFieldBegin()
26367 
      if ftype == TType.STOP:
26368 
        break
26369 
      if fid == 0:
26370 
        if ftype == TType.BOOL:
26371 
          self.success = iprot.readBool();
26372 
        else:
26373 
          iprot.skip(ftype)
26374 
      else:
26375 
        iprot.skip(ftype)
26376 
      iprot.readFieldEnd()
26377 
    iprot.readStructEnd()
26378 
 
26379 
  def write(self, oprot):
26380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26382 
      return
26383 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26384 
    if self.success is not None:
26385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26386 
      oprot.writeBool(self.success)
26387 
      oprot.writeFieldEnd()
26388 
    oprot.writeFieldStop()
26389 
    oprot.writeStructEnd()
26390 
 
26391 
  def validate(self):
26392 
    return
26393 
 
26394 
 
26395 
  def __repr__(self):
26396 
    L = ['%s=%r' % (key, value)
26397 
      for key, value in self.__dict__.iteritems()]
26398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26399 
 
26400 
  def __eq__(self, other):
26401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26402 
 
26403 
  def __ne__(self, other):
26404 
    return not (self == other)
26405 
 
5593 mandeep.dh 26406 
class acceptOrderForItem_args:
26407 
  """
26408 
  Attributes:
26409 
   - itemId
26410 
   - quantity
26411 
   - fulfilmentWarehouseId
26412 
   - billingWarehouseId
26413 
  """
26414 
 
26415 
  thrift_spec = (
26416 
    None, # 0
26417 
    (1, TType.I64, 'itemId', None, None, ), # 1
26418 
    (2, TType.I64, 'quantity', None, None, ), # 2
26419 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26420 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26421 
  )
26422 
 
26423 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26424 
    self.itemId = itemId
26425 
    self.quantity = quantity
26426 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26427 
    self.billingWarehouseId = billingWarehouseId
26428 
 
26429 
  def read(self, iprot):
26430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26432 
      return
26433 
    iprot.readStructBegin()
26434 
    while True:
26435 
      (fname, ftype, fid) = iprot.readFieldBegin()
26436 
      if ftype == TType.STOP:
26437 
        break
26438 
      if fid == 1:
26439 
        if ftype == TType.I64:
26440 
          self.itemId = iprot.readI64();
26441 
        else:
26442 
          iprot.skip(ftype)
26443 
      elif fid == 2:
26444 
        if ftype == TType.I64:
26445 
          self.quantity = iprot.readI64();
26446 
        else:
26447 
          iprot.skip(ftype)
26448 
      elif fid == 3:
26449 
        if ftype == TType.I64:
26450 
          self.fulfilmentWarehouseId = iprot.readI64();
26451 
        else:
26452 
          iprot.skip(ftype)
26453 
      elif fid == 4:
26454 
        if ftype == TType.I64:
26455 
          self.billingWarehouseId = iprot.readI64();
26456 
        else:
26457 
          iprot.skip(ftype)
26458 
      else:
26459 
        iprot.skip(ftype)
26460 
      iprot.readFieldEnd()
26461 
    iprot.readStructEnd()
26462 
 
26463 
  def write(self, oprot):
26464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26466 
      return
26467 
    oprot.writeStructBegin('acceptOrderForItem_args')
26468 
    if self.itemId is not None:
26469 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26470 
      oprot.writeI64(self.itemId)
26471 
      oprot.writeFieldEnd()
26472 
    if self.quantity is not None:
26473 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26474 
      oprot.writeI64(self.quantity)
26475 
      oprot.writeFieldEnd()
26476 
    if self.fulfilmentWarehouseId is not None:
26477 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26478 
      oprot.writeI64(self.fulfilmentWarehouseId)
26479 
      oprot.writeFieldEnd()
26480 
    if self.billingWarehouseId is not None:
26481 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26482 
      oprot.writeI64(self.billingWarehouseId)
26483 
      oprot.writeFieldEnd()
26484 
    oprot.writeFieldStop()
26485 
    oprot.writeStructEnd()
26486 
 
26487 
  def validate(self):
26488 
    return
26489 
 
26490 
 
26491 
  def __repr__(self):
26492 
    L = ['%s=%r' % (key, value)
26493 
      for key, value in self.__dict__.iteritems()]
26494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26495 
 
26496 
  def __eq__(self, other):
26497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26498 
 
26499 
  def __ne__(self, other):
26500 
    return not (self == other)
26501 
 
26502 
class acceptOrderForItem_result:
26503 
 
26504 
  thrift_spec = (
26505 
  )
26506 
 
26507 
  def read(self, iprot):
26508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26510 
      return
26511 
    iprot.readStructBegin()
26512 
    while True:
26513 
      (fname, ftype, fid) = iprot.readFieldBegin()
26514 
      if ftype == TType.STOP:
26515 
        break
26516 
      else:
26517 
        iprot.skip(ftype)
26518 
      iprot.readFieldEnd()
26519 
    iprot.readStructEnd()
26520 
 
26521 
  def write(self, oprot):
26522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26524 
      return
26525 
    oprot.writeStructBegin('acceptOrderForItem_result')
26526 
    oprot.writeFieldStop()
26527 
    oprot.writeStructEnd()
26528 
 
26529 
  def validate(self):
26530 
    return
26531 
 
26532 
 
26533 
  def __repr__(self):
26534 
    L = ['%s=%r' % (key, value)
26535 
      for key, value in self.__dict__.iteritems()]
26536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26537 
 
26538 
  def __eq__(self, other):
26539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26540 
 
26541 
  def __ne__(self, other):
26542 
    return not (self == other)
6000 mandeep.dh 26543 
 
26544 
class createRechargeOrder_args:
26545 
  """
26546 
  Attributes:
26547 
   - rechargeOrder
26548 
  """
26549 
 
26550 
  thrift_spec = (
26551 
    None, # 0
26552 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26553 
  )
26554 
 
26555 
  def __init__(self, rechargeOrder=None,):
26556 
    self.rechargeOrder = rechargeOrder
26557 
 
26558 
  def read(self, iprot):
26559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26561 
      return
26562 
    iprot.readStructBegin()
26563 
    while True:
26564 
      (fname, ftype, fid) = iprot.readFieldBegin()
26565 
      if ftype == TType.STOP:
26566 
        break
26567 
      if fid == 1:
26568 
        if ftype == TType.STRUCT:
26569 
          self.rechargeOrder = RechargeOrder()
26570 
          self.rechargeOrder.read(iprot)
26571 
        else:
26572 
          iprot.skip(ftype)
26573 
      else:
26574 
        iprot.skip(ftype)
26575 
      iprot.readFieldEnd()
26576 
    iprot.readStructEnd()
26577 
 
26578 
  def write(self, oprot):
26579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26581 
      return
26582 
    oprot.writeStructBegin('createRechargeOrder_args')
26583 
    if self.rechargeOrder is not None:
26584 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26585 
      self.rechargeOrder.write(oprot)
26586 
      oprot.writeFieldEnd()
26587 
    oprot.writeFieldStop()
26588 
    oprot.writeStructEnd()
26589 
 
26590 
  def validate(self):
26591 
    return
26592 
 
26593 
 
26594 
  def __repr__(self):
26595 
    L = ['%s=%r' % (key, value)
26596 
      for key, value in self.__dict__.iteritems()]
26597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26598 
 
26599 
  def __eq__(self, other):
26600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26601 
 
26602 
  def __ne__(self, other):
26603 
    return not (self == other)
26604 
 
26605 
class createRechargeOrder_result:
26606 
  """
26607 
  Attributes:
26608 
   - success
26609 
   - ex
26610 
  """
26611 
 
26612 
  thrift_spec = (
26613 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26614 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26615 
  )
26616 
 
26617 
  def __init__(self, success=None, ex=None,):
26618 
    self.success = success
26619 
    self.ex = ex
26620 
 
26621 
  def read(self, iprot):
26622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26624 
      return
26625 
    iprot.readStructBegin()
26626 
    while True:
26627 
      (fname, ftype, fid) = iprot.readFieldBegin()
26628 
      if ftype == TType.STOP:
26629 
        break
26630 
      if fid == 0:
26631 
        if ftype == TType.STRUCT:
26632 
          self.success = RechargeOrder()
26633 
          self.success.read(iprot)
26634 
        else:
26635 
          iprot.skip(ftype)
26636 
      elif fid == 1:
26637 
        if ftype == TType.STRUCT:
26638 
          self.ex = TransactionServiceException()
26639 
          self.ex.read(iprot)
26640 
        else:
26641 
          iprot.skip(ftype)
26642 
      else:
26643 
        iprot.skip(ftype)
26644 
      iprot.readFieldEnd()
26645 
    iprot.readStructEnd()
26646 
 
26647 
  def write(self, oprot):
26648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26650 
      return
26651 
    oprot.writeStructBegin('createRechargeOrder_result')
26652 
    if self.success is not None:
26653 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26654 
      self.success.write(oprot)
26655 
      oprot.writeFieldEnd()
26656 
    if self.ex is not None:
26657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26658 
      self.ex.write(oprot)
26659 
      oprot.writeFieldEnd()
26660 
    oprot.writeFieldStop()
26661 
    oprot.writeStructEnd()
26662 
 
26663 
  def validate(self):
26664 
    return
26665 
 
26666 
 
26667 
  def __repr__(self):
26668 
    L = ['%s=%r' % (key, value)
26669 
      for key, value in self.__dict__.iteritems()]
26670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26671 
 
26672 
  def __eq__(self, other):
26673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26674 
 
26675 
  def __ne__(self, other):
26676 
    return not (self == other)
26677 
 
6031 rajveer 26678 
class getRechargeOrder_args:
26679 
  """
26680 
  Attributes:
26681 
   - rechargeRrderId
26682 
  """
26683 
 
26684 
  thrift_spec = (
26685 
    None, # 0
26686 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26687 
  )
26688 
 
26689 
  def __init__(self, rechargeRrderId=None,):
26690 
    self.rechargeRrderId = rechargeRrderId
26691 
 
26692 
  def read(self, iprot):
26693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26695 
      return
26696 
    iprot.readStructBegin()
26697 
    while True:
26698 
      (fname, ftype, fid) = iprot.readFieldBegin()
26699 
      if ftype == TType.STOP:
26700 
        break
26701 
      if fid == 1:
26702 
        if ftype == TType.I64:
26703 
          self.rechargeRrderId = iprot.readI64();
26704 
        else:
26705 
          iprot.skip(ftype)
26706 
      else:
26707 
        iprot.skip(ftype)
26708 
      iprot.readFieldEnd()
26709 
    iprot.readStructEnd()
26710 
 
26711 
  def write(self, oprot):
26712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26714 
      return
26715 
    oprot.writeStructBegin('getRechargeOrder_args')
26716 
    if self.rechargeRrderId is not None:
26717 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26718 
      oprot.writeI64(self.rechargeRrderId)
26719 
      oprot.writeFieldEnd()
26720 
    oprot.writeFieldStop()
26721 
    oprot.writeStructEnd()
26722 
 
26723 
  def validate(self):
26724 
    return
26725 
 
26726 
 
26727 
  def __repr__(self):
26728 
    L = ['%s=%r' % (key, value)
26729 
      for key, value in self.__dict__.iteritems()]
26730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26731 
 
26732 
  def __eq__(self, other):
26733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26734 
 
26735 
  def __ne__(self, other):
26736 
    return not (self == other)
26737 
 
26738 
class getRechargeOrder_result:
26739 
  """
26740 
  Attributes:
26741 
   - success
26742 
   - ex
26743 
  """
26744 
 
26745 
  thrift_spec = (
26746 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26748 
  )
26749 
 
26750 
  def __init__(self, success=None, ex=None,):
26751 
    self.success = success
26752 
    self.ex = ex
26753 
 
26754 
  def read(self, iprot):
26755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26757 
      return
26758 
    iprot.readStructBegin()
26759 
    while True:
26760 
      (fname, ftype, fid) = iprot.readFieldBegin()
26761 
      if ftype == TType.STOP:
26762 
        break
26763 
      if fid == 0:
26764 
        if ftype == TType.STRUCT:
26765 
          self.success = RechargeOrder()
26766 
          self.success.read(iprot)
26767 
        else:
26768 
          iprot.skip(ftype)
26769 
      elif fid == 1:
26770 
        if ftype == TType.STRUCT:
26771 
          self.ex = TransactionServiceException()
26772 
          self.ex.read(iprot)
26773 
        else:
26774 
          iprot.skip(ftype)
26775 
      else:
26776 
        iprot.skip(ftype)
26777 
      iprot.readFieldEnd()
26778 
    iprot.readStructEnd()
26779 
 
26780 
  def write(self, oprot):
26781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26783 
      return
26784 
    oprot.writeStructBegin('getRechargeOrder_result')
26785 
    if self.success is not None:
26786 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26787 
      self.success.write(oprot)
26788 
      oprot.writeFieldEnd()
26789 
    if self.ex is not None:
26790 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26791 
      self.ex.write(oprot)
26792 
      oprot.writeFieldEnd()
26793 
    oprot.writeFieldStop()
26794 
    oprot.writeStructEnd()
26795 
 
26796 
  def validate(self):
26797 
    return
26798 
 
26799 
 
26800 
  def __repr__(self):
26801 
    L = ['%s=%r' % (key, value)
26802 
      for key, value in self.__dict__.iteritems()]
26803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26804 
 
26805 
  def __eq__(self, other):
26806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26807 
 
26808 
  def __ne__(self, other):
26809 
    return not (self == other)
26810 
 
26811 
class getRechargeOrders_args:
26812 
  """
26813 
  Attributes:
26814 
   - userId
26815 
  """
26816 
 
26817 
  thrift_spec = (
26818 
    None, # 0
26819 
    (1, TType.I64, 'userId', None, None, ), # 1
26820 
  )
26821 
 
26822 
  def __init__(self, userId=None,):
26823 
    self.userId = userId
26824 
 
26825 
  def read(self, iprot):
26826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26828 
      return
26829 
    iprot.readStructBegin()
26830 
    while True:
26831 
      (fname, ftype, fid) = iprot.readFieldBegin()
26832 
      if ftype == TType.STOP:
26833 
        break
26834 
      if fid == 1:
26835 
        if ftype == TType.I64:
26836 
          self.userId = iprot.readI64();
26837 
        else:
26838 
          iprot.skip(ftype)
26839 
      else:
26840 
        iprot.skip(ftype)
26841 
      iprot.readFieldEnd()
26842 
    iprot.readStructEnd()
26843 
 
26844 
  def write(self, oprot):
26845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26847 
      return
26848 
    oprot.writeStructBegin('getRechargeOrders_args')
26849 
    if self.userId is not None:
26850 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26851 
      oprot.writeI64(self.userId)
26852 
      oprot.writeFieldEnd()
26853 
    oprot.writeFieldStop()
26854 
    oprot.writeStructEnd()
26855 
 
26856 
  def validate(self):
26857 
    return
26858 
 
26859 
 
26860 
  def __repr__(self):
26861 
    L = ['%s=%r' % (key, value)
26862 
      for key, value in self.__dict__.iteritems()]
26863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26864 
 
26865 
  def __eq__(self, other):
26866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26867 
 
26868 
  def __ne__(self, other):
26869 
    return not (self == other)
26870 
 
26871 
class getRechargeOrders_result:
26872 
  """
26873 
  Attributes:
26874 
   - success
26875 
  """
26876 
 
26877 
  thrift_spec = (
26878 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26879 
  )
26880 
 
26881 
  def __init__(self, success=None,):
26882 
    self.success = success
26883 
 
26884 
  def read(self, iprot):
26885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26887 
      return
26888 
    iprot.readStructBegin()
26889 
    while True:
26890 
      (fname, ftype, fid) = iprot.readFieldBegin()
26891 
      if ftype == TType.STOP:
26892 
        break
26893 
      if fid == 0:
26894 
        if ftype == TType.LIST:
26895 
          self.success = []
6188 rajveer 26896 
          (_etype659, _size656) = iprot.readListBegin()
26897 
          for _i660 in xrange(_size656):
26898 
            _elem661 = RechargeOrder()
26899 
            _elem661.read(iprot)
26900 
            self.success.append(_elem661)
6031 rajveer 26901 
          iprot.readListEnd()
26902 
        else:
26903 
          iprot.skip(ftype)
26904 
      else:
26905 
        iprot.skip(ftype)
26906 
      iprot.readFieldEnd()
26907 
    iprot.readStructEnd()
26908 
 
26909 
  def write(self, oprot):
26910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26912 
      return
26913 
    oprot.writeStructBegin('getRechargeOrders_result')
26914 
    if self.success is not None:
26915 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26916 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26917 
      for iter662 in self.success:
26918 
        iter662.write(oprot)
6031 rajveer 26919 
      oprot.writeListEnd()
26920 
      oprot.writeFieldEnd()
26921 
    oprot.writeFieldStop()
26922 
    oprot.writeStructEnd()
26923 
 
26924 
  def validate(self):
26925 
    return
26926 
 
26927 
 
26928 
  def __repr__(self):
26929 
    L = ['%s=%r' % (key, value)
26930 
      for key, value in self.__dict__.iteritems()]
26931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26932 
 
26933 
  def __eq__(self, other):
26934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26935 
 
26936 
  def __ne__(self, other):
26937 
    return not (self == other)
26938 
 
6000 mandeep.dh 26939 
class updateRechargeOrderStatus_args:
26940 
  """
26941 
  Attributes:
26942 
   - rechargeOrderId
26943 
   - rechargeOrderStatus
26944 
  """
26945 
 
26946 
  thrift_spec = (
26947 
    None, # 0
26948 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26949 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26950 
  )
26951 
 
26952 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26953 
    self.rechargeOrderId = rechargeOrderId
26954 
    self.rechargeOrderStatus = rechargeOrderStatus
26955 
 
26956 
  def read(self, iprot):
26957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26959 
      return
26960 
    iprot.readStructBegin()
26961 
    while True:
26962 
      (fname, ftype, fid) = iprot.readFieldBegin()
26963 
      if ftype == TType.STOP:
26964 
        break
26965 
      if fid == 1:
26966 
        if ftype == TType.I64:
26967 
          self.rechargeOrderId = iprot.readI64();
26968 
        else:
26969 
          iprot.skip(ftype)
26970 
      elif fid == 2:
26971 
        if ftype == TType.I32:
26972 
          self.rechargeOrderStatus = iprot.readI32();
26973 
        else:
26974 
          iprot.skip(ftype)
26975 
      else:
26976 
        iprot.skip(ftype)
26977 
      iprot.readFieldEnd()
26978 
    iprot.readStructEnd()
26979 
 
26980 
  def write(self, oprot):
26981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26983 
      return
26984 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26985 
    if self.rechargeOrderId is not None:
26986 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26987 
      oprot.writeI64(self.rechargeOrderId)
26988 
      oprot.writeFieldEnd()
26989 
    if self.rechargeOrderStatus is not None:
26990 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26991 
      oprot.writeI32(self.rechargeOrderStatus)
26992 
      oprot.writeFieldEnd()
26993 
    oprot.writeFieldStop()
26994 
    oprot.writeStructEnd()
26995 
 
26996 
  def validate(self):
26997 
    return
26998 
 
26999 
 
27000 
  def __repr__(self):
27001 
    L = ['%s=%r' % (key, value)
27002 
      for key, value in self.__dict__.iteritems()]
27003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27004 
 
27005 
  def __eq__(self, other):
27006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27007 
 
27008 
  def __ne__(self, other):
27009 
    return not (self == other)
27010 
 
27011 
class updateRechargeOrderStatus_result:
27012 
  """
27013 
  Attributes:
6031 rajveer 27014 
   - success
6000 mandeep.dh 27015 
   - ex
27016 
  """
27017 
 
27018 
  thrift_spec = (
6031 rajveer 27019 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27021 
  )
27022 
 
6031 rajveer 27023 
  def __init__(self, success=None, ex=None,):
27024 
    self.success = success
6000 mandeep.dh 27025 
    self.ex = ex
27026 
 
27027 
  def read(self, iprot):
27028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27030 
      return
27031 
    iprot.readStructBegin()
27032 
    while True:
27033 
      (fname, ftype, fid) = iprot.readFieldBegin()
27034 
      if ftype == TType.STOP:
27035 
        break
6031 rajveer 27036 
      if fid == 0:
27037 
        if ftype == TType.BOOL:
27038 
          self.success = iprot.readBool();
27039 
        else:
27040 
          iprot.skip(ftype)
27041 
      elif fid == 1:
6000 mandeep.dh 27042 
        if ftype == TType.STRUCT:
27043 
          self.ex = TransactionServiceException()
27044 
          self.ex.read(iprot)
27045 
        else:
27046 
          iprot.skip(ftype)
27047 
      else:
27048 
        iprot.skip(ftype)
27049 
      iprot.readFieldEnd()
27050 
    iprot.readStructEnd()
27051 
 
27052 
  def write(self, oprot):
27053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27055 
      return
27056 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27057 
    if self.success is not None:
27058 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27059 
      oprot.writeBool(self.success)
27060 
      oprot.writeFieldEnd()
6000 mandeep.dh 27061 
    if self.ex is not None:
27062 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27063 
      self.ex.write(oprot)
27064 
      oprot.writeFieldEnd()
27065 
    oprot.writeFieldStop()
27066 
    oprot.writeStructEnd()
27067 
 
27068 
  def validate(self):
27069 
    return
27070 
 
27071 
 
27072 
  def __repr__(self):
27073 
    L = ['%s=%r' % (key, value)
27074 
      for key, value in self.__dict__.iteritems()]
27075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27076 
 
27077 
  def __eq__(self, other):
27078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27079 
 
27080 
  def __ne__(self, other):
27081 
    return not (self == other)
27082 
 
27083 
class activateRechargeTxn_args:
27084 
  """
27085 
  Attributes:
6031 rajveer 27086 
   - rechargeOrderId
6000 mandeep.dh 27087 
  """
27088 
 
27089 
  thrift_spec = (
27090 
    None, # 0
6031 rajveer 27091 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27092 
  )
27093 
 
6031 rajveer 27094 
  def __init__(self, rechargeOrderId=None,):
27095 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27096 
 
27097 
  def read(self, iprot):
27098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27100 
      return
27101 
    iprot.readStructBegin()
27102 
    while True:
27103 
      (fname, ftype, fid) = iprot.readFieldBegin()
27104 
      if ftype == TType.STOP:
27105 
        break
27106 
      if fid == 1:
6031 rajveer 27107 
        if ftype == TType.I64:
27108 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27109 
        else:
27110 
          iprot.skip(ftype)
27111 
      else:
27112 
        iprot.skip(ftype)
27113 
      iprot.readFieldEnd()
27114 
    iprot.readStructEnd()
27115 
 
27116 
  def write(self, oprot):
27117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27119 
      return
27120 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27121 
    if self.rechargeOrderId is not None:
27122 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27123 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27124 
      oprot.writeFieldEnd()
27125 
    oprot.writeFieldStop()
27126 
    oprot.writeStructEnd()
27127 
 
27128 
  def validate(self):
27129 
    return
27130 
 
27131 
 
27132 
  def __repr__(self):
27133 
    L = ['%s=%r' % (key, value)
27134 
      for key, value in self.__dict__.iteritems()]
27135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27136 
 
27137 
  def __eq__(self, other):
27138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27139 
 
27140 
  def __ne__(self, other):
27141 
    return not (self == other)
27142 
 
27143 
class activateRechargeTxn_result:
27144 
  """
27145 
  Attributes:
27146 
   - success
27147 
   - ex
27148 
  """
27149 
 
27150 
  thrift_spec = (
6031 rajveer 27151 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27152 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27153 
  )
27154 
 
27155 
  def __init__(self, success=None, ex=None,):
27156 
    self.success = success
27157 
    self.ex = ex
27158 
 
27159 
  def read(self, iprot):
27160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27162 
      return
27163 
    iprot.readStructBegin()
27164 
    while True:
27165 
      (fname, ftype, fid) = iprot.readFieldBegin()
27166 
      if ftype == TType.STOP:
27167 
        break
27168 
      if fid == 0:
6031 rajveer 27169 
        if ftype == TType.BOOL:
27170 
          self.success = iprot.readBool();
6000 mandeep.dh 27171 
        else:
27172 
          iprot.skip(ftype)
27173 
      elif fid == 1:
27174 
        if ftype == TType.STRUCT:
27175 
          self.ex = TransactionServiceException()
27176 
          self.ex.read(iprot)
27177 
        else:
27178 
          iprot.skip(ftype)
27179 
      else:
27180 
        iprot.skip(ftype)
27181 
      iprot.readFieldEnd()
27182 
    iprot.readStructEnd()
27183 
 
27184 
  def write(self, oprot):
27185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27187 
      return
27188 
    oprot.writeStructBegin('activateRechargeTxn_result')
27189 
    if self.success is not None:
6031 rajveer 27190 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27191 
      oprot.writeBool(self.success)
6000 mandeep.dh 27192 
      oprot.writeFieldEnd()
27193 
    if self.ex is not None:
27194 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27195 
      self.ex.write(oprot)
27196 
      oprot.writeFieldEnd()
27197 
    oprot.writeFieldStop()
27198 
    oprot.writeStructEnd()
27199 
 
27200 
  def validate(self):
27201 
    return
27202 
 
27203 
 
27204 
  def __repr__(self):
27205 
    L = ['%s=%r' % (key, value)
27206 
      for key, value in self.__dict__.iteritems()]
27207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27208 
 
27209 
  def __eq__(self, other):
27210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27211 
 
27212 
  def __ne__(self, other):
27213 
    return not (self == other)
27214 
 
6031 rajveer 27215 
class getUserWallet_args:
6000 mandeep.dh 27216 
  """
27217 
  Attributes:
6031 rajveer 27218 
   - userId
6000 mandeep.dh 27219 
  """
27220 
 
27221 
  thrift_spec = (
27222 
    None, # 0
6031 rajveer 27223 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27224 
  )
27225 
 
6031 rajveer 27226 
  def __init__(self, userId=None,):
27227 
    self.userId = userId
6000 mandeep.dh 27228 
 
27229 
  def read(self, iprot):
27230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27232 
      return
27233 
    iprot.readStructBegin()
27234 
    while True:
27235 
      (fname, ftype, fid) = iprot.readFieldBegin()
27236 
      if ftype == TType.STOP:
27237 
        break
27238 
      if fid == 1:
27239 
        if ftype == TType.I64:
6031 rajveer 27240 
          self.userId = iprot.readI64();
6000 mandeep.dh 27241 
        else:
27242 
          iprot.skip(ftype)
27243 
      else:
27244 
        iprot.skip(ftype)
27245 
      iprot.readFieldEnd()
27246 
    iprot.readStructEnd()
27247 
 
27248 
  def write(self, oprot):
27249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27251 
      return
6031 rajveer 27252 
    oprot.writeStructBegin('getUserWallet_args')
27253 
    if self.userId is not None:
27254 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27255 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27256 
      oprot.writeFieldEnd()
27257 
    oprot.writeFieldStop()
27258 
    oprot.writeStructEnd()
27259 
 
27260 
  def validate(self):
27261 
    return
27262 
 
27263 
 
27264 
  def __repr__(self):
27265 
    L = ['%s=%r' % (key, value)
27266 
      for key, value in self.__dict__.iteritems()]
27267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27268 
 
27269 
  def __eq__(self, other):
27270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27271 
 
27272 
  def __ne__(self, other):
27273 
    return not (self == other)
27274 
 
6031 rajveer 27275 
class getUserWallet_result:
6000 mandeep.dh 27276 
  """
27277 
  Attributes:
27278 
   - success
27279 
  """
27280 
 
27281 
  thrift_spec = (
6031 rajveer 27282 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27283 
  )
27284 
 
27285 
  def __init__(self, success=None,):
27286 
    self.success = success
27287 
 
27288 
  def read(self, iprot):
27289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27291 
      return
27292 
    iprot.readStructBegin()
27293 
    while True:
27294 
      (fname, ftype, fid) = iprot.readFieldBegin()
27295 
      if ftype == TType.STOP:
27296 
        break
27297 
      if fid == 0:
6031 rajveer 27298 
        if ftype == TType.STRUCT:
27299 
          self.success = UserWallet()
27300 
          self.success.read(iprot)
6000 mandeep.dh 27301 
        else:
27302 
          iprot.skip(ftype)
27303 
      else:
27304 
        iprot.skip(ftype)
27305 
      iprot.readFieldEnd()
27306 
    iprot.readStructEnd()
27307 
 
27308 
  def write(self, oprot):
27309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27311 
      return
6031 rajveer 27312 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27313 
    if self.success is not None:
6031 rajveer 27314 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27315 
      self.success.write(oprot)
6000 mandeep.dh 27316 
      oprot.writeFieldEnd()
27317 
    oprot.writeFieldStop()
27318 
    oprot.writeStructEnd()
27319 
 
27320 
  def validate(self):
27321 
    return
27322 
 
27323 
 
27324 
  def __repr__(self):
27325 
    L = ['%s=%r' % (key, value)
27326 
      for key, value in self.__dict__.iteritems()]
27327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27328 
 
27329 
  def __eq__(self, other):
27330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27331 
 
27332 
  def __ne__(self, other):
27333 
    return not (self == other)
27334 
 
6031 rajveer 27335 
class getUserWalletHistory_args:
6000 mandeep.dh 27336 
  """
27337 
  Attributes:
6031 rajveer 27338 
   - userId
6000 mandeep.dh 27339 
  """
27340 
 
27341 
  thrift_spec = (
27342 
    None, # 0
6031 rajveer 27343 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27344 
  )
27345 
 
6031 rajveer 27346 
  def __init__(self, userId=None,):
27347 
    self.userId = userId
6000 mandeep.dh 27348 
 
27349 
  def read(self, iprot):
27350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27352 
      return
27353 
    iprot.readStructBegin()
27354 
    while True:
27355 
      (fname, ftype, fid) = iprot.readFieldBegin()
27356 
      if ftype == TType.STOP:
27357 
        break
27358 
      if fid == 1:
27359 
        if ftype == TType.I64:
6031 rajveer 27360 
          self.userId = iprot.readI64();
6000 mandeep.dh 27361 
        else:
27362 
          iprot.skip(ftype)
27363 
      else:
27364 
        iprot.skip(ftype)
27365 
      iprot.readFieldEnd()
27366 
    iprot.readStructEnd()
27367 
 
27368 
  def write(self, oprot):
27369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27371 
      return
6031 rajveer 27372 
    oprot.writeStructBegin('getUserWalletHistory_args')
27373 
    if self.userId is not None:
27374 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27375 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27376 
      oprot.writeFieldEnd()
27377 
    oprot.writeFieldStop()
27378 
    oprot.writeStructEnd()
27379 
 
27380 
  def validate(self):
27381 
    return
27382 
 
27383 
 
27384 
  def __repr__(self):
27385 
    L = ['%s=%r' % (key, value)
27386 
      for key, value in self.__dict__.iteritems()]
27387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27388 
 
27389 
  def __eq__(self, other):
27390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27391 
 
27392 
  def __ne__(self, other):
27393 
    return not (self == other)
27394 
 
6031 rajveer 27395 
class getUserWalletHistory_result:
6000 mandeep.dh 27396 
  """
27397 
  Attributes:
27398 
   - success
27399 
  """
27400 
 
27401 
  thrift_spec = (
6031 rajveer 27402 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27403 
  )
27404 
 
27405 
  def __init__(self, success=None,):
27406 
    self.success = success
27407 
 
27408 
  def read(self, iprot):
27409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27411 
      return
27412 
    iprot.readStructBegin()
27413 
    while True:
27414 
      (fname, ftype, fid) = iprot.readFieldBegin()
27415 
      if ftype == TType.STOP:
27416 
        break
27417 
      if fid == 0:
27418 
        if ftype == TType.LIST:
27419 
          self.success = []
6188 rajveer 27420 
          (_etype666, _size663) = iprot.readListBegin()
27421 
          for _i667 in xrange(_size663):
27422 
            _elem668 = UserWalletHistory()
27423 
            _elem668.read(iprot)
27424 
            self.success.append(_elem668)
6000 mandeep.dh 27425 
          iprot.readListEnd()
27426 
        else:
27427 
          iprot.skip(ftype)
27428 
      else:
27429 
        iprot.skip(ftype)
27430 
      iprot.readFieldEnd()
27431 
    iprot.readStructEnd()
27432 
 
27433 
  def write(self, oprot):
27434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27436 
      return
6031 rajveer 27437 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27438 
    if self.success is not None:
27439 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27440 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27441 
      for iter669 in self.success:
27442 
        iter669.write(oprot)
6000 mandeep.dh 27443 
      oprot.writeListEnd()
27444 
      oprot.writeFieldEnd()
27445 
    oprot.writeFieldStop()
27446 
    oprot.writeStructEnd()
27447 
 
27448 
  def validate(self):
27449 
    return
27450 
 
27451 
 
27452 
  def __repr__(self):
27453 
    L = ['%s=%r' % (key, value)
27454 
      for key, value in self.__dict__.iteritems()]
27455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27456 
 
27457 
  def __eq__(self, other):
27458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27459 
 
27460 
  def __ne__(self, other):
27461 
    return not (self == other)
6048 rajveer 27462 
 
6050 anupam.sin 27463 
class getRechargeOrdersForTransaction_args:
27464 
  """
27465 
  Attributes:
27466 
   - txnId
27467 
  """
27468 
 
27469 
  thrift_spec = (
27470 
    None, # 0
27471 
    (1, TType.I64, 'txnId', None, None, ), # 1
27472 
  )
27473 
 
27474 
  def __init__(self, txnId=None,):
27475 
    self.txnId = txnId
27476 
 
27477 
  def read(self, iprot):
27478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27480 
      return
27481 
    iprot.readStructBegin()
27482 
    while True:
27483 
      (fname, ftype, fid) = iprot.readFieldBegin()
27484 
      if ftype == TType.STOP:
27485 
        break
27486 
      if fid == 1:
27487 
        if ftype == TType.I64:
27488 
          self.txnId = iprot.readI64();
27489 
        else:
27490 
          iprot.skip(ftype)
27491 
      else:
27492 
        iprot.skip(ftype)
27493 
      iprot.readFieldEnd()
27494 
    iprot.readStructEnd()
27495 
 
27496 
  def write(self, oprot):
27497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27499 
      return
27500 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27501 
    if self.txnId is not None:
27502 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27503 
      oprot.writeI64(self.txnId)
27504 
      oprot.writeFieldEnd()
27505 
    oprot.writeFieldStop()
27506 
    oprot.writeStructEnd()
27507 
 
27508 
  def validate(self):
27509 
    return
27510 
 
27511 
 
27512 
  def __repr__(self):
27513 
    L = ['%s=%r' % (key, value)
27514 
      for key, value in self.__dict__.iteritems()]
27515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27516 
 
27517 
  def __eq__(self, other):
27518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27519 
 
27520 
  def __ne__(self, other):
27521 
    return not (self == other)
27522 
 
27523 
class getRechargeOrdersForTransaction_result:
27524 
  """
27525 
  Attributes:
27526 
   - success
27527 
   - ex
27528 
  """
27529 
 
27530 
  thrift_spec = (
27531 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27533 
  )
27534 
 
27535 
  def __init__(self, success=None, ex=None,):
27536 
    self.success = success
27537 
    self.ex = ex
27538 
 
27539 
  def read(self, iprot):
27540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27542 
      return
27543 
    iprot.readStructBegin()
27544 
    while True:
27545 
      (fname, ftype, fid) = iprot.readFieldBegin()
27546 
      if ftype == TType.STOP:
27547 
        break
27548 
      if fid == 0:
27549 
        if ftype == TType.STRUCT:
27550 
          self.success = RechargeOrder()
27551 
          self.success.read(iprot)
27552 
        else:
27553 
          iprot.skip(ftype)
27554 
      elif fid == 1:
27555 
        if ftype == TType.STRUCT:
27556 
          self.ex = TransactionServiceException()
27557 
          self.ex.read(iprot)
27558 
        else:
27559 
          iprot.skip(ftype)
27560 
      else:
27561 
        iprot.skip(ftype)
27562 
      iprot.readFieldEnd()
27563 
    iprot.readStructEnd()
27564 
 
27565 
  def write(self, oprot):
27566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27568 
      return
27569 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27570 
    if self.success is not None:
27571 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27572 
      self.success.write(oprot)
27573 
      oprot.writeFieldEnd()
27574 
    if self.ex is not None:
27575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27576 
      self.ex.write(oprot)
27577 
      oprot.writeFieldEnd()
27578 
    oprot.writeFieldStop()
27579 
    oprot.writeStructEnd()
27580 
 
27581 
  def validate(self):
27582 
    return
27583 
 
27584 
 
27585 
  def __repr__(self):
27586 
    L = ['%s=%r' % (key, value)
27587 
      for key, value in self.__dict__.iteritems()]
27588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27589 
 
27590 
  def __eq__(self, other):
27591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27592 
 
27593 
  def __ne__(self, other):
27594 
    return not (self == other)
27595 
 
6048 rajveer 27596 
class getServiceProviders_args:
27597 
  """
27598 
  Attributes:
27599 
   - rechargeType
6206 rajveer 27600 
   - onlyActive
6048 rajveer 27601 
  """
27602 
 
27603 
  thrift_spec = (
27604 
    None, # 0
27605 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27606 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27607 
  )
27608 
 
6206 rajveer 27609 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27610 
    self.rechargeType = rechargeType
6206 rajveer 27611 
    self.onlyActive = onlyActive
6048 rajveer 27612 
 
27613 
  def read(self, iprot):
27614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27616 
      return
27617 
    iprot.readStructBegin()
27618 
    while True:
27619 
      (fname, ftype, fid) = iprot.readFieldBegin()
27620 
      if ftype == TType.STOP:
27621 
        break
27622 
      if fid == 1:
27623 
        if ftype == TType.I32:
27624 
          self.rechargeType = iprot.readI32();
27625 
        else:
27626 
          iprot.skip(ftype)
6206 rajveer 27627 
      elif fid == 2:
27628 
        if ftype == TType.BOOL:
27629 
          self.onlyActive = iprot.readBool();
27630 
        else:
27631 
          iprot.skip(ftype)
6048 rajveer 27632 
      else:
27633 
        iprot.skip(ftype)
27634 
      iprot.readFieldEnd()
27635 
    iprot.readStructEnd()
27636 
 
27637 
  def write(self, oprot):
27638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27640 
      return
27641 
    oprot.writeStructBegin('getServiceProviders_args')
27642 
    if self.rechargeType is not None:
27643 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27644 
      oprot.writeI32(self.rechargeType)
27645 
      oprot.writeFieldEnd()
6206 rajveer 27646 
    if self.onlyActive is not None:
27647 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27648 
      oprot.writeBool(self.onlyActive)
27649 
      oprot.writeFieldEnd()
6048 rajveer 27650 
    oprot.writeFieldStop()
27651 
    oprot.writeStructEnd()
27652 
 
27653 
  def validate(self):
27654 
    return
27655 
 
27656 
 
27657 
  def __repr__(self):
27658 
    L = ['%s=%r' % (key, value)
27659 
      for key, value in self.__dict__.iteritems()]
27660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27661 
 
27662 
  def __eq__(self, other):
27663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27664 
 
27665 
  def __ne__(self, other):
27666 
    return not (self == other)
27667 
 
27668 
class getServiceProviders_result:
27669 
  """
27670 
  Attributes:
27671 
   - success
27672 
  """
27673 
 
27674 
  thrift_spec = (
27675 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27676 
  )
27677 
 
27678 
  def __init__(self, success=None,):
27679 
    self.success = success
27680 
 
27681 
  def read(self, iprot):
27682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27684 
      return
27685 
    iprot.readStructBegin()
27686 
    while True:
27687 
      (fname, ftype, fid) = iprot.readFieldBegin()
27688 
      if ftype == TType.STOP:
27689 
        break
27690 
      if fid == 0:
27691 
        if ftype == TType.MAP:
27692 
          self.success = {}
6188 rajveer 27693 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27694 
          for _i674 in xrange(_size670):
27695 
            _key675 = iprot.readI64();
27696 
            _val676 = iprot.readString();
27697 
            self.success[_key675] = _val676
6048 rajveer 27698 
          iprot.readMapEnd()
27699 
        else:
27700 
          iprot.skip(ftype)
27701 
      else:
27702 
        iprot.skip(ftype)
27703 
      iprot.readFieldEnd()
27704 
    iprot.readStructEnd()
27705 
 
27706 
  def write(self, oprot):
27707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27709 
      return
27710 
    oprot.writeStructBegin('getServiceProviders_result')
27711 
    if self.success is not None:
27712 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27713 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27714 
      for kiter677,viter678 in self.success.items():
27715 
        oprot.writeI64(kiter677)
27716 
        oprot.writeString(viter678)
6048 rajveer 27717 
      oprot.writeMapEnd()
27718 
      oprot.writeFieldEnd()
27719 
    oprot.writeFieldStop()
27720 
    oprot.writeStructEnd()
27721 
 
27722 
  def validate(self):
27723 
    return
27724 
 
27725 
 
27726 
  def __repr__(self):
27727 
    L = ['%s=%r' % (key, value)
27728 
      for key, value in self.__dict__.iteritems()]
27729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27730 
 
27731 
  def __eq__(self, other):
27732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27733 
 
27734 
  def __ne__(self, other):
27735 
    return not (self == other)
27736 
 
27737 
class getServiceProviderForDevice_args:
27738 
  """
27739 
  Attributes:
6049 rajveer 27740 
   - rechargeType
6048 rajveer 27741 
   - deviceNumber
27742 
  """
27743 
 
27744 
  thrift_spec = (
27745 
    None, # 0
6049 rajveer 27746 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27747 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27748 
  )
27749 
 
6049 rajveer 27750 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27751 
    self.rechargeType = rechargeType
6048 rajveer 27752 
    self.deviceNumber = deviceNumber
27753 
 
27754 
  def read(self, iprot):
27755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27757 
      return
27758 
    iprot.readStructBegin()
27759 
    while True:
27760 
      (fname, ftype, fid) = iprot.readFieldBegin()
27761 
      if ftype == TType.STOP:
27762 
        break
27763 
      if fid == 1:
6049 rajveer 27764 
        if ftype == TType.I32:
27765 
          self.rechargeType = iprot.readI32();
27766 
        else:
27767 
          iprot.skip(ftype)
27768 
      elif fid == 2:
6048 rajveer 27769 
        if ftype == TType.STRING:
27770 
          self.deviceNumber = iprot.readString();
27771 
        else:
27772 
          iprot.skip(ftype)
27773 
      else:
27774 
        iprot.skip(ftype)
27775 
      iprot.readFieldEnd()
27776 
    iprot.readStructEnd()
27777 
 
27778 
  def write(self, oprot):
27779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27781 
      return
27782 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27783 
    if self.rechargeType is not None:
27784 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27785 
      oprot.writeI32(self.rechargeType)
27786 
      oprot.writeFieldEnd()
6048 rajveer 27787 
    if self.deviceNumber is not None:
6049 rajveer 27788 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27789 
      oprot.writeString(self.deviceNumber)
27790 
      oprot.writeFieldEnd()
27791 
    oprot.writeFieldStop()
27792 
    oprot.writeStructEnd()
27793 
 
27794 
  def validate(self):
27795 
    return
27796 
 
27797 
 
27798 
  def __repr__(self):
27799 
    L = ['%s=%r' % (key, value)
27800 
      for key, value in self.__dict__.iteritems()]
27801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27802 
 
27803 
  def __eq__(self, other):
27804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27805 
 
27806 
  def __ne__(self, other):
27807 
    return not (self == other)
27808 
 
27809 
class getServiceProviderForDevice_result:
27810 
  """
27811 
  Attributes:
27812 
   - success
27813 
  """
27814 
 
27815 
  thrift_spec = (
6289 anupam.sin 27816 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27817 
  )
27818 
 
27819 
  def __init__(self, success=None,):
27820 
    self.success = success
27821 
 
27822 
  def read(self, iprot):
27823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27825 
      return
27826 
    iprot.readStructBegin()
27827 
    while True:
27828 
      (fname, ftype, fid) = iprot.readFieldBegin()
27829 
      if ftype == TType.STOP:
27830 
        break
27831 
      if fid == 0:
6289 anupam.sin 27832 
        if ftype == TType.STRUCT:
27833 
          self.success = DeviceNumberInfo()
27834 
          self.success.read(iprot)
6048 rajveer 27835 
        else:
27836 
          iprot.skip(ftype)
27837 
      else:
27838 
        iprot.skip(ftype)
27839 
      iprot.readFieldEnd()
27840 
    iprot.readStructEnd()
27841 
 
27842 
  def write(self, oprot):
27843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27845 
      return
27846 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27847 
    if self.success is not None:
6289 anupam.sin 27848 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27849 
      self.success.write(oprot)
6048 rajveer 27850 
      oprot.writeFieldEnd()
27851 
    oprot.writeFieldStop()
27852 
    oprot.writeStructEnd()
27853 
 
27854 
  def validate(self):
27855 
    return
27856 
 
27857 
 
27858 
  def __repr__(self):
27859 
    L = ['%s=%r' % (key, value)
27860 
      for key, value in self.__dict__.iteritems()]
27861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27862 
 
27863 
  def __eq__(self, other):
27864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27865 
 
27866 
  def __ne__(self, other):
27867 
    return not (self == other)
6094 rajveer 27868 
 
6269 rajveer 27869 
class validateRecharge_args:
27870 
  """
27871 
  Attributes:
27872 
   - rechargeType
27873 
   - deviceNumber
6307 anupam.sin 27874 
   - userSelectedProviderId
6269 rajveer 27875 
  """
27876 
 
27877 
  thrift_spec = (
27878 
    None, # 0
27879 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27880 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 27881 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6269 rajveer 27882 
  )
27883 
 
6336 anupam.sin 27884 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None,):
6269 rajveer 27885 
    self.rechargeType = rechargeType
27886 
    self.deviceNumber = deviceNumber
6307 anupam.sin 27887 
    self.userSelectedProviderId = userSelectedProviderId
6269 rajveer 27888 
 
27889 
  def read(self, iprot):
27890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27892 
      return
27893 
    iprot.readStructBegin()
27894 
    while True:
27895 
      (fname, ftype, fid) = iprot.readFieldBegin()
27896 
      if ftype == TType.STOP:
27897 
        break
27898 
      if fid == 1:
27899 
        if ftype == TType.I32:
27900 
          self.rechargeType = iprot.readI32();
27901 
        else:
27902 
          iprot.skip(ftype)
27903 
      elif fid == 2:
27904 
        if ftype == TType.STRING:
27905 
          self.deviceNumber = iprot.readString();
27906 
        else:
27907 
          iprot.skip(ftype)
6307 anupam.sin 27908 
      elif fid == 3:
27909 
        if ftype == TType.I64:
27910 
          self.userSelectedProviderId = iprot.readI64();
27911 
        else:
27912 
          iprot.skip(ftype)
6269 rajveer 27913 
      else:
27914 
        iprot.skip(ftype)
27915 
      iprot.readFieldEnd()
27916 
    iprot.readStructEnd()
27917 
 
27918 
  def write(self, oprot):
27919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27921 
      return
27922 
    oprot.writeStructBegin('validateRecharge_args')
27923 
    if self.rechargeType is not None:
27924 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27925 
      oprot.writeI32(self.rechargeType)
27926 
      oprot.writeFieldEnd()
27927 
    if self.deviceNumber is not None:
27928 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
27929 
      oprot.writeString(self.deviceNumber)
27930 
      oprot.writeFieldEnd()
6307 anupam.sin 27931 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 27932 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 27933 
      oprot.writeI64(self.userSelectedProviderId)
27934 
      oprot.writeFieldEnd()
6269 rajveer 27935 
    oprot.writeFieldStop()
27936 
    oprot.writeStructEnd()
27937 
 
27938 
  def validate(self):
27939 
    return
27940 
 
27941 
 
27942 
  def __repr__(self):
27943 
    L = ['%s=%r' % (key, value)
27944 
      for key, value in self.__dict__.iteritems()]
27945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27946 
 
27947 
  def __eq__(self, other):
27948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27949 
 
27950 
  def __ne__(self, other):
27951 
    return not (self == other)
27952 
 
27953 
class validateRecharge_result:
27954 
  """
27955 
  Attributes:
27956 
   - success
27957 
  """
27958 
 
27959 
  thrift_spec = (
27960 
    (0, TType.STRING, 'success', None, None, ), # 0
27961 
  )
27962 
 
27963 
  def __init__(self, success=None,):
27964 
    self.success = success
27965 
 
27966 
  def read(self, iprot):
27967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27969 
      return
27970 
    iprot.readStructBegin()
27971 
    while True:
27972 
      (fname, ftype, fid) = iprot.readFieldBegin()
27973 
      if ftype == TType.STOP:
27974 
        break
27975 
      if fid == 0:
27976 
        if ftype == TType.STRING:
27977 
          self.success = iprot.readString();
27978 
        else:
27979 
          iprot.skip(ftype)
27980 
      else:
27981 
        iprot.skip(ftype)
27982 
      iprot.readFieldEnd()
27983 
    iprot.readStructEnd()
27984 
 
27985 
  def write(self, oprot):
27986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27988 
      return
27989 
    oprot.writeStructBegin('validateRecharge_result')
27990 
    if self.success is not None:
27991 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27992 
      oprot.writeString(self.success)
27993 
      oprot.writeFieldEnd()
27994 
    oprot.writeFieldStop()
27995 
    oprot.writeStructEnd()
27996 
 
27997 
  def validate(self):
27998 
    return
27999 
 
28000 
 
28001 
  def __repr__(self):
28002 
    L = ['%s=%r' % (key, value)
28003 
      for key, value in self.__dict__.iteritems()]
28004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28005 
 
28006 
  def __eq__(self, other):
28007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28008 
 
28009 
  def __ne__(self, other):
28010 
    return not (self == other)
28011 
 
6094 rajveer 28012 
class getRechargeOrdersForDevice_args:
28013 
  """
28014 
  Attributes:
28015 
   - deviceNumber
28016 
  """
28017 
 
28018 
  thrift_spec = (
28019 
    None, # 0
28020 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28021 
  )
28022 
 
28023 
  def __init__(self, deviceNumber=None,):
28024 
    self.deviceNumber = deviceNumber
28025 
 
28026 
  def read(self, iprot):
28027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28029 
      return
28030 
    iprot.readStructBegin()
28031 
    while True:
28032 
      (fname, ftype, fid) = iprot.readFieldBegin()
28033 
      if ftype == TType.STOP:
28034 
        break
28035 
      if fid == 1:
28036 
        if ftype == TType.STRING:
28037 
          self.deviceNumber = iprot.readString();
28038 
        else:
28039 
          iprot.skip(ftype)
28040 
      else:
28041 
        iprot.skip(ftype)
28042 
      iprot.readFieldEnd()
28043 
    iprot.readStructEnd()
28044 
 
28045 
  def write(self, oprot):
28046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28048 
      return
28049 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28050 
    if self.deviceNumber is not None:
28051 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28052 
      oprot.writeString(self.deviceNumber)
28053 
      oprot.writeFieldEnd()
28054 
    oprot.writeFieldStop()
28055 
    oprot.writeStructEnd()
28056 
 
28057 
  def validate(self):
28058 
    return
28059 
 
28060 
 
28061 
  def __repr__(self):
28062 
    L = ['%s=%r' % (key, value)
28063 
      for key, value in self.__dict__.iteritems()]
28064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28065 
 
28066 
  def __eq__(self, other):
28067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28068 
 
28069 
  def __ne__(self, other):
28070 
    return not (self == other)
28071 
 
28072 
class getRechargeOrdersForDevice_result:
28073 
  """
28074 
  Attributes:
28075 
   - success
28076 
  """
28077 
 
28078 
  thrift_spec = (
28079 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28080 
  )
28081 
 
28082 
  def __init__(self, success=None,):
28083 
    self.success = success
28084 
 
28085 
  def read(self, iprot):
28086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28088 
      return
28089 
    iprot.readStructBegin()
28090 
    while True:
28091 
      (fname, ftype, fid) = iprot.readFieldBegin()
28092 
      if ftype == TType.STOP:
28093 
        break
28094 
      if fid == 0:
28095 
        if ftype == TType.LIST:
28096 
          self.success = []
6188 rajveer 28097 
          (_etype682, _size679) = iprot.readListBegin()
28098 
          for _i683 in xrange(_size679):
28099 
            _elem684 = RechargeOrder()
28100 
            _elem684.read(iprot)
28101 
            self.success.append(_elem684)
6094 rajveer 28102 
          iprot.readListEnd()
28103 
        else:
28104 
          iprot.skip(ftype)
28105 
      else:
28106 
        iprot.skip(ftype)
28107 
      iprot.readFieldEnd()
28108 
    iprot.readStructEnd()
28109 
 
28110 
  def write(self, oprot):
28111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28113 
      return
28114 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28115 
    if self.success is not None:
28116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28118 
      for iter685 in self.success:
28119 
        iter685.write(oprot)
6094 rajveer 28120 
      oprot.writeListEnd()
28121 
      oprot.writeFieldEnd()
28122 
    oprot.writeFieldStop()
28123 
    oprot.writeStructEnd()
28124 
 
28125 
  def validate(self):
28126 
    return
28127 
 
28128 
 
28129 
  def __repr__(self):
28130 
    L = ['%s=%r' % (key, value)
28131 
      for key, value in self.__dict__.iteritems()]
28132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28133 
 
28134 
  def __eq__(self, other):
28135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28136 
 
28137 
  def __ne__(self, other):
28138 
    return not (self == other)
28139 
 
28140 
class addAmountToWallet_args:
28141 
  """
28142 
  Attributes:
28143 
   - userId
28144 
   - orderId
28145 
   - amount
28146 
  """
28147 
 
28148 
  thrift_spec = (
28149 
    None, # 0
28150 
    (1, TType.I64, 'userId', None, None, ), # 1
28151 
    (2, TType.I64, 'orderId', None, None, ), # 2
28152 
    (3, TType.I64, 'amount', None, None, ), # 3
28153 
  )
28154 
 
28155 
  def __init__(self, userId=None, orderId=None, amount=None,):
28156 
    self.userId = userId
28157 
    self.orderId = orderId
28158 
    self.amount = amount
28159 
 
28160 
  def read(self, iprot):
28161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28163 
      return
28164 
    iprot.readStructBegin()
28165 
    while True:
28166 
      (fname, ftype, fid) = iprot.readFieldBegin()
28167 
      if ftype == TType.STOP:
28168 
        break
28169 
      if fid == 1:
28170 
        if ftype == TType.I64:
28171 
          self.userId = iprot.readI64();
28172 
        else:
28173 
          iprot.skip(ftype)
28174 
      elif fid == 2:
28175 
        if ftype == TType.I64:
28176 
          self.orderId = iprot.readI64();
28177 
        else:
28178 
          iprot.skip(ftype)
28179 
      elif fid == 3:
28180 
        if ftype == TType.I64:
28181 
          self.amount = iprot.readI64();
28182 
        else:
28183 
          iprot.skip(ftype)
28184 
      else:
28185 
        iprot.skip(ftype)
28186 
      iprot.readFieldEnd()
28187 
    iprot.readStructEnd()
28188 
 
28189 
  def write(self, oprot):
28190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28192 
      return
28193 
    oprot.writeStructBegin('addAmountToWallet_args')
28194 
    if self.userId is not None:
28195 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28196 
      oprot.writeI64(self.userId)
28197 
      oprot.writeFieldEnd()
28198 
    if self.orderId is not None:
28199 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28200 
      oprot.writeI64(self.orderId)
28201 
      oprot.writeFieldEnd()
28202 
    if self.amount is not None:
28203 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28204 
      oprot.writeI64(self.amount)
28205 
      oprot.writeFieldEnd()
28206 
    oprot.writeFieldStop()
28207 
    oprot.writeStructEnd()
28208 
 
28209 
  def validate(self):
28210 
    return
28211 
 
28212 
 
28213 
  def __repr__(self):
28214 
    L = ['%s=%r' % (key, value)
28215 
      for key, value in self.__dict__.iteritems()]
28216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28217 
 
28218 
  def __eq__(self, other):
28219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28220 
 
28221 
  def __ne__(self, other):
28222 
    return not (self == other)
28223 
 
28224 
class addAmountToWallet_result:
28225 
 
28226 
  thrift_spec = (
28227 
  )
28228 
 
28229 
  def read(self, iprot):
28230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28232 
      return
28233 
    iprot.readStructBegin()
28234 
    while True:
28235 
      (fname, ftype, fid) = iprot.readFieldBegin()
28236 
      if ftype == TType.STOP:
28237 
        break
28238 
      else:
28239 
        iprot.skip(ftype)
28240 
      iprot.readFieldEnd()
28241 
    iprot.readStructEnd()
28242 
 
28243 
  def write(self, oprot):
28244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28246 
      return
28247 
    oprot.writeStructBegin('addAmountToWallet_result')
28248 
    oprot.writeFieldStop()
28249 
    oprot.writeStructEnd()
28250 
 
28251 
  def validate(self):
28252 
    return
28253 
 
28254 
 
28255 
  def __repr__(self):
28256 
    L = ['%s=%r' % (key, value)
28257 
      for key, value in self.__dict__.iteritems()]
28258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28259 
 
28260 
  def __eq__(self, other):
28261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28262 
 
28263 
  def __ne__(self, other):
28264 
    return not (self == other)
6154 rajveer 28265 
 
6188 rajveer 28266 
class getRechargeStatistics_args:
28267 
 
28268 
  thrift_spec = (
28269 
  )
28270 
 
28271 
  def read(self, iprot):
28272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28274 
      return
28275 
    iprot.readStructBegin()
28276 
    while True:
28277 
      (fname, ftype, fid) = iprot.readFieldBegin()
28278 
      if ftype == TType.STOP:
28279 
        break
28280 
      else:
28281 
        iprot.skip(ftype)
28282 
      iprot.readFieldEnd()
28283 
    iprot.readStructEnd()
28284 
 
28285 
  def write(self, oprot):
28286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28288 
      return
28289 
    oprot.writeStructBegin('getRechargeStatistics_args')
28290 
    oprot.writeFieldStop()
28291 
    oprot.writeStructEnd()
28292 
 
28293 
  def validate(self):
28294 
    return
28295 
 
28296 
 
28297 
  def __repr__(self):
28298 
    L = ['%s=%r' % (key, value)
28299 
      for key, value in self.__dict__.iteritems()]
28300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28301 
 
28302 
  def __eq__(self, other):
28303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28304 
 
28305 
  def __ne__(self, other):
28306 
    return not (self == other)
28307 
 
28308 
class getRechargeStatistics_result:
28309 
  """
28310 
  Attributes:
28311 
   - success
28312 
  """
28313 
 
28314 
  thrift_spec = (
28315 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28316 
  )
28317 
 
28318 
  def __init__(self, success=None,):
28319 
    self.success = success
28320 
 
28321 
  def read(self, iprot):
28322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28324 
      return
28325 
    iprot.readStructBegin()
28326 
    while True:
28327 
      (fname, ftype, fid) = iprot.readFieldBegin()
28328 
      if ftype == TType.STOP:
28329 
        break
28330 
      if fid == 0:
28331 
        if ftype == TType.STRUCT:
28332 
          self.success = RechargeStatistics()
28333 
          self.success.read(iprot)
28334 
        else:
28335 
          iprot.skip(ftype)
28336 
      else:
28337 
        iprot.skip(ftype)
28338 
      iprot.readFieldEnd()
28339 
    iprot.readStructEnd()
28340 
 
28341 
  def write(self, oprot):
28342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28344 
      return
28345 
    oprot.writeStructBegin('getRechargeStatistics_result')
28346 
    if self.success is not None:
28347 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28348 
      self.success.write(oprot)
28349 
      oprot.writeFieldEnd()
28350 
    oprot.writeFieldStop()
28351 
    oprot.writeStructEnd()
28352 
 
28353 
  def validate(self):
28354 
    return
28355 
 
28356 
 
28357 
  def __repr__(self):
28358 
    L = ['%s=%r' % (key, value)
28359 
      for key, value in self.__dict__.iteritems()]
28360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28361 
 
28362 
  def __eq__(self, other):
28363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28364 
 
28365 
  def __ne__(self, other):
28366 
    return not (self == other)
28367 
 
6154 rajveer 28368 
class getRechargeOrdersForStatus_args:
28369 
  """
28370 
  Attributes:
28371 
   - status
28372 
  """
28373 
 
28374 
  thrift_spec = (
28375 
    None, # 0
28376 
    (1, TType.I64, 'status', None, None, ), # 1
28377 
  )
28378 
 
28379 
  def __init__(self, status=None,):
28380 
    self.status = status
28381 
 
28382 
  def read(self, iprot):
28383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28385 
      return
28386 
    iprot.readStructBegin()
28387 
    while True:
28388 
      (fname, ftype, fid) = iprot.readFieldBegin()
28389 
      if ftype == TType.STOP:
28390 
        break
28391 
      if fid == 1:
28392 
        if ftype == TType.I64:
28393 
          self.status = iprot.readI64();
28394 
        else:
28395 
          iprot.skip(ftype)
28396 
      else:
28397 
        iprot.skip(ftype)
28398 
      iprot.readFieldEnd()
28399 
    iprot.readStructEnd()
28400 
 
28401 
  def write(self, oprot):
28402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28404 
      return
28405 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28406 
    if self.status is not None:
28407 
      oprot.writeFieldBegin('status', TType.I64, 1)
28408 
      oprot.writeI64(self.status)
28409 
      oprot.writeFieldEnd()
28410 
    oprot.writeFieldStop()
28411 
    oprot.writeStructEnd()
28412 
 
28413 
  def validate(self):
28414 
    return
28415 
 
28416 
 
28417 
  def __repr__(self):
28418 
    L = ['%s=%r' % (key, value)
28419 
      for key, value in self.__dict__.iteritems()]
28420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28421 
 
28422 
  def __eq__(self, other):
28423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28424 
 
28425 
  def __ne__(self, other):
28426 
    return not (self == other)
28427 
 
28428 
class getRechargeOrdersForStatus_result:
28429 
  """
28430 
  Attributes:
28431 
   - success
28432 
  """
28433 
 
28434 
  thrift_spec = (
28435 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28436 
  )
28437 
 
28438 
  def __init__(self, success=None,):
28439 
    self.success = success
28440 
 
28441 
  def read(self, iprot):
28442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28444 
      return
28445 
    iprot.readStructBegin()
28446 
    while True:
28447 
      (fname, ftype, fid) = iprot.readFieldBegin()
28448 
      if ftype == TType.STOP:
28449 
        break
28450 
      if fid == 0:
28451 
        if ftype == TType.LIST:
28452 
          self.success = []
6188 rajveer 28453 
          (_etype689, _size686) = iprot.readListBegin()
28454 
          for _i690 in xrange(_size686):
28455 
            _elem691 = RechargeOrder()
28456 
            _elem691.read(iprot)
28457 
            self.success.append(_elem691)
6154 rajveer 28458 
          iprot.readListEnd()
28459 
        else:
28460 
          iprot.skip(ftype)
28461 
      else:
28462 
        iprot.skip(ftype)
28463 
      iprot.readFieldEnd()
28464 
    iprot.readStructEnd()
28465 
 
28466 
  def write(self, oprot):
28467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28469 
      return
28470 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28471 
    if self.success is not None:
28472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28474 
      for iter692 in self.success:
28475 
        iter692.write(oprot)
6154 rajveer 28476 
      oprot.writeListEnd()
28477 
      oprot.writeFieldEnd()
28478 
    oprot.writeFieldStop()
28479 
    oprot.writeStructEnd()
28480 
 
28481 
  def validate(self):
28482 
    return
28483 
 
28484 
 
28485 
  def __repr__(self):
28486 
    L = ['%s=%r' % (key, value)
28487 
      for key, value in self.__dict__.iteritems()]
28488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28489 
 
28490 
  def __eq__(self, other):
28491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28492 
 
28493 
  def __ne__(self, other):
28494 
    return not (self == other)
6159 rajveer 28495 
 
28496 
class getPlansForOperator_args:
28497 
  """
28498 
  Attributes:
28499 
   - operatorId
28500 
  """
28501 
 
28502 
  thrift_spec = (
28503 
    None, # 0
28504 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28505 
  )
28506 
 
28507 
  def __init__(self, operatorId=None,):
28508 
    self.operatorId = operatorId
28509 
 
28510 
  def read(self, iprot):
28511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28513 
      return
28514 
    iprot.readStructBegin()
28515 
    while True:
28516 
      (fname, ftype, fid) = iprot.readFieldBegin()
28517 
      if ftype == TType.STOP:
28518 
        break
28519 
      if fid == 1:
28520 
        if ftype == TType.I64:
28521 
          self.operatorId = iprot.readI64();
28522 
        else:
28523 
          iprot.skip(ftype)
28524 
      else:
28525 
        iprot.skip(ftype)
28526 
      iprot.readFieldEnd()
28527 
    iprot.readStructEnd()
28528 
 
28529 
  def write(self, oprot):
28530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28532 
      return
28533 
    oprot.writeStructBegin('getPlansForOperator_args')
28534 
    if self.operatorId is not None:
28535 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28536 
      oprot.writeI64(self.operatorId)
28537 
      oprot.writeFieldEnd()
28538 
    oprot.writeFieldStop()
28539 
    oprot.writeStructEnd()
28540 
 
28541 
  def validate(self):
28542 
    return
28543 
 
28544 
 
28545 
  def __repr__(self):
28546 
    L = ['%s=%r' % (key, value)
28547 
      for key, value in self.__dict__.iteritems()]
28548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28549 
 
28550 
  def __eq__(self, other):
28551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28552 
 
28553 
  def __ne__(self, other):
28554 
    return not (self == other)
28555 
 
28556 
class getPlansForOperator_result:
28557 
  """
28558 
  Attributes:
28559 
   - success
28560 
  """
28561 
 
28562 
  thrift_spec = (
28563 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28564 
  )
28565 
 
28566 
  def __init__(self, success=None,):
28567 
    self.success = success
28568 
 
28569 
  def read(self, iprot):
28570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28572 
      return
28573 
    iprot.readStructBegin()
28574 
    while True:
28575 
      (fname, ftype, fid) = iprot.readFieldBegin()
28576 
      if ftype == TType.STOP:
28577 
        break
28578 
      if fid == 0:
28579 
        if ftype == TType.LIST:
28580 
          self.success = []
6188 rajveer 28581 
          (_etype696, _size693) = iprot.readListBegin()
28582 
          for _i697 in xrange(_size693):
28583 
            _elem698 = RechargePlan()
28584 
            _elem698.read(iprot)
28585 
            self.success.append(_elem698)
6159 rajveer 28586 
          iprot.readListEnd()
28587 
        else:
28588 
          iprot.skip(ftype)
28589 
      else:
28590 
        iprot.skip(ftype)
28591 
      iprot.readFieldEnd()
28592 
    iprot.readStructEnd()
28593 
 
28594 
  def write(self, oprot):
28595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28597 
      return
28598 
    oprot.writeStructBegin('getPlansForOperator_result')
28599 
    if self.success is not None:
28600 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28601 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28602 
      for iter699 in self.success:
28603 
        iter699.write(oprot)
6159 rajveer 28604 
      oprot.writeListEnd()
28605 
      oprot.writeFieldEnd()
28606 
    oprot.writeFieldStop()
28607 
    oprot.writeStructEnd()
28608 
 
28609 
  def validate(self):
28610 
    return
28611 
 
28612 
 
28613 
  def __repr__(self):
28614 
    L = ['%s=%r' % (key, value)
28615 
      for key, value in self.__dict__.iteritems()]
28616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28617 
 
28618 
  def __eq__(self, other):
28619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28620 
 
28621 
  def __ne__(self, other):
28622 
    return not (self == other)
6289 anupam.sin 28623 
 
28624 
class getRechargeDenominations_args:
28625 
  """
28626 
  Attributes:
28627 
   - operatorId
6307 anupam.sin 28628 
   - circleCode
6289 anupam.sin 28629 
   - denominationType
28630 
  """
28631 
 
28632 
  thrift_spec = (
28633 
    None, # 0
28634 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28635 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28636 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28637 
  )
28638 
 
6307 anupam.sin 28639 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28640 
    self.operatorId = operatorId
6307 anupam.sin 28641 
    self.circleCode = circleCode
6289 anupam.sin 28642 
    self.denominationType = denominationType
28643 
 
28644 
  def read(self, iprot):
28645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28647 
      return
28648 
    iprot.readStructBegin()
28649 
    while True:
28650 
      (fname, ftype, fid) = iprot.readFieldBegin()
28651 
      if ftype == TType.STOP:
28652 
        break
28653 
      if fid == 1:
28654 
        if ftype == TType.I64:
28655 
          self.operatorId = iprot.readI64();
28656 
        else:
28657 
          iprot.skip(ftype)
28658 
      elif fid == 2:
28659 
        if ftype == TType.STRING:
6307 anupam.sin 28660 
          self.circleCode = iprot.readString();
6289 anupam.sin 28661 
        else:
28662 
          iprot.skip(ftype)
28663 
      elif fid == 3:
28664 
        if ftype == TType.I32:
28665 
          self.denominationType = iprot.readI32();
28666 
        else:
28667 
          iprot.skip(ftype)
28668 
      else:
28669 
        iprot.skip(ftype)
28670 
      iprot.readFieldEnd()
28671 
    iprot.readStructEnd()
28672 
 
28673 
  def write(self, oprot):
28674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28676 
      return
28677 
    oprot.writeStructBegin('getRechargeDenominations_args')
28678 
    if self.operatorId is not None:
28679 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28680 
      oprot.writeI64(self.operatorId)
28681 
      oprot.writeFieldEnd()
6307 anupam.sin 28682 
    if self.circleCode is not None:
28683 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28684 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28685 
      oprot.writeFieldEnd()
28686 
    if self.denominationType is not None:
28687 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28688 
      oprot.writeI32(self.denominationType)
28689 
      oprot.writeFieldEnd()
28690 
    oprot.writeFieldStop()
28691 
    oprot.writeStructEnd()
28692 
 
28693 
  def validate(self):
28694 
    return
28695 
 
28696 
 
28697 
  def __repr__(self):
28698 
    L = ['%s=%r' % (key, value)
28699 
      for key, value in self.__dict__.iteritems()]
28700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28701 
 
28702 
  def __eq__(self, other):
28703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28704 
 
28705 
  def __ne__(self, other):
28706 
    return not (self == other)
28707 
 
28708 
class getRechargeDenominations_result:
28709 
  """
28710 
  Attributes:
28711 
   - success
28712 
   - ex
28713 
  """
28714 
 
28715 
  thrift_spec = (
28716 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28717 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28718 
  )
28719 
 
28720 
  def __init__(self, success=None, ex=None,):
28721 
    self.success = success
28722 
    self.ex = ex
28723 
 
28724 
  def read(self, iprot):
28725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28727 
      return
28728 
    iprot.readStructBegin()
28729 
    while True:
28730 
      (fname, ftype, fid) = iprot.readFieldBegin()
28731 
      if ftype == TType.STOP:
28732 
        break
28733 
      if fid == 0:
28734 
        if ftype == TType.LIST:
28735 
          self.success = []
28736 
          (_etype703, _size700) = iprot.readListBegin()
28737 
          for _i704 in xrange(_size700):
28738 
            _elem705 = RechargeDenomination()
28739 
            _elem705.read(iprot)
28740 
            self.success.append(_elem705)
28741 
          iprot.readListEnd()
28742 
        else:
28743 
          iprot.skip(ftype)
28744 
      elif fid == 1:
28745 
        if ftype == TType.STRUCT:
28746 
          self.ex = TransactionServiceException()
28747 
          self.ex.read(iprot)
28748 
        else:
28749 
          iprot.skip(ftype)
28750 
      else:
28751 
        iprot.skip(ftype)
28752 
      iprot.readFieldEnd()
28753 
    iprot.readStructEnd()
28754 
 
28755 
  def write(self, oprot):
28756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28758 
      return
28759 
    oprot.writeStructBegin('getRechargeDenominations_result')
28760 
    if self.success is not None:
28761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28762 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28763 
      for iter706 in self.success:
28764 
        iter706.write(oprot)
28765 
      oprot.writeListEnd()
28766 
      oprot.writeFieldEnd()
28767 
    if self.ex is not None:
28768 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28769 
      self.ex.write(oprot)
28770 
      oprot.writeFieldEnd()
28771 
    oprot.writeFieldStop()
28772 
    oprot.writeStructEnd()
28773 
 
28774 
  def validate(self):
28775 
    return
28776 
 
28777 
 
28778 
  def __repr__(self):
28779 
    L = ['%s=%r' % (key, value)
28780 
      for key, value in self.__dict__.iteritems()]
28781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28782 
 
28783 
  def __eq__(self, other):
28784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28785 
 
28786 
  def __ne__(self, other):
28787 
    return not (self == other)
6371 rajveer 28788 
 
28789 
class updateAvailabilityStatus_args:
28790 
  """
28791 
  Attributes:
28792 
   - operatorId
28793 
   - circleId
28794 
   - isAvailable
28795 
  """
28796 
 
28797 
  thrift_spec = (
28798 
    None, # 0
28799 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28800 
    (2, TType.I64, 'circleId', None, None, ), # 2
28801 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
28802 
  )
28803 
 
28804 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
28805 
    self.operatorId = operatorId
28806 
    self.circleId = circleId
28807 
    self.isAvailable = isAvailable
28808 
 
28809 
  def read(self, iprot):
28810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28812 
      return
28813 
    iprot.readStructBegin()
28814 
    while True:
28815 
      (fname, ftype, fid) = iprot.readFieldBegin()
28816 
      if ftype == TType.STOP:
28817 
        break
28818 
      if fid == 1:
28819 
        if ftype == TType.I64:
28820 
          self.operatorId = iprot.readI64();
28821 
        else:
28822 
          iprot.skip(ftype)
28823 
      elif fid == 2:
28824 
        if ftype == TType.I64:
28825 
          self.circleId = iprot.readI64();
28826 
        else:
28827 
          iprot.skip(ftype)
28828 
      elif fid == 3:
28829 
        if ftype == TType.BOOL:
28830 
          self.isAvailable = iprot.readBool();
28831 
        else:
28832 
          iprot.skip(ftype)
28833 
      else:
28834 
        iprot.skip(ftype)
28835 
      iprot.readFieldEnd()
28836 
    iprot.readStructEnd()
28837 
 
28838 
  def write(self, oprot):
28839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28841 
      return
28842 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
28843 
    if self.operatorId is not None:
28844 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28845 
      oprot.writeI64(self.operatorId)
28846 
      oprot.writeFieldEnd()
28847 
    if self.circleId is not None:
28848 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
28849 
      oprot.writeI64(self.circleId)
28850 
      oprot.writeFieldEnd()
28851 
    if self.isAvailable is not None:
28852 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
28853 
      oprot.writeBool(self.isAvailable)
28854 
      oprot.writeFieldEnd()
28855 
    oprot.writeFieldStop()
28856 
    oprot.writeStructEnd()
28857 
 
28858 
  def validate(self):
28859 
    return
28860 
 
28861 
 
28862 
  def __repr__(self):
28863 
    L = ['%s=%r' % (key, value)
28864 
      for key, value in self.__dict__.iteritems()]
28865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28866 
 
28867 
  def __eq__(self, other):
28868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28869 
 
28870 
  def __ne__(self, other):
28871 
    return not (self == other)
28872 
 
28873 
class updateAvailabilityStatus_result:
28874 
 
28875 
  thrift_spec = (
28876 
  )
28877 
 
28878 
  def read(self, iprot):
28879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28881 
      return
28882 
    iprot.readStructBegin()
28883 
    while True:
28884 
      (fname, ftype, fid) = iprot.readFieldBegin()
28885 
      if ftype == TType.STOP:
28886 
        break
28887 
      else:
28888 
        iprot.skip(ftype)
28889 
      iprot.readFieldEnd()
28890 
    iprot.readStructEnd()
28891 
 
28892 
  def write(self, oprot):
28893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28895 
      return
28896 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
28897 
    oprot.writeFieldStop()
28898 
    oprot.writeStructEnd()
28899 
 
28900 
  def validate(self):
28901 
    return
28902 
 
28903 
 
28904 
  def __repr__(self):
28905 
    L = ['%s=%r' % (key, value)
28906 
      for key, value in self.__dict__.iteritems()]
28907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28908 
 
28909 
  def __eq__(self, other):
28910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28911 
 
28912 
  def __ne__(self, other):
28913 
    return not (self == other)