Subversion Repositories SmartDukaan

Rev

Rev 6371 | Rev 6412 | 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 
 
6389 rajveer 1427 
  def getAvailableEmiSchemes(self, ):
1428 
    pass
6371 rajveer 1429 
 
6389 rajveer 1430 
  def getMiscCharges(self, transactionId):
1431 
    """
1432 
    Parameters:
1433 
     - transactionId
1434 
    """
1435 
    pass
1436 
 
1437 
 
3376 rajveer 1438 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1439 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1440 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1441 
 
1442 
  def createTransaction(self, transaction):
1443 
    """
1444 
    Parameters:
1445 
     - transaction
1446 
    """
1447 
    self.send_createTransaction(transaction)
132 ashish 1448 
    return self.recv_createTransaction()
94 ashish 1449 
 
1450 
  def send_createTransaction(self, transaction):
1451 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1452 
    args = createTransaction_args()
1453 
    args.transaction = transaction
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_createTransaction(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = createTransaction_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
3431 rajveer 1468 
    if result.success is not None:
132 ashish 1469 
      return result.success
3431 rajveer 1470 
    if result.ex is not None:
94 ashish 1471 
      raise result.ex
132 ashish 1472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1473 
 
1474 
  def getTransaction(self, id):
1475 
    """
1476 
    Parameters:
1477 
     - id
1478 
    """
1479 
    self.send_getTransaction(id)
1480 
    return self.recv_getTransaction()
1481 
 
1482 
  def send_getTransaction(self, id):
1483 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1484 
    args = getTransaction_args()
1485 
    args.id = id
1486 
    args.write(self._oprot)
1487 
    self._oprot.writeMessageEnd()
1488 
    self._oprot.trans.flush()
1489 
 
1490 
  def recv_getTransaction(self, ):
1491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1492 
    if mtype == TMessageType.EXCEPTION:
1493 
      x = TApplicationException()
1494 
      x.read(self._iprot)
1495 
      self._iprot.readMessageEnd()
1496 
      raise x
1497 
    result = getTransaction_result()
1498 
    result.read(self._iprot)
1499 
    self._iprot.readMessageEnd()
3431 rajveer 1500 
    if result.success is not None:
94 ashish 1501 
      return result.success
3431 rajveer 1502 
    if result.ex is not None:
94 ashish 1503 
      raise result.ex
1504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1505 
 
1506 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1507 
    """
1508 
    Parameters:
1509 
     - customerId
1510 
     - from_date
1511 
     - to_date
1512 
     - status
1513 
    """
1514 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1515 
    return self.recv_getTransactionsForCustomer()
1516 
 
1517 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1518 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1519 
    args = getTransactionsForCustomer_args()
1520 
    args.customerId = customerId
1521 
    args.from_date = from_date
1522 
    args.to_date = to_date
1523 
    args.status = status
1524 
    args.write(self._oprot)
1525 
    self._oprot.writeMessageEnd()
1526 
    self._oprot.trans.flush()
1527 
 
1528 
  def recv_getTransactionsForCustomer(self, ):
1529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1530 
    if mtype == TMessageType.EXCEPTION:
1531 
      x = TApplicationException()
1532 
      x.read(self._iprot)
1533 
      self._iprot.readMessageEnd()
1534 
      raise x
1535 
    result = getTransactionsForCustomer_result()
1536 
    result.read(self._iprot)
1537 
    self._iprot.readMessageEnd()
3431 rajveer 1538 
    if result.success is not None:
94 ashish 1539 
      return result.success
3431 rajveer 1540 
    if result.ex is not None:
94 ashish 1541 
      raise result.ex
1542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1543 
 
132 ashish 1544 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1545 
    """
1546 
    Parameters:
1547 
     - shoppingCartId
1548 
    """
1549 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1550 
    return self.recv_getTransactionsForShoppingCartId()
1551 
 
1552 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1553 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1554 
    args = getTransactionsForShoppingCartId_args()
1555 
    args.shoppingCartId = shoppingCartId
1556 
    args.write(self._oprot)
1557 
    self._oprot.writeMessageEnd()
1558 
    self._oprot.trans.flush()
1559 
 
1560 
  def recv_getTransactionsForShoppingCartId(self, ):
1561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1562 
    if mtype == TMessageType.EXCEPTION:
1563 
      x = TApplicationException()
1564 
      x.read(self._iprot)
1565 
      self._iprot.readMessageEnd()
1566 
      raise x
1567 
    result = getTransactionsForShoppingCartId_result()
1568 
    result.read(self._iprot)
1569 
    self._iprot.readMessageEnd()
3431 rajveer 1570 
    if result.success is not None:
132 ashish 1571 
      return result.success
3431 rajveer 1572 
    if result.ex is not None:
132 ashish 1573 
      raise result.ex
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1575 
 
94 ashish 1576 
  def getTransactionStatus(self, transactionId):
1577 
    """
1578 
    Parameters:
1579 
     - transactionId
1580 
    """
1581 
    self.send_getTransactionStatus(transactionId)
1582 
    return self.recv_getTransactionStatus()
1583 
 
1584 
  def send_getTransactionStatus(self, transactionId):
1585 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1586 
    args = getTransactionStatus_args()
1587 
    args.transactionId = transactionId
1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_getTransactionStatus(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = getTransactionStatus_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
3431 rajveer 1602 
    if result.success is not None:
94 ashish 1603 
      return result.success
3431 rajveer 1604 
    if result.ex is not None:
94 ashish 1605 
      raise result.ex
1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1607 
 
5527 anupam.sin 1608 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1609 
    """
1610 
    Parameters:
1611 
     - transactionId
1612 
     - status
1613 
     - description
5527 anupam.sin 1614 
     - pickUp
1615 
     - orderType
94 ashish 1616 
    """
5527 anupam.sin 1617 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1618 
    return self.recv_changeTransactionStatus()
1619 
 
5527 anupam.sin 1620 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1621 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1622 
    args = changeTransactionStatus_args()
1623 
    args.transactionId = transactionId
1624 
    args.status = status
1625 
    args.description = description
5527 anupam.sin 1626 
    args.pickUp = pickUp
1627 
    args.orderType = orderType
94 ashish 1628 
    args.write(self._oprot)
1629 
    self._oprot.writeMessageEnd()
1630 
    self._oprot.trans.flush()
1631 
 
1632 
  def recv_changeTransactionStatus(self, ):
1633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1634 
    if mtype == TMessageType.EXCEPTION:
1635 
      x = TApplicationException()
1636 
      x.read(self._iprot)
1637 
      self._iprot.readMessageEnd()
1638 
      raise x
1639 
    result = changeTransactionStatus_result()
1640 
    result.read(self._iprot)
1641 
    self._iprot.readMessageEnd()
3431 rajveer 1642 
    if result.success is not None:
94 ashish 1643 
      return result.success
3431 rajveer 1644 
    if result.ex is not None:
94 ashish 1645 
      raise result.ex
1646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1647 
 
1398 varun.gupt 1648 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1649 
    """
1650 
    Parameters:
1651 
     - transactionId
1652 
    """
1398 varun.gupt 1653 
    self.send_enqueueTransactionInfoEmail(transactionId)
1654 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1655 
 
1398 varun.gupt 1656 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1657 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1658 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1659 
    args.transactionId = transactionId
1660 
    args.write(self._oprot)
1661 
    self._oprot.writeMessageEnd()
1662 
    self._oprot.trans.flush()
1663 
 
1398 varun.gupt 1664 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1666 
    if mtype == TMessageType.EXCEPTION:
1667 
      x = TApplicationException()
1668 
      x.read(self._iprot)
1669 
      self._iprot.readMessageEnd()
1670 
      raise x
1398 varun.gupt 1671 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1672 
    result.read(self._iprot)
1673 
    self._iprot.readMessageEnd()
3431 rajveer 1674 
    if result.success is not None:
1382 varun.gupt 1675 
      return result.success
3431 rajveer 1676 
    if result.ex is not None:
1382 varun.gupt 1677 
      raise result.ex
1398 varun.gupt 1678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1679 
 
4801 anupam.sin 1680 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1681 
    """
1682 
    Parameters:
4801 anupam.sin 1683 
     - statuses
483 rajveer 1684 
     - from_date
1685 
     - to_date
1686 
     - warehouse_id
94 ashish 1687 
    """
4801 anupam.sin 1688 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1689 
    return self.recv_getAllOrders()
94 ashish 1690 
 
4801 anupam.sin 1691 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1692 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1693 
    args = getAllOrders_args()
4801 anupam.sin 1694 
    args.statuses = statuses
483 rajveer 1695 
    args.from_date = from_date
1696 
    args.to_date = to_date
1697 
    args.warehouse_id = warehouse_id
94 ashish 1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
483 rajveer 1702 
  def recv_getAllOrders(self, ):
94 ashish 1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
483 rajveer 1709 
    result = getAllOrders_result()
94 ashish 1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
3431 rajveer 1712 
    if result.success is not None:
94 ashish 1713 
      return result.success
3431 rajveer 1714 
    if result.ex is not None:
94 ashish 1715 
      raise result.ex
483 rajveer 1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1717 
 
4133 chandransh 1718 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1719 
    """
1720 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1721 
    Pass the status as null and the limit as 0 to ignore them.
1722 
 
1723 
    Parameters:
1724 
     - statuses
1725 
     - offset
1726 
     - limit
1727 
     - warehouse_id
1728 
    """
1729 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1730 
    return self.recv_getOrdersInBatch()
1731 
 
1732 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1733 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1734 
    args = getOrdersInBatch_args()
1735 
    args.statuses = statuses
1736 
    args.offset = offset
1737 
    args.limit = limit
1738 
    args.warehouse_id = warehouse_id
1739 
    args.write(self._oprot)
1740 
    self._oprot.writeMessageEnd()
1741 
    self._oprot.trans.flush()
1742 
 
1743 
  def recv_getOrdersInBatch(self, ):
1744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1745 
    if mtype == TMessageType.EXCEPTION:
1746 
      x = TApplicationException()
1747 
      x.read(self._iprot)
1748 
      self._iprot.readMessageEnd()
1749 
      raise x
1750 
    result = getOrdersInBatch_result()
1751 
    result.read(self._iprot)
1752 
    self._iprot.readMessageEnd()
1753 
    if result.success is not None:
1754 
      return result.success
1755 
    if result.ex is not None:
1756 
      raise result.ex
1757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1758 
 
1759 
  def getOrderCount(self, statuses, warehouseId):
1760 
    """
1761 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1762 
 
1763 
    Parameters:
1764 
     - statuses
1765 
     - warehouseId
1766 
    """
1767 
    self.send_getOrderCount(statuses, warehouseId)
1768 
    return self.recv_getOrderCount()
1769 
 
1770 
  def send_getOrderCount(self, statuses, warehouseId):
1771 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1772 
    args = getOrderCount_args()
1773 
    args.statuses = statuses
1774 
    args.warehouseId = warehouseId
1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
1779 
  def recv_getOrderCount(self, ):
1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
1786 
    result = getOrderCount_result()
1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
1789 
    if result.success is not None:
1790 
      return result.success
1791 
    if result.ex is not None:
1792 
      raise result.ex
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1794 
 
999 varun.gupt 1795 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1796 
    """
1132 chandransh 1797 
    Returns orders within a range of their billing dates
3431 rajveer 1798 
 
999 varun.gupt 1799 
    Parameters:
1800 
     - status
1801 
     - start_billing_date
1802 
     - end_billing_date
1803 
     - warehouse_id
1804 
    """
1805 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1806 
    return self.recv_getOrdersByBillingDate()
1807 
 
1808 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1809 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1810 
    args = getOrdersByBillingDate_args()
1811 
    args.status = status
1812 
    args.start_billing_date = start_billing_date
1813 
    args.end_billing_date = end_billing_date
1814 
    args.warehouse_id = warehouse_id
1815 
    args.write(self._oprot)
1816 
    self._oprot.writeMessageEnd()
1817 
    self._oprot.trans.flush()
1818 
 
1819 
  def recv_getOrdersByBillingDate(self, ):
1820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1821 
    if mtype == TMessageType.EXCEPTION:
1822 
      x = TApplicationException()
1823 
      x.read(self._iprot)
1824 
      self._iprot.readMessageEnd()
1825 
      raise x
1826 
    result = getOrdersByBillingDate_result()
1827 
    result.read(self._iprot)
1828 
    self._iprot.readMessageEnd()
3431 rajveer 1829 
    if result.success is not None:
999 varun.gupt 1830 
      return result.success
3431 rajveer 1831 
    if result.ex is not None:
999 varun.gupt 1832 
      raise result.ex
1833 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1834 
 
3451 chandransh 1835 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1836 
    """
1837 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1838 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1839 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1840 
 
3427 chandransh 1841 
    Parameters:
1842 
     - fromShippingDate
1843 
     - toShippingDate
1844 
     - providerId
1845 
     - warehouseId
3451 chandransh 1846 
     - cod
3427 chandransh 1847 
    """
3451 chandransh 1848 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1849 
    return self.recv_getOrdersByShippingDate()
1850 
 
3451 chandransh 1851 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1852 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1853 
    args = getOrdersByShippingDate_args()
1854 
    args.fromShippingDate = fromShippingDate
1855 
    args.toShippingDate = toShippingDate
1856 
    args.providerId = providerId
1857 
    args.warehouseId = warehouseId
3451 chandransh 1858 
    args.cod = cod
3427 chandransh 1859 
    args.write(self._oprot)
1860 
    self._oprot.writeMessageEnd()
1861 
    self._oprot.trans.flush()
1862 
 
1863 
  def recv_getOrdersByShippingDate(self, ):
1864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1865 
    if mtype == TMessageType.EXCEPTION:
1866 
      x = TApplicationException()
1867 
      x.read(self._iprot)
1868 
      self._iprot.readMessageEnd()
1869 
      raise x
1870 
    result = getOrdersByShippingDate_result()
1871 
    result.read(self._iprot)
1872 
    self._iprot.readMessageEnd()
3431 rajveer 1873 
    if result.success is not None:
3427 chandransh 1874 
      return result.success
3431 rajveer 1875 
    if result.ex is not None:
3427 chandransh 1876 
      raise result.ex
1877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1878 
 
1382 varun.gupt 1879 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1880 
    """
1881 
    Returns order ids for orders which can be returned
3431 rajveer 1882 
 
1382 varun.gupt 1883 
    Parameters:
1884 
     - customer_id
1885 
     - limit
1886 
    """
1887 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1888 
    return self.recv_getReturnableOrdersForCustomer()
1889 
 
1890 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1891 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1892 
    args = getReturnableOrdersForCustomer_args()
1893 
    args.customer_id = customer_id
1894 
    args.limit = limit
1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
1899 
  def recv_getReturnableOrdersForCustomer(self, ):
1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
1906 
    result = getReturnableOrdersForCustomer_result()
1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
3431 rajveer 1909 
    if result.success is not None:
1382 varun.gupt 1910 
      return result.success
3431 rajveer 1911 
    if result.ex is not None:
1382 varun.gupt 1912 
      raise result.ex
1913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1914 
 
1915 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1916 
    """
1917 
    Returns order ids for orders which can be cancelled
3431 rajveer 1918 
 
1382 varun.gupt 1919 
    Parameters:
1920 
     - customer_id
1921 
     - limit
1922 
    """
1923 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1924 
    return self.recv_getCancellableOrdersForCustomer()
1925 
 
1926 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1927 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1928 
    args = getCancellableOrdersForCustomer_args()
1929 
    args.customer_id = customer_id
1930 
    args.limit = limit
1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
1935 
  def recv_getCancellableOrdersForCustomer(self, ):
1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
1942 
    result = getCancellableOrdersForCustomer_result()
1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
3431 rajveer 1945 
    if result.success is not None:
1382 varun.gupt 1946 
      return result.success
3431 rajveer 1947 
    if result.ex is not None:
1382 varun.gupt 1948 
      raise result.ex
1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1950 
 
483 rajveer 1951 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1952 
    """
1953 
    Parameters:
483 rajveer 1954 
     - orderId
1955 
     - status
1956 
     - description
94 ashish 1957 
    """
483 rajveer 1958 
    self.send_changeOrderStatus(orderId, status, description)
1959 
    return self.recv_changeOrderStatus()
94 ashish 1960 
 
483 rajveer 1961 
  def send_changeOrderStatus(self, orderId, status, description):
1962 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1963 
    args = changeOrderStatus_args()
1964 
    args.orderId = orderId
1965 
    args.status = status
1966 
    args.description = description
94 ashish 1967 
    args.write(self._oprot)
1968 
    self._oprot.writeMessageEnd()
1969 
    self._oprot.trans.flush()
1970 
 
483 rajveer 1971 
  def recv_changeOrderStatus(self, ):
94 ashish 1972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1973 
    if mtype == TMessageType.EXCEPTION:
1974 
      x = TApplicationException()
1975 
      x.read(self._iprot)
1976 
      self._iprot.readMessageEnd()
1977 
      raise x
483 rajveer 1978 
    result = changeOrderStatus_result()
94 ashish 1979 
    result.read(self._iprot)
1980 
    self._iprot.readMessageEnd()
3431 rajveer 1981 
    if result.success is not None:
94 ashish 1982 
      return result.success
3431 rajveer 1983 
    if result.ex is not None:
94 ashish 1984 
      raise result.ex
483 rajveer 1985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1986 
 
1528 ankur.sing 1987 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1988 
    """
1528 ankur.sing 1989 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1990 
    only user who owns the transaction can view its order details.
3431 rajveer 1991 
 
94 ashish 1992 
    Parameters:
1993 
     - transactionId
1528 ankur.sing 1994 
     - customerId
94 ashish 1995 
    """
1528 ankur.sing 1996 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1997 
    return self.recv_getOrdersForTransaction()
94 ashish 1998 
 
1528 ankur.sing 1999 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2000 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2001 
    args = getOrdersForTransaction_args()
94 ashish 2002 
    args.transactionId = transactionId
1528 ankur.sing 2003 
    args.customerId = customerId
94 ashish 2004 
    args.write(self._oprot)
2005 
    self._oprot.writeMessageEnd()
2006 
    self._oprot.trans.flush()
2007 
 
483 rajveer 2008 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2010 
    if mtype == TMessageType.EXCEPTION:
2011 
      x = TApplicationException()
2012 
      x.read(self._iprot)
2013 
      self._iprot.readMessageEnd()
2014 
      raise x
483 rajveer 2015 
    result = getOrdersForTransaction_result()
94 ashish 2016 
    result.read(self._iprot)
2017 
    self._iprot.readMessageEnd()
3431 rajveer 2018 
    if result.success is not None:
94 ashish 2019 
      return result.success
3431 rajveer 2020 
    if result.ex is not None:
94 ashish 2021 
      raise result.ex
483 rajveer 2022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2023 
 
3014 chandransh 2024 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2025 
    """
3014 chandransh 2026 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2027 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2028 
 
94 ashish 2029 
    Parameters:
483 rajveer 2030 
     - customerId
2031 
     - from_date
2032 
     - to_date
3014 chandransh 2033 
     - statuses
94 ashish 2034 
    """
3014 chandransh 2035 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2036 
    return self.recv_getOrdersForCustomer()
94 ashish 2037 
 
3014 chandransh 2038 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2039 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2040 
    args = getOrdersForCustomer_args()
2041 
    args.customerId = customerId
2042 
    args.from_date = from_date
2043 
    args.to_date = to_date
3014 chandransh 2044 
    args.statuses = statuses
94 ashish 2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
483 rajveer 2049 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
483 rajveer 2056 
    result = getOrdersForCustomer_result()
94 ashish 2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
3431 rajveer 2059 
    if result.success is not None:
94 ashish 2060 
      return result.success
3431 rajveer 2061 
    if result.ex is not None:
94 ashish 2062 
      raise result.ex
483 rajveer 2063 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2064 
 
483 rajveer 2065 
  def createOrder(self, order):
94 ashish 2066 
    """
2067 
    Parameters:
483 rajveer 2068 
     - order
94 ashish 2069 
    """
483 rajveer 2070 
    self.send_createOrder(order)
2071 
    return self.recv_createOrder()
94 ashish 2072 
 
483 rajveer 2073 
  def send_createOrder(self, order):
2074 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2075 
    args = createOrder_args()
2076 
    args.order = order
94 ashish 2077 
    args.write(self._oprot)
2078 
    self._oprot.writeMessageEnd()
2079 
    self._oprot.trans.flush()
2080 
 
483 rajveer 2081 
  def recv_createOrder(self, ):
94 ashish 2082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2083 
    if mtype == TMessageType.EXCEPTION:
2084 
      x = TApplicationException()
2085 
      x.read(self._iprot)
2086 
      self._iprot.readMessageEnd()
2087 
      raise x
483 rajveer 2088 
    result = createOrder_result()
94 ashish 2089 
    result.read(self._iprot)
2090 
    self._iprot.readMessageEnd()
3431 rajveer 2091 
    if result.success is not None:
94 ashish 2092 
      return result.success
3431 rajveer 2093 
    if result.ex is not None:
94 ashish 2094 
      raise result.ex
483 rajveer 2095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2096 
 
483 rajveer 2097 
  def getOrder(self, id):
94 ashish 2098 
    """
2099 
    Parameters:
483 rajveer 2100 
     - id
94 ashish 2101 
    """
483 rajveer 2102 
    self.send_getOrder(id)
2103 
    return self.recv_getOrder()
94 ashish 2104 
 
483 rajveer 2105 
  def send_getOrder(self, id):
2106 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2107 
    args = getOrder_args()
2108 
    args.id = id
94 ashish 2109 
    args.write(self._oprot)
2110 
    self._oprot.writeMessageEnd()
2111 
    self._oprot.trans.flush()
2112 
 
483 rajveer 2113 
  def recv_getOrder(self, ):
94 ashish 2114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2115 
    if mtype == TMessageType.EXCEPTION:
2116 
      x = TApplicationException()
2117 
      x.read(self._iprot)
2118 
      self._iprot.readMessageEnd()
2119 
      raise x
483 rajveer 2120 
    result = getOrder_result()
94 ashish 2121 
    result.read(self._iprot)
2122 
    self._iprot.readMessageEnd()
3431 rajveer 2123 
    if result.success is not None:
94 ashish 2124 
      return result.success
3431 rajveer 2125 
    if result.ex is not None:
94 ashish 2126 
      raise result.ex
483 rajveer 2127 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2128 
 
483 rajveer 2129 
  def getLineItemsForOrder(self, orderId):
94 ashish 2130 
    """
2131 
    Parameters:
483 rajveer 2132 
     - orderId
94 ashish 2133 
    """
483 rajveer 2134 
    self.send_getLineItemsForOrder(orderId)
2135 
    return self.recv_getLineItemsForOrder()
94 ashish 2136 
 
483 rajveer 2137 
  def send_getLineItemsForOrder(self, orderId):
2138 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2139 
    args = getLineItemsForOrder_args()
2140 
    args.orderId = orderId
94 ashish 2141 
    args.write(self._oprot)
2142 
    self._oprot.writeMessageEnd()
2143 
    self._oprot.trans.flush()
2144 
 
483 rajveer 2145 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2147 
    if mtype == TMessageType.EXCEPTION:
2148 
      x = TApplicationException()
2149 
      x.read(self._iprot)
2150 
      self._iprot.readMessageEnd()
2151 
      raise x
483 rajveer 2152 
    result = getLineItemsForOrder_result()
94 ashish 2153 
    result.read(self._iprot)
2154 
    self._iprot.readMessageEnd()
3431 rajveer 2155 
    if result.success is not None:
94 ashish 2156 
      return result.success
3431 rajveer 2157 
    if result.ex is not None:
94 ashish 2158 
      raise result.ex
483 rajveer 2159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2160 
 
4999 phani.kuma 2161 
  def getOrderList(self, order_ids):
2162 
    """
2163 
    Parameters:
2164 
     - order_ids
2165 
    """
2166 
    self.send_getOrderList(order_ids)
2167 
    return self.recv_getOrderList()
2168 
 
2169 
  def send_getOrderList(self, order_ids):
2170 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2171 
    args = getOrderList_args()
2172 
    args.order_ids = order_ids
2173 
    args.write(self._oprot)
2174 
    self._oprot.writeMessageEnd()
2175 
    self._oprot.trans.flush()
2176 
 
2177 
  def recv_getOrderList(self, ):
2178 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2179 
    if mtype == TMessageType.EXCEPTION:
2180 
      x = TApplicationException()
2181 
      x.read(self._iprot)
2182 
      self._iprot.readMessageEnd()
2183 
      raise x
2184 
    result = getOrderList_result()
2185 
    result.read(self._iprot)
2186 
    self._iprot.readMessageEnd()
2187 
    if result.success is not None:
2188 
      return result.success
2189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2190 
 
5386 phani.kuma 2191 
  def getOrderListForVendor(self, order_ids, vendorId):
2192 
    """
2193 
    Parameters:
2194 
     - order_ids
2195 
     - vendorId
2196 
    """
2197 
    self.send_getOrderListForVendor(order_ids, vendorId)
2198 
    return self.recv_getOrderListForVendor()
2199 
 
2200 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2201 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2202 
    args = getOrderListForVendor_args()
2203 
    args.order_ids = order_ids
2204 
    args.vendorId = vendorId
2205 
    args.write(self._oprot)
2206 
    self._oprot.writeMessageEnd()
2207 
    self._oprot.trans.flush()
2208 
 
2209 
  def recv_getOrderListForVendor(self, ):
2210 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2211 
    if mtype == TMessageType.EXCEPTION:
2212 
      x = TApplicationException()
2213 
      x.read(self._iprot)
2214 
      self._iprot.readMessageEnd()
2215 
      raise x
2216 
    result = getOrderListForVendor_result()
2217 
    result.read(self._iprot)
2218 
    self._iprot.readMessageEnd()
2219 
    if result.success is not None:
2220 
      return result.success
2221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2222 
 
1528 ankur.sing 2223 
  def getOrderForCustomer(self, orderId, customerId):
2224 
    """
2225 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2226 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2227 
 
1528 ankur.sing 2228 
    Parameters:
2229 
     - orderId
2230 
     - customerId
2231 
    """
2232 
    self.send_getOrderForCustomer(orderId, customerId)
2233 
    return self.recv_getOrderForCustomer()
2234 
 
2235 
  def send_getOrderForCustomer(self, orderId, customerId):
2236 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2237 
    args = getOrderForCustomer_args()
2238 
    args.orderId = orderId
2239 
    args.customerId = customerId
2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
2244 
  def recv_getOrderForCustomer(self, ):
2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
2251 
    result = getOrderForCustomer_result()
2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
3431 rajveer 2254 
    if result.success is not None:
1528 ankur.sing 2255 
      return result.success
3431 rajveer 2256 
    if result.ex is not None:
1528 ankur.sing 2257 
      raise result.ex
2258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2259 
 
4444 rajveer 2260 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2261 
    """
2262 
    Parameters:
4394 rajveer 2263 
     - type
4444 rajveer 2264 
     - warehouseId
4394 rajveer 2265 
     - status
2266 
     - timestamp
3064 chandransh 2267 
    """
4444 rajveer 2268 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2269 
    return self.recv_getAlerts()
2270 
 
4444 rajveer 2271 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2272 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2273 
    args = getAlerts_args()
4394 rajveer 2274 
    args.type = type
4444 rajveer 2275 
    args.warehouseId = warehouseId
4394 rajveer 2276 
    args.status = status
2277 
    args.timestamp = timestamp
3064 chandransh 2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_getAlerts(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = getAlerts_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
3431 rajveer 2292 
    if result.success is not None:
3064 chandransh 2293 
      return result.success
2294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2295 
 
4444 rajveer 2296 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2297 
    """
2298 
    Parameters:
2299 
     - type
4444 rajveer 2300 
     - warehouseId
4394 rajveer 2301 
     - description
3064 chandransh 2302 
    """
4444 rajveer 2303 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2304 
    self.recv_addAlert()
3064 chandransh 2305 
 
4444 rajveer 2306 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2307 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2308 
    args = addAlert_args()
3064 chandransh 2309 
    args.type = type
4444 rajveer 2310 
    args.warehouseId = warehouseId
4394 rajveer 2311 
    args.description = description
3064 chandransh 2312 
    args.write(self._oprot)
2313 
    self._oprot.writeMessageEnd()
2314 
    self._oprot.trans.flush()
2315 
 
4394 rajveer 2316 
  def recv_addAlert(self, ):
3064 chandransh 2317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2318 
    if mtype == TMessageType.EXCEPTION:
2319 
      x = TApplicationException()
2320 
      x.read(self._iprot)
2321 
      self._iprot.readMessageEnd()
2322 
      raise x
4394 rajveer 2323 
    result = addAlert_result()
3064 chandransh 2324 
    result.read(self._iprot)
2325 
    self._iprot.readMessageEnd()
2326 
    return
2327 
 
4444 rajveer 2328 
  def markAlertsAsSeen(self, warehouseId):
2329 
    """
2330 
    Parameters:
2331 
     - warehouseId
2332 
    """
2333 
    self.send_markAlertsAsSeen(warehouseId)
2334 
    self.recv_markAlertsAsSeen()
2335 
 
2336 
  def send_markAlertsAsSeen(self, warehouseId):
2337 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2338 
    args = markAlertsAsSeen_args()
2339 
    args.warehouseId = warehouseId
2340 
    args.write(self._oprot)
2341 
    self._oprot.writeMessageEnd()
2342 
    self._oprot.trans.flush()
2343 
 
2344 
  def recv_markAlertsAsSeen(self, ):
2345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2346 
    if mtype == TMessageType.EXCEPTION:
2347 
      x = TApplicationException()
2348 
      x.read(self._iprot)
2349 
      self._iprot.readMessageEnd()
2350 
      raise x
2351 
    result = markAlertsAsSeen_result()
2352 
    result.read(self._iprot)
2353 
    self._iprot.readMessageEnd()
2354 
    return
2355 
 
3064 chandransh 2356 
  def getValidOrderCount(self, ):
2357 
    """
2358 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2359 
    """
2360 
    self.send_getValidOrderCount()
2361 
    return self.recv_getValidOrderCount()
2362 
 
2363 
  def send_getValidOrderCount(self, ):
2364 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2365 
    args = getValidOrderCount_args()
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_getValidOrderCount(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = getValidOrderCount_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
3431 rajveer 2380 
    if result.success is not None:
3064 chandransh 2381 
      return result.success
2382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2383 
 
2384 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2385 
    """
2386 
    Returns the number of distinct customers who have done successful transactions
2387 
    """
2388 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2389 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2390 
 
2391 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2392 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2393 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2394 
    args.write(self._oprot)
2395 
    self._oprot.writeMessageEnd()
2396 
    self._oprot.trans.flush()
2397 
 
2398 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2400 
    if mtype == TMessageType.EXCEPTION:
2401 
      x = TApplicationException()
2402 
      x.read(self._iprot)
2403 
      self._iprot.readMessageEnd()
2404 
      raise x
2405 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2406 
    result.read(self._iprot)
2407 
    self._iprot.readMessageEnd()
3431 rajveer 2408 
    if result.success is not None:
3064 chandransh 2409 
      return result.success
2410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2411 
 
2412 
  def getValidOrdersAmountRange(self, ):
2413 
    """
2414 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2415 
    List contains two values, first minimum amount and second maximum amount.
2416 
    """
2417 
    self.send_getValidOrdersAmountRange()
2418 
    return self.recv_getValidOrdersAmountRange()
2419 
 
2420 
  def send_getValidOrdersAmountRange(self, ):
2421 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2422 
    args = getValidOrdersAmountRange_args()
2423 
    args.write(self._oprot)
2424 
    self._oprot.writeMessageEnd()
2425 
    self._oprot.trans.flush()
2426 
 
2427 
  def recv_getValidOrdersAmountRange(self, ):
2428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2429 
    if mtype == TMessageType.EXCEPTION:
2430 
      x = TApplicationException()
2431 
      x.read(self._iprot)
2432 
      self._iprot.readMessageEnd()
2433 
      raise x
2434 
    result = getValidOrdersAmountRange_result()
2435 
    result.read(self._iprot)
2436 
    self._iprot.readMessageEnd()
3431 rajveer 2437 
    if result.success is not None:
3064 chandransh 2438 
      return result.success
2439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2440 
 
5874 rajveer 2441 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2442 
    """
2443 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2444 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2445 
 
3064 chandransh 2446 
    Parameters:
2447 
     - limit
5874 rajveer 2448 
     - onlyStore
3064 chandransh 2449 
    """
5874 rajveer 2450 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2451 
    return self.recv_getValidOrders()
2452 
 
5874 rajveer 2453 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2454 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2455 
    args = getValidOrders_args()
2456 
    args.limit = limit
5874 rajveer 2457 
    args.onlyStore = onlyStore
3064 chandransh 2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
2462 
  def recv_getValidOrders(self, ):
2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
2469 
    result = getValidOrders_result()
2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
3431 rajveer 2472 
    if result.success is not None:
3064 chandransh 2473 
      return result.success
2474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2475 
 
1220 chandransh 2476 
  def batchOrders(self, warehouseId):
2477 
    """
2478 
    Create a batch of all the pending orders for the given warehouse.
2479 
    The returned list is orderd by created_timestamp.
2480 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2481 
 
1220 chandransh 2482 
    Parameters:
2483 
     - warehouseId
2484 
    """
2485 
    self.send_batchOrders(warehouseId)
2486 
    return self.recv_batchOrders()
2487 
 
2488 
  def send_batchOrders(self, warehouseId):
2489 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2490 
    args = batchOrders_args()
2491 
    args.warehouseId = warehouseId
2492 
    args.write(self._oprot)
2493 
    self._oprot.writeMessageEnd()
2494 
    self._oprot.trans.flush()
2495 
 
2496 
  def recv_batchOrders(self, ):
2497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2498 
    if mtype == TMessageType.EXCEPTION:
2499 
      x = TApplicationException()
2500 
      x.read(self._iprot)
2501 
      self._iprot.readMessageEnd()
2502 
      raise x
2503 
    result = batchOrders_result()
2504 
    result.read(self._iprot)
2505 
    self._iprot.readMessageEnd()
3431 rajveer 2506 
    if result.success is not None:
1220 chandransh 2507 
      return result.success
3431 rajveer 2508 
    if result.ex is not None:
1220 chandransh 2509 
      raise result.ex
2510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2511 
 
1208 chandransh 2512 
  def markOrderAsOutOfStock(self, orderId):
2513 
    """
2514 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2515 
 
1208 chandransh 2516 
    Parameters:
2517 
     - orderId
2518 
    """
2519 
    self.send_markOrderAsOutOfStock(orderId)
2520 
    return self.recv_markOrderAsOutOfStock()
2521 
 
2522 
  def send_markOrderAsOutOfStock(self, orderId):
2523 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2524 
    args = markOrderAsOutOfStock_args()
2525 
    args.orderId = orderId
2526 
    args.write(self._oprot)
2527 
    self._oprot.writeMessageEnd()
2528 
    self._oprot.trans.flush()
2529 
 
2530 
  def recv_markOrderAsOutOfStock(self, ):
2531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2532 
    if mtype == TMessageType.EXCEPTION:
2533 
      x = TApplicationException()
2534 
      x.read(self._iprot)
2535 
      self._iprot.readMessageEnd()
2536 
      raise x
2537 
    result = markOrderAsOutOfStock_result()
2538 
    result.read(self._iprot)
2539 
    self._iprot.readMessageEnd()
3431 rajveer 2540 
    if result.success is not None:
1208 chandransh 2541 
      return result.success
3431 rajveer 2542 
    if result.ex is not None:
1208 chandransh 2543 
      raise result.ex
2544 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2545 
 
3064 chandransh 2546 
  def verifyOrder(self, orderId):
759 chandransh 2547 
    """
3064 chandransh 2548 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2549 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2550 
    used for all other orders as well.
2551 
    Throws an exception if no such order exists.
3431 rajveer 2552 
 
759 chandransh 2553 
    Parameters:
3064 chandransh 2554 
     - orderId
759 chandransh 2555 
    """
3064 chandransh 2556 
    self.send_verifyOrder(orderId)
2557 
    return self.recv_verifyOrder()
759 chandransh 2558 
 
3064 chandransh 2559 
  def send_verifyOrder(self, orderId):
2560 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2561 
    args = verifyOrder_args()
2562 
    args.orderId = orderId
759 chandransh 2563 
    args.write(self._oprot)
2564 
    self._oprot.writeMessageEnd()
2565 
    self._oprot.trans.flush()
2566 
 
3064 chandransh 2567 
  def recv_verifyOrder(self, ):
759 chandransh 2568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2569 
    if mtype == TMessageType.EXCEPTION:
2570 
      x = TApplicationException()
2571 
      x.read(self._iprot)
2572 
      self._iprot.readMessageEnd()
2573 
      raise x
3064 chandransh 2574 
    result = verifyOrder_result()
759 chandransh 2575 
    result.read(self._iprot)
2576 
    self._iprot.readMessageEnd()
3431 rajveer 2577 
    if result.success is not None:
759 chandransh 2578 
      return result.success
3431 rajveer 2579 
    if result.ex is not None:
759 chandransh 2580 
      raise result.ex
3064 chandransh 2581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2582 
 
3064 chandransh 2583 
  def acceptOrder(self, orderId):
1113 chandransh 2584 
    """
3064 chandransh 2585 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2586 
    given order is not a COD order, it also captures the payment if the same has
2587 
    not been captured.
2588 
    Throws an exception if no such order exists.
3431 rajveer 2589 
 
1113 chandransh 2590 
    Parameters:
3064 chandransh 2591 
     - orderId
1113 chandransh 2592 
    """
3064 chandransh 2593 
    self.send_acceptOrder(orderId)
2594 
    return self.recv_acceptOrder()
1113 chandransh 2595 
 
3064 chandransh 2596 
  def send_acceptOrder(self, orderId):
2597 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2598 
    args = acceptOrder_args()
2599 
    args.orderId = orderId
1113 chandransh 2600 
    args.write(self._oprot)
2601 
    self._oprot.writeMessageEnd()
2602 
    self._oprot.trans.flush()
2603 
 
3064 chandransh 2604 
  def recv_acceptOrder(self, ):
1113 chandransh 2605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2606 
    if mtype == TMessageType.EXCEPTION:
2607 
      x = TApplicationException()
2608 
      x.read(self._iprot)
2609 
      self._iprot.readMessageEnd()
2610 
      raise x
3064 chandransh 2611 
    result = acceptOrder_result()
1113 chandransh 2612 
    result.read(self._iprot)
2613 
    self._iprot.readMessageEnd()
3431 rajveer 2614 
    if result.success is not None:
1113 chandransh 2615 
      return result.success
3431 rajveer 2616 
    if result.ex is not None:
1113 chandransh 2617 
      raise result.ex
3064 chandransh 2618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2619 
 
5110 mandeep.dh 2620 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2621 
    """
3064 chandransh 2622 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2623 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2624 
    the IMEI no. if a -1 is supplied.
2625 
    Also, it generates an invoice number for the order, marks the order as
2626 
    BILLED and sets the billing timestamp.
2627 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2628 
 
1135 chandransh 2629 
    Parameters:
3064 chandransh 2630 
     - orderId
2631 
     - invoice_number
4658 mandeep.dh 2632 
     - serialNumber
4283 anupam.sin 2633 
     - itemNumber
3064 chandransh 2634 
     - billed_by
4264 rajveer 2635 
     - jacketNumber
4283 anupam.sin 2636 
     - billingType
5110 mandeep.dh 2637 
     - fulfilmentWarehouseId
4763 rajveer 2638 
     - authorize
1135 chandransh 2639 
    """
5110 mandeep.dh 2640 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2641 
    return self.recv_addBillingDetails()
1135 chandransh 2642 
 
5110 mandeep.dh 2643 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2644 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2645 
    args = addBillingDetails_args()
2646 
    args.orderId = orderId
2647 
    args.invoice_number = invoice_number
4658 mandeep.dh 2648 
    args.serialNumber = serialNumber
4283 anupam.sin 2649 
    args.itemNumber = itemNumber
3064 chandransh 2650 
    args.billed_by = billed_by
4264 rajveer 2651 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2652 
    args.billingType = billingType
5110 mandeep.dh 2653 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2654 
    args.authorize = authorize
1135 chandransh 2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
3064 chandransh 2659 
  def recv_addBillingDetails(self, ):
1135 chandransh 2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
3064 chandransh 2666 
    result = addBillingDetails_result()
1135 chandransh 2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
3431 rajveer 2669 
    if result.success is not None:
3064 chandransh 2670 
      return result.success
3431 rajveer 2671 
    if result.ex is not None:
1135 chandransh 2672 
      raise result.ex
3064 chandransh 2673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2674 
 
4763 rajveer 2675 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2676 
    """
2677 
    Add the invoice number to the order.
2678 
 
2679 
    Parameters:
2680 
     - orderId
2681 
     - invoiceNumber
4763 rajveer 2682 
     - color
4579 rajveer 2683 
    """
4763 rajveer 2684 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2685 
    self.recv_addInvoiceNumber()
2686 
 
4763 rajveer 2687 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2688 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2689 
    args = addInvoiceNumber_args()
2690 
    args.orderId = orderId
2691 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2692 
    args.color = color
4579 rajveer 2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
2697 
  def recv_addInvoiceNumber(self, ):
2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
2704 
    result = addInvoiceNumber_result()
2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
2707 
    if result.ex is not None:
2708 
      raise result.ex
2709 
    return
2710 
 
4910 phani.kuma 2711 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2712 
    """
3064 chandransh 2713 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2714 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2715 
 
1408 ankur.sing 2716 
    Parameters:
3064 chandransh 2717 
     - warehouseId
1408 ankur.sing 2718 
     - providerId
3064 chandransh 2719 
     - cod
4910 phani.kuma 2720 
     - orderIds
1408 ankur.sing 2721 
    """
4910 phani.kuma 2722 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2723 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2724 
 
4910 phani.kuma 2725 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2726 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2727 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2728 
    args.warehouseId = warehouseId
1408 ankur.sing 2729 
    args.providerId = providerId
3064 chandransh 2730 
    args.cod = cod
4910 phani.kuma 2731 
    args.orderIds = orderIds
1408 ankur.sing 2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
4910 phani.kuma 2736 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
4910 phani.kuma 2743 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
3431 rajveer 2746 
    if result.success is not None:
1408 ankur.sing 2747 
      return result.success
3431 rajveer 2748 
    if result.ex is not None:
3064 chandransh 2749 
      raise result.ex
4910 phani.kuma 2750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2751 
 
5713 rajveer 2752 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2753 
    """
2754 
    Parameters:
2755 
     - providerId
2756 
     - orderIds
5713 rajveer 2757 
     - awbs
5676 rajveer 2758 
    """
5713 rajveer 2759 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2760 
    return self.recv_markOrdersAsReturnedFromStore()
2761 
 
5713 rajveer 2762 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2763 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2764 
    args = markOrdersAsReturnedFromStore_args()
2765 
    args.providerId = providerId
2766 
    args.orderIds = orderIds
5713 rajveer 2767 
    args.awbs = awbs
5676 rajveer 2768 
    args.write(self._oprot)
2769 
    self._oprot.writeMessageEnd()
2770 
    self._oprot.trans.flush()
2771 
 
2772 
  def recv_markOrdersAsReturnedFromStore(self, ):
2773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2774 
    if mtype == TMessageType.EXCEPTION:
2775 
      x = TApplicationException()
2776 
      x.read(self._iprot)
2777 
      self._iprot.readMessageEnd()
2778 
      raise x
2779 
    result = markOrdersAsReturnedFromStore_result()
2780 
    result.read(self._iprot)
2781 
    self._iprot.readMessageEnd()
2782 
    if result.success is not None:
2783 
      return result.success
2784 
    if result.ex is not None:
2785 
      raise result.ex
2786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2787 
 
4910 phani.kuma 2788 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2789 
    """
4910 phani.kuma 2790 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2791 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2792 
 
2793 
    Parameters:
2794 
     - providerId
4910 phani.kuma 2795 
     - pickupDetails
4410 rajveer 2796 
    """
4910 phani.kuma 2797 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2798 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2799 
 
4910 phani.kuma 2800 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2801 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2802 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2803 
    args.providerId = providerId
4910 phani.kuma 2804 
    args.pickupDetails = pickupDetails
4410 rajveer 2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
4910 phani.kuma 2809 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
4910 phani.kuma 2816 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
2819 
    if result.ex is not None:
2820 
      raise result.ex
4910 phani.kuma 2821 
    return
4410 rajveer 2822 
 
4910 phani.kuma 2823 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2824 
    """
3064 chandransh 2825 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2826 
 
94 ashish 2827 
    Parameters:
3064 chandransh 2828 
     - providerId
304 ashish 2829 
    """
4910 phani.kuma 2830 
    self.send_getOrdersNotPickedUp(providerId)
2831 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2832 
 
4910 phani.kuma 2833 
  def send_getOrdersNotPickedUp(self, providerId):
2834 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2835 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2836 
    args.providerId = providerId
304 ashish 2837 
    args.write(self._oprot)
2838 
    self._oprot.writeMessageEnd()
2839 
    self._oprot.trans.flush()
2840 
 
4910 phani.kuma 2841 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2843 
    if mtype == TMessageType.EXCEPTION:
2844 
      x = TApplicationException()
2845 
      x.read(self._iprot)
2846 
      self._iprot.readMessageEnd()
2847 
      raise x
4910 phani.kuma 2848 
    result = getOrdersNotPickedUp_result()
304 ashish 2849 
    result.read(self._iprot)
2850 
    self._iprot.readMessageEnd()
3431 rajveer 2851 
    if result.success is not None:
304 ashish 2852 
      return result.success
4910 phani.kuma 2853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2854 
 
3064 chandransh 2855 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2856 
    """
3064 chandransh 2857 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2858 
    the name of the receiver.
2859 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2860 
 
304 ashish 2861 
    Parameters:
3064 chandransh 2862 
     - providerId
2863 
     - deliveredOrders
304 ashish 2864 
    """
3064 chandransh 2865 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2866 
    self.recv_markOrdersAsDelivered()
304 ashish 2867 
 
3064 chandransh 2868 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2869 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2870 
    args = markOrdersAsDelivered_args()
2871 
    args.providerId = providerId
2872 
    args.deliveredOrders = deliveredOrders
304 ashish 2873 
    args.write(self._oprot)
2874 
    self._oprot.writeMessageEnd()
2875 
    self._oprot.trans.flush()
2876 
 
3064 chandransh 2877 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2879 
    if mtype == TMessageType.EXCEPTION:
2880 
      x = TApplicationException()
2881 
      x.read(self._iprot)
2882 
      self._iprot.readMessageEnd()
2883 
      raise x
3064 chandransh 2884 
    result = markOrdersAsDelivered_result()
304 ashish 2885 
    result.read(self._iprot)
2886 
    self._iprot.readMessageEnd()
3431 rajveer 2887 
    if result.ex is not None:
3064 chandransh 2888 
      raise result.ex
304 ashish 2889 
    return
2890 
 
4910 phani.kuma 2891 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2892 
    """
4910 phani.kuma 2893 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2894 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2895 
 
3064 chandransh 2896 
    Parameters:
2897 
     - providerId
2898 
     - returnedOrders
1596 ankur.sing 2899 
    """
4910 phani.kuma 2900 
    self.send_markAsRTOrders(providerId, returnedOrders)
2901 
    self.recv_markAsRTOrders()
304 ashish 2902 
 
4910 phani.kuma 2903 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2904 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2905 
    args = markAsRTOrders_args()
3064 chandransh 2906 
    args.providerId = providerId
2907 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2908 
    args.write(self._oprot)
2909 
    self._oprot.writeMessageEnd()
2910 
    self._oprot.trans.flush()
2911 
 
4910 phani.kuma 2912 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2914 
    if mtype == TMessageType.EXCEPTION:
2915 
      x = TApplicationException()
2916 
      x.read(self._iprot)
2917 
      self._iprot.readMessageEnd()
2918 
      raise x
4910 phani.kuma 2919 
    result = markAsRTOrders_result()
1596 ankur.sing 2920 
    result.read(self._iprot)
2921 
    self._iprot.readMessageEnd()
3431 rajveer 2922 
    if result.ex is not None:
3064 chandransh 2923 
      raise result.ex
2924 
    return
1596 ankur.sing 2925 
 
4910 phani.kuma 2926 
  def getRTOrders(self, providerId):
2927 
    """
2928 
    Returns a list of orders that were returned by courier.
2929 
 
2930 
    Parameters:
2931 
     - providerId
2932 
    """
2933 
    self.send_getRTOrders(providerId)
2934 
    return self.recv_getRTOrders()
2935 
 
2936 
  def send_getRTOrders(self, providerId):
2937 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2938 
    args = getRTOrders_args()
2939 
    args.providerId = providerId
2940 
    args.write(self._oprot)
2941 
    self._oprot.writeMessageEnd()
2942 
    self._oprot.trans.flush()
2943 
 
2944 
  def recv_getRTOrders(self, ):
2945 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2946 
    if mtype == TMessageType.EXCEPTION:
2947 
      x = TApplicationException()
2948 
      x.read(self._iprot)
2949 
      self._iprot.readMessageEnd()
2950 
      raise x
2951 
    result = getRTOrders_result()
2952 
    result.read(self._iprot)
2953 
    self._iprot.readMessageEnd()
2954 
    if result.success is not None:
2955 
      return result.success
2956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2957 
 
3064 chandransh 2958 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2959 
    """
3064 chandransh 2960 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2961 
 
3064 chandransh 2962 
    Parameters:
2963 
     - providerId
2964 
     - undeliveredOrders
1627 ankur.sing 2965 
    """
3064 chandransh 2966 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2967 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2968 
 
3064 chandransh 2969 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2970 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2971 
    args = updateNonDeliveryReason_args()
2972 
    args.providerId = providerId
2973 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2974 
    args.write(self._oprot)
2975 
    self._oprot.writeMessageEnd()
2976 
    self._oprot.trans.flush()
2977 
 
3064 chandransh 2978 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2980 
    if mtype == TMessageType.EXCEPTION:
2981 
      x = TApplicationException()
2982 
      x.read(self._iprot)
2983 
      self._iprot.readMessageEnd()
2984 
      raise x
3064 chandransh 2985 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2986 
    result.read(self._iprot)
2987 
    self._iprot.readMessageEnd()
4910 phani.kuma 2988 
    if result.ex is not None:
2989 
      raise result.ex
2990 
    return
2991 
 
2992 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2993 
    """
2994 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2995 
 
2996 
    Parameters:
2997 
     - providerId
2998 
    """
2999 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3000 
    return self.recv_getNonDeliveredOrdersbyCourier()
3001 
 
3002 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3003 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3004 
    args = getNonDeliveredOrdersbyCourier_args()
3005 
    args.providerId = providerId
3006 
    args.write(self._oprot)
3007 
    self._oprot.writeMessageEnd()
3008 
    self._oprot.trans.flush()
3009 
 
3010 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3011 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3012 
    if mtype == TMessageType.EXCEPTION:
3013 
      x = TApplicationException()
3014 
      x.read(self._iprot)
3015 
      self._iprot.readMessageEnd()
3016 
      raise x
3017 
    result = getNonDeliveredOrdersbyCourier_result()
3018 
    result.read(self._iprot)
3019 
    self._iprot.readMessageEnd()
4581 phani.kuma 3020 
    if result.success is not None:
3021 
      return result.success
4910 phani.kuma 3022 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3023 
 
3024 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3025 
    """
3026 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3027 
 
3028 
    Parameters:
3029 
     - providerId
3030 
     - local_connected_orders
3031 
    """
3032 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3033 
    self.recv_markOrdersAsLocalConnected()
3034 
 
3035 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3036 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3037 
    args = markOrdersAsLocalConnected_args()
3038 
    args.providerId = providerId
3039 
    args.local_connected_orders = local_connected_orders
3040 
    args.write(self._oprot)
3041 
    self._oprot.writeMessageEnd()
3042 
    self._oprot.trans.flush()
3043 
 
3044 
  def recv_markOrdersAsLocalConnected(self, ):
3045 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3046 
    if mtype == TMessageType.EXCEPTION:
3047 
      x = TApplicationException()
3048 
      x.read(self._iprot)
3049 
      self._iprot.readMessageEnd()
3050 
      raise x
3051 
    result = markOrdersAsLocalConnected_result()
3052 
    result.read(self._iprot)
3053 
    self._iprot.readMessageEnd()
3431 rajveer 3054 
    if result.ex is not None:
3064 chandransh 3055 
      raise result.ex
4910 phani.kuma 3056 
    return
1627 ankur.sing 3057 
 
4910 phani.kuma 3058 
  def getOrdersNotLocalConnected(self, providerId):
3059 
    """
3060 
    Returns a list of orders that were picked up or shipped but pending local connection.
3061 
 
3062 
    Parameters:
3063 
     - providerId
3064 
    """
3065 
    self.send_getOrdersNotLocalConnected(providerId)
3066 
    return self.recv_getOrdersNotLocalConnected()
3067 
 
3068 
  def send_getOrdersNotLocalConnected(self, providerId):
3069 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3070 
    args = getOrdersNotLocalConnected_args()
3071 
    args.providerId = providerId
3072 
    args.write(self._oprot)
3073 
    self._oprot.writeMessageEnd()
3074 
    self._oprot.trans.flush()
3075 
 
3076 
  def recv_getOrdersNotLocalConnected(self, ):
3077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3078 
    if mtype == TMessageType.EXCEPTION:
3079 
      x = TApplicationException()
3080 
      x.read(self._iprot)
3081 
      self._iprot.readMessageEnd()
3082 
      raise x
3083 
    result = getOrdersNotLocalConnected_result()
3084 
    result.read(self._iprot)
3085 
    self._iprot.readMessageEnd()
3086 
    if result.success is not None:
3087 
      return result.success
3088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3089 
 
3090 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3091 
    """
3092 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3093 
 
3094 
    Parameters:
3095 
     - providerId
3096 
     - destination_city_reached_orders
3097 
    """
3098 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3099 
    self.recv_markOrdersAsDestinationCityReached()
3100 
 
3101 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3102 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3103 
    args = markOrdersAsDestinationCityReached_args()
3104 
    args.providerId = providerId
3105 
    args.destination_city_reached_orders = destination_city_reached_orders
3106 
    args.write(self._oprot)
3107 
    self._oprot.writeMessageEnd()
3108 
    self._oprot.trans.flush()
3109 
 
3110 
  def recv_markOrdersAsDestinationCityReached(self, ):
3111 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3112 
    if mtype == TMessageType.EXCEPTION:
3113 
      x = TApplicationException()
3114 
      x.read(self._iprot)
3115 
      self._iprot.readMessageEnd()
3116 
      raise x
3117 
    result = markOrdersAsDestinationCityReached_result()
3118 
    result.read(self._iprot)
3119 
    self._iprot.readMessageEnd()
3120 
    if result.ex is not None:
3121 
      raise result.ex
3122 
    return
3123 
 
3124 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3125 
    """
3126 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3127 
 
3128 
    Parameters:
3129 
     - providerId
3130 
     - first_atdl_orders
3131 
    """
3132 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3133 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3134 
 
3135 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3136 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3137 
    args = markOrdersAsFirstDeliveryAttempted_args()
3138 
    args.providerId = providerId
3139 
    args.first_atdl_orders = first_atdl_orders
3140 
    args.write(self._oprot)
3141 
    self._oprot.writeMessageEnd()
3142 
    self._oprot.trans.flush()
3143 
 
3144 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3145 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3146 
    if mtype == TMessageType.EXCEPTION:
3147 
      x = TApplicationException()
3148 
      x.read(self._iprot)
3149 
      self._iprot.readMessageEnd()
3150 
      raise x
3151 
    result = markOrdersAsFirstDeliveryAttempted_result()
3152 
    result.read(self._iprot)
3153 
    self._iprot.readMessageEnd()
3154 
    if result.ex is not None:
3155 
      raise result.ex
3156 
    return
3157 
 
3064 chandransh 3158 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3159 
    """
3064 chandransh 3160 
    Returns the list of orders whose delivery time has passed but have not been
3161 
    delivered yet for the given provider and warehouse. To get a complete list of
3162 
    undelivered orders, pass them as -1.
3163 
    Returns an empty list if no such orders exist.
3431 rajveer 3164 
 
1886 ankur.sing 3165 
    Parameters:
3064 chandransh 3166 
     - providerId
3167 
     - warehouseId
1886 ankur.sing 3168 
    """
3064 chandransh 3169 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3170 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3171 
 
3064 chandransh 3172 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3173 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3174 
    args = getUndeliveredOrders_args()
3175 
    args.providerId = providerId
3176 
    args.warehouseId = warehouseId
1886 ankur.sing 3177 
    args.write(self._oprot)
3178 
    self._oprot.writeMessageEnd()
3179 
    self._oprot.trans.flush()
3180 
 
3064 chandransh 3181 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3183 
    if mtype == TMessageType.EXCEPTION:
3184 
      x = TApplicationException()
3185 
      x.read(self._iprot)
3186 
      self._iprot.readMessageEnd()
3187 
      raise x
3064 chandransh 3188 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3189 
    result.read(self._iprot)
3190 
    self._iprot.readMessageEnd()
3431 rajveer 3191 
    if result.success is not None:
1886 ankur.sing 3192 
      return result.success
3064 chandransh 3193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3194 
 
4783 phani.kuma 3195 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3196 
    """
3197 
    Returns the list of orders whose expected delivery date has passed but have not been
3198 
    delivered yet.
3199 
    Returns an empty list if no such orders exist.
3200 
    """
3201 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3202 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3203 
 
3204 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3205 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3206 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3211 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3218 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3221 
    if result.success is not None:
3222 
      return result.success
3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3224 
 
2536 chandransh 3225 
  def toggleDOAFlag(self, orderId):
3226 
    """
3227 
    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.
3228 
    Returns the final flag status.
3229 
    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 3230 
 
2536 chandransh 3231 
    Parameters:
3232 
     - orderId
3233 
    """
3234 
    self.send_toggleDOAFlag(orderId)
3235 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3236 
 
2536 chandransh 3237 
  def send_toggleDOAFlag(self, orderId):
3238 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3239 
    args = toggleDOAFlag_args()
3240 
    args.orderId = orderId
3241 
    args.write(self._oprot)
3242 
    self._oprot.writeMessageEnd()
3243 
    self._oprot.trans.flush()
3244 
 
3245 
  def recv_toggleDOAFlag(self, ):
3246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3247 
    if mtype == TMessageType.EXCEPTION:
3248 
      x = TApplicationException()
3249 
      x.read(self._iprot)
3250 
      self._iprot.readMessageEnd()
3251 
      raise x
3252 
    result = toggleDOAFlag_result()
3253 
    result.read(self._iprot)
3254 
    self._iprot.readMessageEnd()
3431 rajveer 3255 
    if result.success is not None:
2536 chandransh 3256 
      return result.success
3431 rajveer 3257 
    if result.ex is not None:
2536 chandransh 3258 
      raise result.ex
3259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3260 
 
4712 rajveer 3261 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3262 
    """
3263 
    Parameters:
3264 
     - orderId
3265 
     - deliveryTimestamp
3266 
     - receiver
3267 
    """
3268 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3269 
    self.recv_markOrderAsDelivered()
3270 
 
3271 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3272 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3273 
    args = markOrderAsDelivered_args()
3274 
    args.orderId = orderId
3275 
    args.deliveryTimestamp = deliveryTimestamp
3276 
    args.receiver = receiver
3277 
    args.write(self._oprot)
3278 
    self._oprot.writeMessageEnd()
3279 
    self._oprot.trans.flush()
3280 
 
3281 
  def recv_markOrderAsDelivered(self, ):
3282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3283 
    if mtype == TMessageType.EXCEPTION:
3284 
      x = TApplicationException()
3285 
      x.read(self._iprot)
3286 
      self._iprot.readMessageEnd()
3287 
      raise x
3288 
    result = markOrderAsDelivered_result()
3289 
    result.read(self._iprot)
3290 
    self._iprot.readMessageEnd()
3291 
    if result.ex is not None:
3292 
      raise result.ex
3293 
    return
3294 
 
5553 rajveer 3295 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3296 
    """
3297 
    Parameters:
3298 
     - orderId
3299 
     - deliveryTimestamp
3300 
    """
3301 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3302 
    self.recv_markOrderAsReceivedAtStore()
3303 
 
3304 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3305 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3306 
    args = markOrderAsReceivedAtStore_args()
3307 
    args.orderId = orderId
3308 
    args.deliveryTimestamp = deliveryTimestamp
3309 
    args.write(self._oprot)
3310 
    self._oprot.writeMessageEnd()
3311 
    self._oprot.trans.flush()
3312 
 
3313 
  def recv_markOrderAsReceivedAtStore(self, ):
3314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3315 
    if mtype == TMessageType.EXCEPTION:
3316 
      x = TApplicationException()
3317 
      x.read(self._iprot)
3318 
      self._iprot.readMessageEnd()
3319 
      raise x
3320 
    result = markOrderAsReceivedAtStore_result()
3321 
    result.read(self._iprot)
3322 
    self._iprot.readMessageEnd()
3323 
    if result.ex is not None:
3324 
      raise result.ex
3325 
    return
3326 
 
4454 rajveer 3327 
  def markOrderDoaRequestReceived(self, orderId):
3328 
    """
3329 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3330 
 
3331 
    Parameters:
3332 
     - orderId
3333 
    """
3334 
    self.send_markOrderDoaRequestReceived(orderId)
3335 
    return self.recv_markOrderDoaRequestReceived()
3336 
 
3337 
  def send_markOrderDoaRequestReceived(self, orderId):
3338 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3339 
    args = markOrderDoaRequestReceived_args()
3340 
    args.orderId = orderId
3341 
    args.write(self._oprot)
3342 
    self._oprot.writeMessageEnd()
3343 
    self._oprot.trans.flush()
3344 
 
3345 
  def recv_markOrderDoaRequestReceived(self, ):
3346 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3347 
    if mtype == TMessageType.EXCEPTION:
3348 
      x = TApplicationException()
3349 
      x.read(self._iprot)
3350 
      self._iprot.readMessageEnd()
3351 
      raise x
3352 
    result = markOrderDoaRequestReceived_result()
3353 
    result.read(self._iprot)
3354 
    self._iprot.readMessageEnd()
3355 
    if result.success is not None:
3356 
      return result.success
3357 
    if result.ex is not None:
3358 
      raise result.ex
3359 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3360 
 
3361 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3362 
    """
3363 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3364 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3365 
 
3366 
    Parameters:
3367 
     - orderId
3368 
     - isAuthorized
3369 
    """
3370 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3371 
    return self.recv_markOrderDoaRequestAuthorized()
3372 
 
3373 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3374 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3375 
    args = markOrderDoaRequestAuthorized_args()
3376 
    args.orderId = orderId
3377 
    args.isAuthorized = isAuthorized
3378 
    args.write(self._oprot)
3379 
    self._oprot.writeMessageEnd()
3380 
    self._oprot.trans.flush()
3381 
 
3382 
  def recv_markOrderDoaRequestAuthorized(self, ):
3383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3384 
    if mtype == TMessageType.EXCEPTION:
3385 
      x = TApplicationException()
3386 
      x.read(self._iprot)
3387 
      self._iprot.readMessageEnd()
3388 
      raise x
3389 
    result = markOrderDoaRequestAuthorized_result()
3390 
    result.read(self._iprot)
3391 
    self._iprot.readMessageEnd()
3392 
    if result.success is not None:
3393 
      return result.success
3394 
    if result.ex is not None:
3395 
      raise result.ex
3396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3397 
 
4488 rajveer 3398 
  def markOrderReturnRequestReceived(self, orderId):
3399 
    """
3400 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3401 
 
3402 
    Parameters:
3403 
     - orderId
3404 
    """
3405 
    self.send_markOrderReturnRequestReceived(orderId)
3406 
    return self.recv_markOrderReturnRequestReceived()
3407 
 
3408 
  def send_markOrderReturnRequestReceived(self, orderId):
3409 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3410 
    args = markOrderReturnRequestReceived_args()
3411 
    args.orderId = orderId
3412 
    args.write(self._oprot)
3413 
    self._oprot.writeMessageEnd()
3414 
    self._oprot.trans.flush()
3415 
 
3416 
  def recv_markOrderReturnRequestReceived(self, ):
3417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3418 
    if mtype == TMessageType.EXCEPTION:
3419 
      x = TApplicationException()
3420 
      x.read(self._iprot)
3421 
      self._iprot.readMessageEnd()
3422 
      raise x
3423 
    result = markOrderReturnRequestReceived_result()
3424 
    result.read(self._iprot)
3425 
    self._iprot.readMessageEnd()
3426 
    if result.success is not None:
3427 
      return result.success
3428 
    if result.ex is not None:
3429 
      raise result.ex
3430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3431 
 
3432 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3433 
    """
3434 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3435 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3436 
 
3437 
    Parameters:
3438 
     - orderId
3439 
     - isAuthorized
3440 
    """
3441 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3442 
    return self.recv_markOrderReturnRequestAuthorized()
3443 
 
3444 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3445 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3446 
    args = markOrderReturnRequestAuthorized_args()
3447 
    args.orderId = orderId
3448 
    args.isAuthorized = isAuthorized
3449 
    args.write(self._oprot)
3450 
    self._oprot.writeMessageEnd()
3451 
    self._oprot.trans.flush()
3452 
 
3453 
  def recv_markOrderReturnRequestAuthorized(self, ):
3454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3455 
    if mtype == TMessageType.EXCEPTION:
3456 
      x = TApplicationException()
3457 
      x.read(self._iprot)
3458 
      self._iprot.readMessageEnd()
3459 
      raise x
3460 
    result = markOrderReturnRequestAuthorized_result()
3461 
    result.read(self._iprot)
3462 
    self._iprot.readMessageEnd()
3463 
    if result.success is not None:
3464 
      return result.success
3465 
    if result.ex is not None:
3466 
      raise result.ex
3467 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3468 
 
4579 rajveer 3469 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3470 
    """
3471 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3472 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3473 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3474 
    For any other status, it returns false.
3475 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3476 
 
2536 chandransh 3477 
    Parameters:
3478 
     - orderId
4579 rajveer 3479 
     - providerId
2536 chandransh 3480 
    """
4579 rajveer 3481 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3482 
    return self.recv_requestPickupNumber()
3483 
 
4579 rajveer 3484 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3485 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3486 
    args = requestPickupNumber_args()
3487 
    args.orderId = orderId
4579 rajveer 3488 
    args.providerId = providerId
2536 chandransh 3489 
    args.write(self._oprot)
3490 
    self._oprot.writeMessageEnd()
3491 
    self._oprot.trans.flush()
3492 
 
3493 
  def recv_requestPickupNumber(self, ):
3494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3495 
    if mtype == TMessageType.EXCEPTION:
3496 
      x = TApplicationException()
3497 
      x.read(self._iprot)
3498 
      self._iprot.readMessageEnd()
3499 
      raise x
3500 
    result = requestPickupNumber_result()
3501 
    result.read(self._iprot)
3502 
    self._iprot.readMessageEnd()
3431 rajveer 3503 
    if result.success is not None:
2536 chandransh 3504 
      return result.success
3431 rajveer 3505 
    if result.ex is not None:
2536 chandransh 3506 
      raise result.ex
3507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3508 
 
4602 rajveer 3509 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3510 
    """
4452 rajveer 3511 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3512 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3513 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3514 
    	3. Returns true
2591 chandransh 3515 
    If the order is in any other status, it returns false.
2536 chandransh 3516 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3517 
 
2536 chandransh 3518 
    Parameters:
3519 
     - orderId
3520 
     - pickupNumber
4602 rajveer 3521 
     - providerId
2536 chandransh 3522 
    """
4602 rajveer 3523 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3524 
    return self.recv_authorizePickup()
3525 
 
4602 rajveer 3526 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3527 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3528 
    args = authorizePickup_args()
3529 
    args.orderId = orderId
3530 
    args.pickupNumber = pickupNumber
4602 rajveer 3531 
    args.providerId = providerId
2536 chandransh 3532 
    args.write(self._oprot)
3533 
    self._oprot.writeMessageEnd()
3534 
    self._oprot.trans.flush()
3535 
 
3536 
  def recv_authorizePickup(self, ):
3537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3538 
    if mtype == TMessageType.EXCEPTION:
3539 
      x = TApplicationException()
3540 
      x.read(self._iprot)
3541 
      self._iprot.readMessageEnd()
3542 
      raise x
3543 
    result = authorizePickup_result()
3544 
    result.read(self._iprot)
3545 
    self._iprot.readMessageEnd()
3431 rajveer 3546 
    if result.success is not None:
2536 chandransh 3547 
      return result.success
3431 rajveer 3548 
    if result.ex is not None:
2536 chandransh 3549 
      raise result.ex
3550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3551 
 
2764 chandransh 3552 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3553 
    """
3554 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3555 
 
2764 chandransh 3556 
    Parameters:
3557 
     - providerId
3558 
     - pickupDetails
3559 
    """
3560 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3561 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3562 
 
3563 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3564 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3565 
    args = markDoasAsPickedUp_args()
3566 
    args.providerId = providerId
3567 
    args.pickupDetails = pickupDetails
3568 
    args.write(self._oprot)
3569 
    self._oprot.writeMessageEnd()
3570 
    self._oprot.trans.flush()
3571 
 
3572 
  def recv_markDoasAsPickedUp(self, ):
3573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3574 
    if mtype == TMessageType.EXCEPTION:
3575 
      x = TApplicationException()
3576 
      x.read(self._iprot)
3577 
      self._iprot.readMessageEnd()
3578 
      raise x
3579 
    result = markDoasAsPickedUp_result()
3580 
    result.read(self._iprot)
3581 
    self._iprot.readMessageEnd()
4910 phani.kuma 3582 
    return
3583 
 
3584 
  def getDoasNotPickedUp(self, providerId):
3585 
    """
3586 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3587 
 
3588 
    Parameters:
3589 
     - providerId
3590 
    """
3591 
    self.send_getDoasNotPickedUp(providerId)
3592 
    return self.recv_getDoasNotPickedUp()
3593 
 
3594 
  def send_getDoasNotPickedUp(self, providerId):
3595 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3596 
    args = getDoasNotPickedUp_args()
3597 
    args.providerId = providerId
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_getDoasNotPickedUp(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = getDoasNotPickedUp_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
3431 rajveer 3612 
    if result.success is not None:
2764 chandransh 3613 
      return result.success
4910 phani.kuma 3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3615 
 
4741 phani.kuma 3616 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3617 
    """
3618 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3619 
 
3620 
    Parameters:
3621 
     - providerId
3622 
     - pickupDetails
3623 
    """
3624 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3625 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3626 
 
3627 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3628 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3629 
    args = markReturnOrdersAsPickedUp_args()
3630 
    args.providerId = providerId
3631 
    args.pickupDetails = pickupDetails
3632 
    args.write(self._oprot)
3633 
    self._oprot.writeMessageEnd()
3634 
    self._oprot.trans.flush()
3635 
 
3636 
  def recv_markReturnOrdersAsPickedUp(self, ):
3637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3638 
    if mtype == TMessageType.EXCEPTION:
3639 
      x = TApplicationException()
3640 
      x.read(self._iprot)
3641 
      self._iprot.readMessageEnd()
3642 
      raise x
3643 
    result = markReturnOrdersAsPickedUp_result()
3644 
    result.read(self._iprot)
3645 
    self._iprot.readMessageEnd()
4910 phani.kuma 3646 
    return
3647 
 
3648 
  def getReturnOrdersNotPickedUp(self, providerId):
3649 
    """
3650 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3651 
 
3652 
    Parameters:
3653 
     - providerId
3654 
    """
3655 
    self.send_getReturnOrdersNotPickedUp(providerId)
3656 
    return self.recv_getReturnOrdersNotPickedUp()
3657 
 
3658 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3659 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3660 
    args = getReturnOrdersNotPickedUp_args()
3661 
    args.providerId = providerId
3662 
    args.write(self._oprot)
3663 
    self._oprot.writeMessageEnd()
3664 
    self._oprot.trans.flush()
3665 
 
3666 
  def recv_getReturnOrdersNotPickedUp(self, ):
3667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3668 
    if mtype == TMessageType.EXCEPTION:
3669 
      x = TApplicationException()
3670 
      x.read(self._iprot)
3671 
      self._iprot.readMessageEnd()
3672 
      raise x
3673 
    result = getReturnOrdersNotPickedUp_result()
3674 
    result.read(self._iprot)
3675 
    self._iprot.readMessageEnd()
4741 phani.kuma 3676 
    if result.success is not None:
3677 
      return result.success
4910 phani.kuma 3678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3679 
 
4479 rajveer 3680 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3681 
    """
4452 rajveer 3682 
    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 3683 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3684 
    If the order is in any other state, it returns false.
3685 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3686 
 
2591 chandransh 3687 
    Parameters:
3688 
     - orderId
4479 rajveer 3689 
     - receiveCondition
2591 chandransh 3690 
    """
4479 rajveer 3691 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3692 
    return self.recv_receiveReturn()
2536 chandransh 3693 
 
4479 rajveer 3694 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3695 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3696 
    args = receiveReturn_args()
2591 chandransh 3697 
    args.orderId = orderId
4479 rajveer 3698 
    args.receiveCondition = receiveCondition
2591 chandransh 3699 
    args.write(self._oprot)
3700 
    self._oprot.writeMessageEnd()
3701 
    self._oprot.trans.flush()
3702 
 
2616 chandransh 3703 
  def recv_receiveReturn(self, ):
2591 chandransh 3704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3705 
    if mtype == TMessageType.EXCEPTION:
3706 
      x = TApplicationException()
3707 
      x.read(self._iprot)
3708 
      self._iprot.readMessageEnd()
3709 
      raise x
2616 chandransh 3710 
    result = receiveReturn_result()
2591 chandransh 3711 
    result.read(self._iprot)
3712 
    self._iprot.readMessageEnd()
3431 rajveer 3713 
    if result.success is not None:
2591 chandransh 3714 
      return result.success
3431 rajveer 3715 
    if result.ex is not None:
2591 chandransh 3716 
      raise result.ex
2616 chandransh 3717 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3718 
 
3719 
  def validateDoa(self, orderId, isValid):
3720 
    """
4452 rajveer 3721 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3722 
    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 3723 
    If the order is in any other state, it returns false.
3724 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3725 
 
2591 chandransh 3726 
    Parameters:
3727 
     - orderId
3728 
     - isValid
3729 
    """
3730 
    self.send_validateDoa(orderId, isValid)
3731 
    return self.recv_validateDoa()
3732 
 
3733 
  def send_validateDoa(self, orderId, isValid):
3734 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3735 
    args = validateDoa_args()
3736 
    args.orderId = orderId
3737 
    args.isValid = isValid
3738 
    args.write(self._oprot)
3739 
    self._oprot.writeMessageEnd()
3740 
    self._oprot.trans.flush()
3741 
 
3742 
  def recv_validateDoa(self, ):
3743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3744 
    if mtype == TMessageType.EXCEPTION:
3745 
      x = TApplicationException()
3746 
      x.read(self._iprot)
3747 
      self._iprot.readMessageEnd()
3748 
      raise x
3749 
    result = validateDoa_result()
3750 
    result.read(self._iprot)
3751 
    self._iprot.readMessageEnd()
3431 rajveer 3752 
    if result.success is not None:
2591 chandransh 3753 
      return result.success
3431 rajveer 3754 
    if result.ex is not None:
2591 chandransh 3755 
      raise result.ex
3756 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3757 
 
4495 rajveer 3758 
  def validateReturnProduct(self, orderId, isUsable):
3759 
    """
3760 
    Parameters:
3761 
     - orderId
3762 
     - isUsable
3763 
    """
3764 
    self.send_validateReturnProduct(orderId, isUsable)
3765 
    return self.recv_validateReturnProduct()
3766 
 
3767 
  def send_validateReturnProduct(self, orderId, isUsable):
3768 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3769 
    args = validateReturnProduct_args()
3770 
    args.orderId = orderId
3771 
    args.isUsable = isUsable
3772 
    args.write(self._oprot)
3773 
    self._oprot.writeMessageEnd()
3774 
    self._oprot.trans.flush()
3775 
 
3776 
  def recv_validateReturnProduct(self, ):
3777 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3778 
    if mtype == TMessageType.EXCEPTION:
3779 
      x = TApplicationException()
3780 
      x.read(self._iprot)
3781 
      self._iprot.readMessageEnd()
3782 
      raise x
3783 
    result = validateReturnProduct_result()
3784 
    result.read(self._iprot)
3785 
    self._iprot.readMessageEnd()
3786 
    if result.success is not None:
3787 
      return result.success
3788 
    if result.ex is not None:
3789 
      raise result.ex
3790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3791 
 
2616 chandransh 3792 
  def reshipOrder(self, orderId):
3793 
    """
4484 rajveer 3794 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3795 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3796 
    	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 3797 
 
3798 
    If the order is in DOA_CERT_VALID state, it does the following:
3799 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3800 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3801 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3802 
 
2616 chandransh 3803 
    Returns the id of the newly created order.
3431 rajveer 3804 
 
2616 chandransh 3805 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3806 
 
2616 chandransh 3807 
    Parameters:
3808 
     - orderId
3809 
    """
3810 
    self.send_reshipOrder(orderId)
3811 
    return self.recv_reshipOrder()
2591 chandransh 3812 
 
2616 chandransh 3813 
  def send_reshipOrder(self, orderId):
3814 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3815 
    args = reshipOrder_args()
3816 
    args.orderId = orderId
3817 
    args.write(self._oprot)
3818 
    self._oprot.writeMessageEnd()
3819 
    self._oprot.trans.flush()
3820 
 
3821 
  def recv_reshipOrder(self, ):
3822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3823 
    if mtype == TMessageType.EXCEPTION:
3824 
      x = TApplicationException()
3825 
      x.read(self._iprot)
3826 
      self._iprot.readMessageEnd()
3827 
      raise x
3828 
    result = reshipOrder_result()
3829 
    result.read(self._iprot)
3830 
    self._iprot.readMessageEnd()
3431 rajveer 3831 
    if result.success is not None:
2616 chandransh 3832 
      return result.success
3431 rajveer 3833 
    if result.ex is not None:
2616 chandransh 3834 
      raise result.ex
3835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3836 
 
3226 chandransh 3837 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3838 
    """
4484 rajveer 3839 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3840 
    	1. Creates a refund request for batch processing.
3841 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3842 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3843 
 
2616 chandransh 3844 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3845 
    	1. Creates a refund request for batch processing.
3226 chandransh 3846 
    	2. Cancels the reservation of the item in the warehouse.
3847 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3848 
 
3226 chandransh 3849 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3850 
    	1. Cancels the reservation of the item in the warehouse.
3851 
    	2. Marks the current order as CANCELED.
3852 
 
3853 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3854 
 
2616 chandransh 3855 
    Returns True if it is successful, False otherwise.
3431 rajveer 3856 
 
2616 chandransh 3857 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3858 
 
2616 chandransh 3859 
    Parameters:
3860 
     - orderId
3226 chandransh 3861 
     - refundedBy
3862 
     - reason
2616 chandransh 3863 
    """
3226 chandransh 3864 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3865 
    return self.recv_refundOrder()
3866 
 
3226 chandransh 3867 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3868 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3869 
    args = refundOrder_args()
3870 
    args.orderId = orderId
3226 chandransh 3871 
    args.refundedBy = refundedBy
3872 
    args.reason = reason
2616 chandransh 3873 
    args.write(self._oprot)
3874 
    self._oprot.writeMessageEnd()
3875 
    self._oprot.trans.flush()
3876 
 
3877 
  def recv_refundOrder(self, ):
3878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3879 
    if mtype == TMessageType.EXCEPTION:
3880 
      x = TApplicationException()
3881 
      x.read(self._iprot)
3882 
      self._iprot.readMessageEnd()
3883 
      raise x
3884 
    result = refundOrder_result()
3885 
    result.read(self._iprot)
3886 
    self._iprot.readMessageEnd()
3431 rajveer 3887 
    if result.success is not None:
2616 chandransh 3888 
      return result.success
3431 rajveer 3889 
    if result.ex is not None:
2616 chandransh 3890 
      raise result.ex
3891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3892 
 
2690 chandransh 3893 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3894 
    """
3895 
    Get all return orders created between the from and to dates for the given warehouse.
3896 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3897 
 
2690 chandransh 3898 
    Parameters:
3899 
     - warehouseId
3900 
     - fromDate
3901 
     - toDate
3902 
    """
3903 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3904 
    return self.recv_getReturnOrders()
2616 chandransh 3905 
 
2690 chandransh 3906 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3907 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3908 
    args = getReturnOrders_args()
3909 
    args.warehouseId = warehouseId
3910 
    args.fromDate = fromDate
3911 
    args.toDate = toDate
3912 
    args.write(self._oprot)
3913 
    self._oprot.writeMessageEnd()
3914 
    self._oprot.trans.flush()
3915 
 
3916 
  def recv_getReturnOrders(self, ):
3917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3918 
    if mtype == TMessageType.EXCEPTION:
3919 
      x = TApplicationException()
3920 
      x.read(self._iprot)
3921 
      self._iprot.readMessageEnd()
3922 
      raise x
3923 
    result = getReturnOrders_result()
3924 
    result.read(self._iprot)
3925 
    self._iprot.readMessageEnd()
3431 rajveer 3926 
    if result.success is not None:
2690 chandransh 3927 
      return result.success
3928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3929 
 
5481 phani.kuma 3930 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3931 
    """
3932 
    Get all return orders created between the from and to dates.
3933 
 
3934 
    Parameters:
3935 
     - onlyNotProcessed
3936 
     - fromDate
3937 
     - toDate
3938 
    """
3939 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3940 
    return self.recv_getAllReturnOrders()
3941 
 
3942 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3943 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3944 
    args = getAllReturnOrders_args()
3945 
    args.onlyNotProcessed = onlyNotProcessed
3946 
    args.fromDate = fromDate
3947 
    args.toDate = toDate
3948 
    args.write(self._oprot)
3949 
    self._oprot.writeMessageEnd()
3950 
    self._oprot.trans.flush()
3951 
 
3952 
  def recv_getAllReturnOrders(self, ):
3953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3954 
    if mtype == TMessageType.EXCEPTION:
3955 
      x = TApplicationException()
3956 
      x.read(self._iprot)
3957 
      self._iprot.readMessageEnd()
3958 
      raise x
3959 
    result = getAllReturnOrders_result()
3960 
    result.read(self._iprot)
3961 
    self._iprot.readMessageEnd()
3962 
    if result.success is not None:
3963 
      return result.success
3964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3965 
 
2700 chandransh 3966 
  def getReturnOrder(self, id):
3967 
    """
3968 
    Returns the ReturnOrder corresponding to the given id.
3969 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3970 
 
2700 chandransh 3971 
    Parameters:
3972 
     - id
3973 
    """
3974 
    self.send_getReturnOrder(id)
3975 
    return self.recv_getReturnOrder()
3976 
 
3977 
  def send_getReturnOrder(self, id):
3978 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3979 
    args = getReturnOrder_args()
3980 
    args.id = id
3981 
    args.write(self._oprot)
3982 
    self._oprot.writeMessageEnd()
3983 
    self._oprot.trans.flush()
3984 
 
3985 
  def recv_getReturnOrder(self, ):
3986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3987 
    if mtype == TMessageType.EXCEPTION:
3988 
      x = TApplicationException()
3989 
      x.read(self._iprot)
3990 
      self._iprot.readMessageEnd()
3991 
      raise x
3992 
    result = getReturnOrder_result()
3993 
    result.read(self._iprot)
3994 
    self._iprot.readMessageEnd()
3431 rajveer 3995 
    if result.success is not None:
2700 chandransh 3996 
      return result.success
3431 rajveer 3997 
    if result.ex is not None:
2700 chandransh 3998 
      raise result.ex
3999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4000 
 
2690 chandransh 4001 
  def processReturn(self, returnOrderId):
4002 
    """
4003 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4004 
 
2690 chandransh 4005 
    Parameters:
4006 
     - returnOrderId
4007 
    """
4008 
    self.send_processReturn(returnOrderId)
4009 
    self.recv_processReturn()
4010 
 
4011 
  def send_processReturn(self, returnOrderId):
4012 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4013 
    args = processReturn_args()
4014 
    args.returnOrderId = returnOrderId
4015 
    args.write(self._oprot)
4016 
    self._oprot.writeMessageEnd()
4017 
    self._oprot.trans.flush()
4018 
 
4019 
  def recv_processReturn(self, ):
4020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4021 
    if mtype == TMessageType.EXCEPTION:
4022 
      x = TApplicationException()
4023 
      x.read(self._iprot)
4024 
      self._iprot.readMessageEnd()
4025 
      raise x
4026 
    result = processReturn_result()
4027 
    result.read(self._iprot)
4028 
    self._iprot.readMessageEnd()
3431 rajveer 4029 
    if result.ex is not None:
2690 chandransh 4030 
      raise result.ex
4031 
    return
4032 
 
3451 chandransh 4033 
  def updateWeight(self, orderId, weight):
4034 
    """
4035 
    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 4036 
 
3451 chandransh 4037 
    Parameters:
4038 
     - orderId
4039 
     - weight
4040 
    """
4041 
    self.send_updateWeight(orderId, weight)
4042 
    return self.recv_updateWeight()
4043 
 
4044 
  def send_updateWeight(self, orderId, weight):
4045 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4046 
    args = updateWeight_args()
4047 
    args.orderId = orderId
4048 
    args.weight = weight
4049 
    args.write(self._oprot)
4050 
    self._oprot.writeMessageEnd()
4051 
    self._oprot.trans.flush()
4052 
 
4053 
  def recv_updateWeight(self, ):
4054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4055 
    if mtype == TMessageType.EXCEPTION:
4056 
      x = TApplicationException()
4057 
      x.read(self._iprot)
4058 
      self._iprot.readMessageEnd()
4059 
      raise x
4060 
    result = updateWeight_result()
4061 
    result.read(self._iprot)
4062 
    self._iprot.readMessageEnd()
4063 
    if result.success is not None:
4064 
      return result.success
4065 
    if result.ex is not None:
4066 
      raise result.ex
4067 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4068 
 
3469 chandransh 4069 
  def changeItem(self, orderId, itemId):
4070 
    """
4071 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4072 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4073 
 
3469 chandransh 4074 
    Parameters:
4075 
     - orderId
4076 
     - itemId
4077 
    """
4078 
    self.send_changeItem(orderId, itemId)
4079 
    return self.recv_changeItem()
4080 
 
4081 
  def send_changeItem(self, orderId, itemId):
4082 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4083 
    args = changeItem_args()
4084 
    args.orderId = orderId
4085 
    args.itemId = itemId
4086 
    args.write(self._oprot)
4087 
    self._oprot.writeMessageEnd()
4088 
    self._oprot.trans.flush()
4089 
 
4090 
  def recv_changeItem(self, ):
4091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4092 
    if mtype == TMessageType.EXCEPTION:
4093 
      x = TApplicationException()
4094 
      x.read(self._iprot)
4095 
      self._iprot.readMessageEnd()
4096 
      raise x
4097 
    result = changeItem_result()
4098 
    result.read(self._iprot)
4099 
    self._iprot.readMessageEnd()
4100 
    if result.success is not None:
4101 
      return result.success
4102 
    if result.ex is not None:
4103 
      raise result.ex
4104 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4105 
 
4106 
  def shiftToWarehouse(self, orderId, warehouseId):
4107 
    """
4108 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4109 
 
4110 
    Parameters:
4111 
     - orderId
4112 
     - warehouseId
4113 
    """
4114 
    self.send_shiftToWarehouse(orderId, warehouseId)
4115 
    return self.recv_shiftToWarehouse()
4116 
 
4117 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4118 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4119 
    args = shiftToWarehouse_args()
4120 
    args.orderId = orderId
4121 
    args.warehouseId = warehouseId
4122 
    args.write(self._oprot)
4123 
    self._oprot.writeMessageEnd()
4124 
    self._oprot.trans.flush()
4125 
 
4126 
  def recv_shiftToWarehouse(self, ):
4127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4128 
    if mtype == TMessageType.EXCEPTION:
4129 
      x = TApplicationException()
4130 
      x.read(self._iprot)
4131 
      self._iprot.readMessageEnd()
4132 
      raise x
4133 
    result = shiftToWarehouse_result()
4134 
    result.read(self._iprot)
4135 
    self._iprot.readMessageEnd()
4136 
    if result.success is not None:
4137 
      return result.success
4138 
    if result.ex is not None:
4139 
      raise result.ex
4140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4141 
 
4647 rajveer 4142 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4143 
    """
4144 
    Adds the given delay reason to the given order.
3986 chandransh 4145 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4146 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4147 
 
3553 chandransh 4148 
    Parameters:
4149 
     - orderId
4150 
     - delayReason
3986 chandransh 4151 
     - furtherDelay
4647 rajveer 4152 
     - delayReasonText
3553 chandransh 4153 
    """
4647 rajveer 4154 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4155 
    return self.recv_addDelayReason()
4156 
 
4647 rajveer 4157 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4158 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4159 
    args = addDelayReason_args()
4160 
    args.orderId = orderId
4161 
    args.delayReason = delayReason
3986 chandransh 4162 
    args.furtherDelay = furtherDelay
4647 rajveer 4163 
    args.delayReasonText = delayReasonText
3553 chandransh 4164 
    args.write(self._oprot)
4165 
    self._oprot.writeMessageEnd()
4166 
    self._oprot.trans.flush()
4167 
 
4168 
  def recv_addDelayReason(self, ):
4169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4170 
    if mtype == TMessageType.EXCEPTION:
4171 
      x = TApplicationException()
4172 
      x.read(self._iprot)
4173 
      self._iprot.readMessageEnd()
4174 
      raise x
4175 
    result = addDelayReason_result()
4176 
    result.read(self._iprot)
4177 
    self._iprot.readMessageEnd()
4178 
    if result.success is not None:
4179 
      return result.success
4180 
    if result.ex is not None:
4181 
      raise result.ex
4182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4183 
 
3956 chandransh 4184 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4185 
    """
4186 
    Marks the COD orders with given AWB nos. as having been processed.
4187 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4188 
 
3956 chandransh 4189 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4190 
    1. There is no order corresponding to an AWB number.
4191 
    2. The captured amount for a payment exceeds the total payment.
4192 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4193 
 
4194 
    Parameters:
4195 
     - collectedAmountMap
4196 
     - xferBy
4197 
     - xferTxnId
4198 
     - xferDate
4199 
    """
4200 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4201 
    return self.recv_reconcileCodCollection()
4202 
 
4203 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4204 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4205 
    args = reconcileCodCollection_args()
4206 
    args.collectedAmountMap = collectedAmountMap
4207 
    args.xferBy = xferBy
4208 
    args.xferTxnId = xferTxnId
4209 
    args.xferDate = xferDate
4210 
    args.write(self._oprot)
4211 
    self._oprot.writeMessageEnd()
4212 
    self._oprot.trans.flush()
4213 
 
4214 
  def recv_reconcileCodCollection(self, ):
4215 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4216 
    if mtype == TMessageType.EXCEPTION:
4217 
      x = TApplicationException()
4218 
      x.read(self._iprot)
4219 
      self._iprot.readMessageEnd()
4220 
      raise x
4221 
    result = reconcileCodCollection_result()
4222 
    result.read(self._iprot)
4223 
    self._iprot.readMessageEnd()
4224 
    if result.success is not None:
4225 
      return result.success
4226 
    if result.ex is not None:
4227 
      raise result.ex
4228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4229 
 
4008 mandeep.dh 4230 
  def getTransactionsRequiringExtraProcessing(self, category):
4231 
    """
4065 mandeep.dh 4232 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4233 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4234 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4235 
 
4008 mandeep.dh 4236 
    Parameters:
4237 
     - category
4238 
    """
4239 
    self.send_getTransactionsRequiringExtraProcessing(category)
4240 
    return self.recv_getTransactionsRequiringExtraProcessing()
4241 
 
4242 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4243 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4244 
    args = getTransactionsRequiringExtraProcessing_args()
4245 
    args.category = category
4246 
    args.write(self._oprot)
4247 
    self._oprot.writeMessageEnd()
4248 
    self._oprot.trans.flush()
4249 
 
4250 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4252 
    if mtype == TMessageType.EXCEPTION:
4253 
      x = TApplicationException()
4254 
      x.read(self._iprot)
4255 
      self._iprot.readMessageEnd()
4256 
      raise x
4257 
    result = getTransactionsRequiringExtraProcessing_result()
4258 
    result.read(self._iprot)
4259 
    self._iprot.readMessageEnd()
4260 
    if result.success is not None:
4261 
      return result.success
4262 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4263 
 
4264 
  def markTransactionAsProcessed(self, transactionId, category):
4265 
    """
4266 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4267 
    It essentially deletes the transaction id record for a particular
4268 
    processing type category (if present) from DB.
4269 
    This is currently used by CRM application.
4008 mandeep.dh 4270 
 
4271 
    Parameters:
4272 
     - transactionId
4273 
     - category
4274 
    """
4275 
    self.send_markTransactionAsProcessed(transactionId, category)
4276 
    self.recv_markTransactionAsProcessed()
4277 
 
4278 
  def send_markTransactionAsProcessed(self, transactionId, category):
4279 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4280 
    args = markTransactionAsProcessed_args()
4281 
    args.transactionId = transactionId
4282 
    args.category = category
4283 
    args.write(self._oprot)
4284 
    self._oprot.writeMessageEnd()
4285 
    self._oprot.trans.flush()
4286 
 
4287 
  def recv_markTransactionAsProcessed(self, ):
4288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4289 
    if mtype == TMessageType.EXCEPTION:
4290 
      x = TApplicationException()
4291 
      x.read(self._iprot)
4292 
      self._iprot.readMessageEnd()
4293 
      raise x
4294 
    result = markTransactionAsProcessed_result()
4295 
    result.read(self._iprot)
4296 
    self._iprot.readMessageEnd()
4297 
    return
4298 
 
4018 chandransh 4299 
  def getItemWiseRiskyOrdersCount(self, ):
4300 
    """
4301 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4302 
    is defined as one whose shipping date is about to expire.
4303 
    """
4304 
    self.send_getItemWiseRiskyOrdersCount()
4305 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4306 
 
4018 chandransh 4307 
  def send_getItemWiseRiskyOrdersCount(self, ):
4308 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4309 
    args = getItemWiseRiskyOrdersCount_args()
4310 
    args.write(self._oprot)
4311 
    self._oprot.writeMessageEnd()
4312 
    self._oprot.trans.flush()
4313 
 
4314 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4315 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4316 
    if mtype == TMessageType.EXCEPTION:
4317 
      x = TApplicationException()
4318 
      x.read(self._iprot)
4319 
      self._iprot.readMessageEnd()
4320 
      raise x
4321 
    result = getItemWiseRiskyOrdersCount_result()
4322 
    result.read(self._iprot)
4323 
    self._iprot.readMessageEnd()
4324 
    if result.success is not None:
4325 
      return result.success
4326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4327 
 
4295 varun.gupt 4328 
  def getOrdersForItemIds(self, itemIds):
4329 
    """
4330 
    Returns a list of all orders which have items with given id
4331 
 
4332 
    Parameters:
4333 
     - itemIds
4334 
    """
4335 
    self.send_getOrdersForItemIds(itemIds)
4336 
    return self.recv_getOrdersForItemIds()
4337 
 
4338 
  def send_getOrdersForItemIds(self, itemIds):
4339 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4340 
    args = getOrdersForItemIds_args()
4341 
    args.itemIds = itemIds
4342 
    args.write(self._oprot)
4343 
    self._oprot.writeMessageEnd()
4344 
    self._oprot.trans.flush()
4345 
 
4346 
  def recv_getOrdersForItemIds(self, ):
4347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4348 
    if mtype == TMessageType.EXCEPTION:
4349 
      x = TApplicationException()
4350 
      x.read(self._iprot)
4351 
      self._iprot.readMessageEnd()
4352 
      raise x
4353 
    result = getOrdersForItemIds_result()
4354 
    result.read(self._iprot)
4355 
    self._iprot.readMessageEnd()
4356 
    if result.success is not None:
4357 
      return result.success
4358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4359 
 
4247 rajveer 4360 
  def markOrderCancellationRequestReceived(self, orderId):
4361 
    """
4362 
    Mark order as cancellation request received. If customer sends request of cancellation of
4363 
    a particular order, this method will be called. It will just change status of the order
4364 
    depending on its current status. It also records the previous status, so that we can move
4365 
    back to that status if cancellation request is denied.
4018 chandransh 4366 
 
4247 rajveer 4367 
    Parameters:
4368 
     - orderId
4369 
    """
4370 
    self.send_markOrderCancellationRequestReceived(orderId)
4371 
    self.recv_markOrderCancellationRequestReceived()
4372 
 
4373 
  def send_markOrderCancellationRequestReceived(self, orderId):
4374 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4375 
    args = markOrderCancellationRequestReceived_args()
4376 
    args.orderId = orderId
4377 
    args.write(self._oprot)
4378 
    self._oprot.writeMessageEnd()
4379 
    self._oprot.trans.flush()
4380 
 
4381 
  def recv_markOrderCancellationRequestReceived(self, ):
4382 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4383 
    if mtype == TMessageType.EXCEPTION:
4384 
      x = TApplicationException()
4385 
      x.read(self._iprot)
4386 
      self._iprot.readMessageEnd()
4387 
      raise x
4388 
    result = markOrderCancellationRequestReceived_result()
4389 
    result.read(self._iprot)
4390 
    self._iprot.readMessageEnd()
4391 
    if result.ex is not None:
4392 
      raise result.ex
4393 
    return
4394 
 
4395 
  def markOrderCancellationRequestConfirmed(self, orderId):
4396 
    """
4397 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4398 
    cancellation request confirmed. After this OM will be able to cancel the order.
4399 
 
4400 
    Parameters:
4401 
     - orderId
4402 
    """
4403 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4404 
    self.recv_markOrderCancellationRequestConfirmed()
4405 
 
4406 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4407 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4408 
    args = markOrderCancellationRequestConfirmed_args()
4409 
    args.orderId = orderId
4410 
    args.write(self._oprot)
4411 
    self._oprot.writeMessageEnd()
4412 
    self._oprot.trans.flush()
4413 
 
4414 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4416 
    if mtype == TMessageType.EXCEPTION:
4417 
      x = TApplicationException()
4418 
      x.read(self._iprot)
4419 
      self._iprot.readMessageEnd()
4420 
      raise x
4421 
    result = markOrderCancellationRequestConfirmed_result()
4422 
    result.read(self._iprot)
4423 
    self._iprot.readMessageEnd()
4424 
    if result.ex is not None:
4425 
      raise result.ex
4426 
    return
4427 
 
4428 
  def markOrderCancellationRequestDenied(self, orderId):
4429 
    """
4430 
    If we decide to not to cancel order, we will move the order ro previous status.
4431 
 
4432 
    Parameters:
4433 
     - orderId
4434 
    """
4435 
    self.send_markOrderCancellationRequestDenied(orderId)
4436 
    self.recv_markOrderCancellationRequestDenied()
4437 
 
4438 
  def send_markOrderCancellationRequestDenied(self, orderId):
4439 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4440 
    args = markOrderCancellationRequestDenied_args()
4441 
    args.orderId = orderId
4442 
    args.write(self._oprot)
4443 
    self._oprot.writeMessageEnd()
4444 
    self._oprot.trans.flush()
4445 
 
4446 
  def recv_markOrderCancellationRequestDenied(self, ):
4447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4448 
    if mtype == TMessageType.EXCEPTION:
4449 
      x = TApplicationException()
4450 
      x.read(self._iprot)
4451 
      self._iprot.readMessageEnd()
4452 
      raise x
4453 
    result = markOrderCancellationRequestDenied_result()
4454 
    result.read(self._iprot)
4455 
    self._iprot.readMessageEnd()
4456 
    if result.ex is not None:
4457 
      raise result.ex
4458 
    return
4459 
 
4258 rajveer 4460 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4461 
    """
4258 rajveer 4462 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4463 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4464 
 
4465 
    Parameters:
4258 rajveer 4466 
     - transactionId
4247 rajveer 4467 
    """
4258 rajveer 4468 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4469 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4470 
 
4258 rajveer 4471 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4472 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4473 
    args = markTransactionAsPaymentFlagRemoved_args()
4474 
    args.transactionId = transactionId
4247 rajveer 4475 
    args.write(self._oprot)
4476 
    self._oprot.writeMessageEnd()
4477 
    self._oprot.trans.flush()
4478 
 
4258 rajveer 4479 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4481 
    if mtype == TMessageType.EXCEPTION:
4482 
      x = TApplicationException()
4483 
      x.read(self._iprot)
4484 
      self._iprot.readMessageEnd()
4485 
      raise x
4258 rajveer 4486 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4487 
    result.read(self._iprot)
4488 
    self._iprot.readMessageEnd()
4489 
    if result.ex is not None:
4490 
      raise result.ex
4491 
    return
4492 
 
4259 anupam.sin 4493 
  def refundTransaction(self, transactionId, refundedBy, reason):
4494 
    """
4495 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4496 
    need to be cancelled
4247 rajveer 4497 
 
4259 anupam.sin 4498 
    Parameters:
4499 
     - transactionId
4500 
     - refundedBy
4501 
     - reason
4502 
    """
4503 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4504 
    self.recv_refundTransaction()
4505 
 
4506 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4507 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4508 
    args = refundTransaction_args()
4509 
    args.transactionId = transactionId
4510 
    args.refundedBy = refundedBy
4511 
    args.reason = reason
4512 
    args.write(self._oprot)
4513 
    self._oprot.writeMessageEnd()
4514 
    self._oprot.trans.flush()
4515 
 
4516 
  def recv_refundTransaction(self, ):
4517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4518 
    if mtype == TMessageType.EXCEPTION:
4519 
      x = TApplicationException()
4520 
      x.read(self._iprot)
4521 
      self._iprot.readMessageEnd()
4522 
      raise x
4523 
    result = refundTransaction_result()
4524 
    result.read(self._iprot)
4525 
    self._iprot.readMessageEnd()
4526 
    if result.ex is not None:
4527 
      raise result.ex
4528 
    return
4529 
 
4324 mandeep.dh 4530 
  def updateShipmentAddress(self, orderId, addressId):
4531 
    """
4532 
    Updates shipment address of an order. Delivery and shipping date estimates
4533 
    etc. are also updated here.
4534 
 
4535 
    Throws TransactionServiceException in case address change is not
4536 
    possible due to certain reasons such as new pincode in address is
4537 
    not serviceable etc.
4538 
 
4539 
    Parameters:
4540 
     - orderId
4541 
     - addressId
4542 
    """
4543 
    self.send_updateShipmentAddress(orderId, addressId)
4544 
    self.recv_updateShipmentAddress()
4545 
 
4546 
  def send_updateShipmentAddress(self, orderId, addressId):
4547 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4548 
    args = updateShipmentAddress_args()
4549 
    args.orderId = orderId
4550 
    args.addressId = addressId
4551 
    args.write(self._oprot)
4552 
    self._oprot.writeMessageEnd()
4553 
    self._oprot.trans.flush()
4554 
 
4555 
  def recv_updateShipmentAddress(self, ):
4556 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4557 
    if mtype == TMessageType.EXCEPTION:
4558 
      x = TApplicationException()
4559 
      x.read(self._iprot)
4560 
      self._iprot.readMessageEnd()
4561 
      raise x
4562 
    result = updateShipmentAddress_result()
4563 
    result.read(self._iprot)
4564 
    self._iprot.readMessageEnd()
4565 
    if result.ex is not None:
4566 
      raise result.ex
4567 
    return
4568 
 
4285 rajveer 4569 
  def acceptOrdersForItemId(self, itemId, inventory):
4570 
    """
4571 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4572 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4573 
 
4285 rajveer 4574 
    Parameters:
4575 
     - itemId
4576 
     - inventory
4577 
    """
4578 
    self.send_acceptOrdersForItemId(itemId, inventory)
4579 
    return self.recv_acceptOrdersForItemId()
4580 
 
4581 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4582 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4583 
    args = acceptOrdersForItemId_args()
4584 
    args.itemId = itemId
4585 
    args.inventory = inventory
4586 
    args.write(self._oprot)
4587 
    self._oprot.writeMessageEnd()
4588 
    self._oprot.trans.flush()
4589 
 
4590 
  def recv_acceptOrdersForItemId(self, ):
4591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4592 
    if mtype == TMessageType.EXCEPTION:
4593 
      x = TApplicationException()
4594 
      x.read(self._iprot)
4595 
      self._iprot.readMessageEnd()
4596 
      raise x
4597 
    result = acceptOrdersForItemId_result()
4598 
    result.read(self._iprot)
4599 
    self._iprot.readMessageEnd()
4600 
    if result.success is not None:
4601 
      return result.success
4602 
    if result.ex is not None:
4603 
      raise result.ex
4604 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4605 
 
4369 rajveer 4606 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4607 
    """
4608 
    Parameters:
4609 
     - vendorId
4610 
     - itemId
4611 
     - quantity
4612 
     - estimate
4369 rajveer 4613 
     - isReminder
4303 rajveer 4614 
    """
4369 rajveer 4615 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4616 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4617 
 
4369 rajveer 4618 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4619 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4620 
    args = markOrdersAsPORaised_args()
4621 
    args.vendorId = vendorId
4622 
    args.itemId = itemId
4623 
    args.quantity = quantity
4624 
    args.estimate = estimate
4369 rajveer 4625 
    args.isReminder = isReminder
4303 rajveer 4626 
    args.write(self._oprot)
4627 
    self._oprot.writeMessageEnd()
4628 
    self._oprot.trans.flush()
4629 
 
4630 
  def recv_markOrdersAsPORaised(self, ):
4631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4632 
    if mtype == TMessageType.EXCEPTION:
4633 
      x = TApplicationException()
4634 
      x.read(self._iprot)
4635 
      self._iprot.readMessageEnd()
4636 
      raise x
4637 
    result = markOrdersAsPORaised_result()
4638 
    result.read(self._iprot)
4639 
    self._iprot.readMessageEnd()
4640 
    if result.ex is not None:
4641 
      raise result.ex
4642 
    return
4643 
 
4369 rajveer 4644 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4645 
    """
4646 
    Parameters:
4647 
     - vendorId
4648 
     - itemId
4649 
     - quantity
4650 
     - estimate
4369 rajveer 4651 
     - isReminder
4303 rajveer 4652 
    """
4369 rajveer 4653 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4654 
    self.recv_markOrdersAsReversalInitiated()
4655 
 
4369 rajveer 4656 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4657 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4658 
    args = markOrdersAsReversalInitiated_args()
4659 
    args.vendorId = vendorId
4660 
    args.itemId = itemId
4661 
    args.quantity = quantity
4662 
    args.estimate = estimate
4369 rajveer 4663 
    args.isReminder = isReminder
4303 rajveer 4664 
    args.write(self._oprot)
4665 
    self._oprot.writeMessageEnd()
4666 
    self._oprot.trans.flush()
4667 
 
4668 
  def recv_markOrdersAsReversalInitiated(self, ):
4669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4670 
    if mtype == TMessageType.EXCEPTION:
4671 
      x = TApplicationException()
4672 
      x.read(self._iprot)
4673 
      self._iprot.readMessageEnd()
4674 
      raise x
4675 
    result = markOrdersAsReversalInitiated_result()
4676 
    result.read(self._iprot)
4677 
    self._iprot.readMessageEnd()
4678 
    if result.ex is not None:
4679 
      raise result.ex
4680 
    return
4681 
 
4369 rajveer 4682 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4683 
    """
4684 
    Parameters:
4685 
     - vendorId
4686 
     - itemId
4687 
     - quantity
4688 
     - estimate
4369 rajveer 4689 
     - isReminder
4303 rajveer 4690 
    """
4369 rajveer 4691 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4692 
    self.recv_markOrdersAsNotAvailabke()
4693 
 
4369 rajveer 4694 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4695 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4696 
    args = markOrdersAsNotAvailabke_args()
4697 
    args.vendorId = vendorId
4698 
    args.itemId = itemId
4699 
    args.quantity = quantity
4700 
    args.estimate = estimate
4369 rajveer 4701 
    args.isReminder = isReminder
4303 rajveer 4702 
    args.write(self._oprot)
4703 
    self._oprot.writeMessageEnd()
4704 
    self._oprot.trans.flush()
4705 
 
4706 
  def recv_markOrdersAsNotAvailabke(self, ):
4707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4708 
    if mtype == TMessageType.EXCEPTION:
4709 
      x = TApplicationException()
4710 
      x.read(self._iprot)
4711 
      self._iprot.readMessageEnd()
4712 
      raise x
4713 
    result = markOrdersAsNotAvailabke_result()
4714 
    result.read(self._iprot)
4715 
    self._iprot.readMessageEnd()
4716 
    if result.ex is not None:
4717 
      raise result.ex
4718 
    return
4719 
 
4369 rajveer 4720 
  def markOrdersAsTimeout(self, vendorId):
4721 
    """
4722 
    Parameters:
4723 
     - vendorId
4724 
    """
4725 
    self.send_markOrdersAsTimeout(vendorId)
4726 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4727 
 
4369 rajveer 4728 
  def send_markOrdersAsTimeout(self, vendorId):
4729 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4730 
    args = markOrdersAsTimeout_args()
4731 
    args.vendorId = vendorId
4732 
    args.write(self._oprot)
4733 
    self._oprot.writeMessageEnd()
4734 
    self._oprot.trans.flush()
4735 
 
4736 
  def recv_markOrdersAsTimeout(self, ):
4737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4738 
    if mtype == TMessageType.EXCEPTION:
4739 
      x = TApplicationException()
4740 
      x.read(self._iprot)
4741 
      self._iprot.readMessageEnd()
4742 
      raise x
4743 
    result = markOrdersAsTimeout_result()
4744 
    result.read(self._iprot)
4745 
    self._iprot.readMessageEnd()
4746 
    if result.success is not None:
4747 
      return result.success
4748 
    if result.ex is not None:
4749 
      raise result.ex
4750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4751 
 
4662 rajveer 4752 
  def markOrderAsLostInTransit(self, orderId):
4753 
    """
4754 
    Mark order as LOST_IN_TRANSIT
4755 
 
4756 
    Parameters:
4757 
     - orderId
4758 
    """
4759 
    self.send_markOrderAsLostInTransit(orderId)
4760 
    return self.recv_markOrderAsLostInTransit()
4761 
 
4762 
  def send_markOrderAsLostInTransit(self, orderId):
4763 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4764 
    args = markOrderAsLostInTransit_args()
4765 
    args.orderId = orderId
4766 
    args.write(self._oprot)
4767 
    self._oprot.writeMessageEnd()
4768 
    self._oprot.trans.flush()
4769 
 
4770 
  def recv_markOrderAsLostInTransit(self, ):
4771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4772 
    if mtype == TMessageType.EXCEPTION:
4773 
      x = TApplicationException()
4774 
      x.read(self._iprot)
4775 
      self._iprot.readMessageEnd()
4776 
      raise x
4777 
    result = markOrderAsLostInTransit_result()
4778 
    result.read(self._iprot)
4779 
    self._iprot.readMessageEnd()
4780 
    if result.success is not None:
4781 
      return result.success
4782 
    if result.ex is not None:
4783 
      raise result.ex
4784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4785 
 
4386 anupam.sin 4786 
  def getOrderForAwb(self, awb):
4787 
    """
4788 
    Returns the order corresponding to an AWB number
4369 rajveer 4789 
 
4386 anupam.sin 4790 
    Parameters:
4791 
     - awb
4792 
    """
4793 
    self.send_getOrderForAwb(awb)
4794 
    return self.recv_getOrderForAwb()
4795 
 
4796 
  def send_getOrderForAwb(self, awb):
4797 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4798 
    args = getOrderForAwb_args()
4799 
    args.awb = awb
4800 
    args.write(self._oprot)
4801 
    self._oprot.writeMessageEnd()
4802 
    self._oprot.trans.flush()
4803 
 
4804 
  def recv_getOrderForAwb(self, ):
4805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4806 
    if mtype == TMessageType.EXCEPTION:
4807 
      x = TApplicationException()
4808 
      x.read(self._iprot)
4809 
      self._iprot.readMessageEnd()
4810 
      raise x
4811 
    result = getOrderForAwb_result()
4812 
    result.read(self._iprot)
4813 
    self._iprot.readMessageEnd()
4814 
    if result.success is not None:
4815 
      return result.success
4816 
    if result.ex is not None:
4817 
      raise result.ex
4818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4819 
 
4910 phani.kuma 4820 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4821 
    """
4910 phani.kuma 4822 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4823 
 
4506 phani.kuma 4824 
    Parameters:
4825 
     - logistics_provider_id
4910 phani.kuma 4826 
     - order_status_list
4506 phani.kuma 4827 
    """
4910 phani.kuma 4828 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4829 
    return self.recv_getOrdersForProviderForStatus()
4830 
 
4910 phani.kuma 4831 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4832 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4833 
    args = getOrdersForProviderForStatus_args()
4834 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4835 
    args.order_status_list = order_status_list
4506 phani.kuma 4836 
    args.write(self._oprot)
4837 
    self._oprot.writeMessageEnd()
4838 
    self._oprot.trans.flush()
4839 
 
4840 
  def recv_getOrdersForProviderForStatus(self, ):
4841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4842 
    if mtype == TMessageType.EXCEPTION:
4843 
      x = TApplicationException()
4844 
      x.read(self._iprot)
4845 
      self._iprot.readMessageEnd()
4846 
      raise x
4847 
    result = getOrdersForProviderForStatus_result()
4848 
    result.read(self._iprot)
4849 
    self._iprot.readMessageEnd()
4850 
    if result.success is not None:
4851 
      return result.success
4852 
    if result.ex is not None:
4853 
      raise result.ex
4854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4855 
 
4600 varun.gupt 4856 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4857 
    """
4858 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4859 
 
4600 varun.gupt 4860 
    Parameters:
4861 
     - vendorId
4862 
     - billingDateFrom
4863 
     - billingDateTo
4864 
    """
4865 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4866 
    return self.recv_getBilledOrdersForVendor()
4867 
 
4868 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4869 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4870 
    args = getBilledOrdersForVendor_args()
4871 
    args.vendorId = vendorId
4872 
    args.billingDateFrom = billingDateFrom
4873 
    args.billingDateTo = billingDateTo
4874 
    args.write(self._oprot)
4875 
    self._oprot.writeMessageEnd()
4876 
    self._oprot.trans.flush()
4877 
 
4878 
  def recv_getBilledOrdersForVendor(self, ):
4879 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4880 
    if mtype == TMessageType.EXCEPTION:
4881 
      x = TApplicationException()
4882 
      x.read(self._iprot)
4883 
      self._iprot.readMessageEnd()
4884 
      raise x
4885 
    result = getBilledOrdersForVendor_result()
4886 
    result.read(self._iprot)
4887 
    self._iprot.readMessageEnd()
4888 
    if result.success is not None:
4889 
      return result.success
4890 
    if result.ex is not None:
4891 
      raise result.ex
4892 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4893 
 
4607 rajveer 4894 
  def getSlippedSippingDateOrders(self, ):
4895 
    self.send_getSlippedSippingDateOrders()
4896 
    return self.recv_getSlippedSippingDateOrders()
4897 
 
4898 
  def send_getSlippedSippingDateOrders(self, ):
4899 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4900 
    args = getSlippedSippingDateOrders_args()
4901 
    args.write(self._oprot)
4902 
    self._oprot.writeMessageEnd()
4903 
    self._oprot.trans.flush()
4904 
 
4905 
  def recv_getSlippedSippingDateOrders(self, ):
4906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4907 
    if mtype == TMessageType.EXCEPTION:
4908 
      x = TApplicationException()
4909 
      x.read(self._iprot)
4910 
      self._iprot.readMessageEnd()
4911 
      raise x
4912 
    result = getSlippedSippingDateOrders_result()
4913 
    result.read(self._iprot)
4914 
    self._iprot.readMessageEnd()
4915 
    if result.success is not None:
4916 
      return result.success
4917 
    if result.ex is not None:
4918 
      raise result.ex
4919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4920 
 
4709 rajveer 4921 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4922 
    """
4923 
    Parameters:
4924 
     - cancelDateFrom
4925 
     - cancelDateTo
4926 
    """
4927 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4928 
    return self.recv_getCancelledOrders()
4929 
 
4930 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4931 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4932 
    args = getCancelledOrders_args()
4933 
    args.cancelDateFrom = cancelDateFrom
4934 
    args.cancelDateTo = cancelDateTo
4935 
    args.write(self._oprot)
4936 
    self._oprot.writeMessageEnd()
4937 
    self._oprot.trans.flush()
4938 
 
4939 
  def recv_getCancelledOrders(self, ):
4940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4941 
    if mtype == TMessageType.EXCEPTION:
4942 
      x = TApplicationException()
4943 
      x.read(self._iprot)
4944 
      self._iprot.readMessageEnd()
4945 
      raise x
4946 
    result = getCancelledOrders_result()
4947 
    result.read(self._iprot)
4948 
    self._iprot.readMessageEnd()
4949 
    if result.success is not None:
4950 
      return result.success
4951 
    if result.ex is not None:
4952 
      raise result.ex
4953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4954 
 
4600 varun.gupt 4955 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4956 
    """
4957 
    Parameters:
4958 
     - mapAWBAndAmount
4959 
    """
4960 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4961 
    self.recv_saveBluedartSettlements()
4962 
 
4963 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4964 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4965 
    args = saveBluedartSettlements_args()
4966 
    args.mapAWBAndAmount = mapAWBAndAmount
4967 
    args.write(self._oprot)
4968 
    self._oprot.writeMessageEnd()
4969 
    self._oprot.trans.flush()
4970 
 
4971 
  def recv_saveBluedartSettlements(self, ):
4972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4973 
    if mtype == TMessageType.EXCEPTION:
4974 
      x = TApplicationException()
4975 
      x.read(self._iprot)
4976 
      self._iprot.readMessageEnd()
4977 
      raise x
4978 
    result = saveBluedartSettlements_result()
4979 
    result.read(self._iprot)
4980 
    self._iprot.readMessageEnd()
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    return
4984 
 
4905 varun.gupt 4985 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4986 
    """
4987 
    Parameters:
4988 
     - settlementDate
4989 
     - paymentGatewayId
4905 varun.gupt 4990 
     - referenceId
4600 varun.gupt 4991 
     - serviceTax
4992 
     - otherCharges
4993 
     - netCollection
4994 
    """
4905 varun.gupt 4995 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4996 
    self.recv_savePaymentSettlements()
4997 
 
4905 varun.gupt 4998 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4999 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5000 
    args = savePaymentSettlements_args()
5001 
    args.settlementDate = settlementDate
5002 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5003 
    args.referenceId = referenceId
4600 varun.gupt 5004 
    args.serviceTax = serviceTax
5005 
    args.otherCharges = otherCharges
5006 
    args.netCollection = netCollection
5007 
    args.write(self._oprot)
5008 
    self._oprot.writeMessageEnd()
5009 
    self._oprot.trans.flush()
5010 
 
5011 
  def recv_savePaymentSettlements(self, ):
5012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5013 
    if mtype == TMessageType.EXCEPTION:
5014 
      x = TApplicationException()
5015 
      x.read(self._iprot)
5016 
      self._iprot.readMessageEnd()
5017 
      raise x
5018 
    result = savePaymentSettlements_result()
5019 
    result.read(self._iprot)
5020 
    self._iprot.readMessageEnd()
5021 
    if result.ex is not None:
5022 
      raise result.ex
5023 
    return
5024 
 
5025 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5026 
    """
5027 
    Parameters:
5028 
     - settlementId
5029 
     - settlementDate
5030 
     - transactionDateFrom
5031 
     - transactionDateTo
5032 
     - amount
5033 
    """
5034 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5035 
    self.recv_saveEBSSettlementSummary()
5036 
 
5037 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5038 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5039 
    args = saveEBSSettlementSummary_args()
5040 
    args.settlementId = settlementId
5041 
    args.settlementDate = settlementDate
5042 
    args.transactionDateFrom = transactionDateFrom
5043 
    args.transactionDateTo = transactionDateTo
5044 
    args.amount = amount
5045 
    args.write(self._oprot)
5046 
    self._oprot.writeMessageEnd()
5047 
    self._oprot.trans.flush()
5048 
 
5049 
  def recv_saveEBSSettlementSummary(self, ):
5050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5051 
    if mtype == TMessageType.EXCEPTION:
5052 
      x = TApplicationException()
5053 
      x.read(self._iprot)
5054 
      self._iprot.readMessageEnd()
5055 
      raise x
5056 
    result = saveEBSSettlementSummary_result()
5057 
    result.read(self._iprot)
5058 
    self._iprot.readMessageEnd()
5059 
    if result.ex is not None:
5060 
      raise result.ex
5061 
    return
5062 
 
5386 phani.kuma 5063 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5064 
    """
5065 
    Parameters:
5189 varun.gupt 5066 
     - referenceId
5067 
     - isRefund
4600 varun.gupt 5068 
    """
5386 phani.kuma 5069 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5070 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5071 
 
5386 phani.kuma 5072 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5073 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5074 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5075 
    args.referenceId = referenceId
5076 
    args.isRefund = isRefund
4600 varun.gupt 5077 
    args.write(self._oprot)
5078 
    self._oprot.writeMessageEnd()
5079 
    self._oprot.trans.flush()
5080 
 
5386 phani.kuma 5081 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5082 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5083 
    if mtype == TMessageType.EXCEPTION:
5084 
      x = TApplicationException()
5085 
      x.read(self._iprot)
5086 
      self._iprot.readMessageEnd()
5087 
      raise x
5386 phani.kuma 5088 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5089 
    result.read(self._iprot)
5090 
    self._iprot.readMessageEnd()
5091 
    if result.success is not None:
5092 
      return result.success
5093 
    if result.ex is not None:
5094 
      raise result.ex
5386 phani.kuma 5095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5096 
 
5386 phani.kuma 5097 
  def getSettlementForCod(self, orderId, isRefund):
5098 
    """
5099 
    Parameters:
5100 
     - orderId
5101 
     - isRefund
5102 
    """
5103 
    self.send_getSettlementForCod(orderId, isRefund)
5104 
    return self.recv_getSettlementForCod()
5105 
 
5106 
  def send_getSettlementForCod(self, orderId, isRefund):
5107 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5108 
    args = getSettlementForCod_args()
5109 
    args.orderId = orderId
5110 
    args.isRefund = isRefund
5111 
    args.write(self._oprot)
5112 
    self._oprot.writeMessageEnd()
5113 
    self._oprot.trans.flush()
5114 
 
5115 
  def recv_getSettlementForCod(self, ):
5116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5117 
    if mtype == TMessageType.EXCEPTION:
5118 
      x = TApplicationException()
5119 
      x.read(self._iprot)
5120 
      self._iprot.readMessageEnd()
5121 
      raise x
5122 
    result = getSettlementForCod_result()
5123 
    result.read(self._iprot)
5124 
    self._iprot.readMessageEnd()
5125 
    if result.success is not None:
5126 
      return result.success
5127 
    if result.ex is not None:
5128 
      raise result.ex
5129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5130 
 
4600 varun.gupt 5131 
  def getEBSSettlementSummaries(self, ):
5132 
    self.send_getEBSSettlementSummaries()
5133 
    return self.recv_getEBSSettlementSummaries()
5134 
 
5135 
  def send_getEBSSettlementSummaries(self, ):
5136 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5137 
    args = getEBSSettlementSummaries_args()
5138 
    args.write(self._oprot)
5139 
    self._oprot.writeMessageEnd()
5140 
    self._oprot.trans.flush()
5141 
 
5142 
  def recv_getEBSSettlementSummaries(self, ):
5143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5144 
    if mtype == TMessageType.EXCEPTION:
5145 
      x = TApplicationException()
5146 
      x.read(self._iprot)
5147 
      self._iprot.readMessageEnd()
5148 
      raise x
5149 
    result = getEBSSettlementSummaries_result()
5150 
    result.read(self._iprot)
5151 
    self._iprot.readMessageEnd()
5152 
    if result.success is not None:
5153 
      return result.success
5154 
    if result.ex is not None:
5155 
      raise result.ex
5156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5157 
 
5158 
  def markEBSSettlementUploaded(self, settlementId):
5159 
    """
5160 
    Parameters:
5161 
     - settlementId
5162 
    """
5163 
    self.send_markEBSSettlementUploaded(settlementId)
5164 
    self.recv_markEBSSettlementUploaded()
5165 
 
5166 
  def send_markEBSSettlementUploaded(self, settlementId):
5167 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5168 
    args = markEBSSettlementUploaded_args()
5169 
    args.settlementId = settlementId
5170 
    args.write(self._oprot)
5171 
    self._oprot.writeMessageEnd()
5172 
    self._oprot.trans.flush()
5173 
 
5174 
  def recv_markEBSSettlementUploaded(self, ):
5175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5176 
    if mtype == TMessageType.EXCEPTION:
5177 
      x = TApplicationException()
5178 
      x.read(self._iprot)
5179 
      self._iprot.readMessageEnd()
5180 
      raise x
5181 
    result = markEBSSettlementUploaded_result()
5182 
    result.read(self._iprot)
5183 
    self._iprot.readMessageEnd()
5184 
    if result.ex is not None:
5185 
      raise result.ex
5186 
    return
5187 
 
5188 
  def getEBSSettlementDate(self, settlementId):
5189 
    """
5190 
    Parameters:
5191 
     - settlementId
5192 
    """
5193 
    self.send_getEBSSettlementDate(settlementId)
5194 
    return self.recv_getEBSSettlementDate()
5195 
 
5196 
  def send_getEBSSettlementDate(self, settlementId):
5197 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5198 
    args = getEBSSettlementDate_args()
5199 
    args.settlementId = settlementId
5200 
    args.write(self._oprot)
5201 
    self._oprot.writeMessageEnd()
5202 
    self._oprot.trans.flush()
5203 
 
5204 
  def recv_getEBSSettlementDate(self, ):
5205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5206 
    if mtype == TMessageType.EXCEPTION:
5207 
      x = TApplicationException()
5208 
      x.read(self._iprot)
5209 
      self._iprot.readMessageEnd()
5210 
      raise x
5211 
    result = getEBSSettlementDate_result()
5212 
    result.read(self._iprot)
5213 
    self._iprot.readMessageEnd()
5214 
    if result.success is not None:
5215 
      return result.success
5216 
    if result.ex is not None:
5217 
      raise result.ex
5218 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5219 
 
4715 varun.gupt 5220 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5221 
    """
5222 
    Parameters:
5223 
     - settlementDateFrom
5224 
     - settlementDateTo
5225 
     - isRefund
5226 
    """
5227 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5228 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5229 
 
4715 varun.gupt 5230 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5231 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5232 
    args = getSettlementsByDate_args()
5233 
    args.settlementDateFrom = settlementDateFrom
5234 
    args.settlementDateTo = settlementDateTo
5235 
    args.isRefund = isRefund
5236 
    args.write(self._oprot)
5237 
    self._oprot.writeMessageEnd()
5238 
    self._oprot.trans.flush()
5239 
 
5240 
  def recv_getSettlementsByDate(self, ):
5241 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5242 
    if mtype == TMessageType.EXCEPTION:
5243 
      x = TApplicationException()
5244 
      x.read(self._iprot)
5245 
      self._iprot.readMessageEnd()
5246 
      raise x
5247 
    result = getSettlementsByDate_result()
5248 
    result.read(self._iprot)
5249 
    self._iprot.readMessageEnd()
5250 
    if result.success is not None:
5251 
      return result.success
5252 
    if result.ex is not None:
5253 
      raise result.ex
5254 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5255 
 
5256 
  def getReshippedOrderIds(self, orderIds):
5257 
    """
5258 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5259 
 
5260 
    Parameters:
5261 
     - orderIds
5262 
    """
5263 
    self.send_getReshippedOrderIds(orderIds)
5264 
    return self.recv_getReshippedOrderIds()
5265 
 
5266 
  def send_getReshippedOrderIds(self, orderIds):
5267 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5268 
    args = getReshippedOrderIds_args()
5269 
    args.orderIds = orderIds
5270 
    args.write(self._oprot)
5271 
    self._oprot.writeMessageEnd()
5272 
    self._oprot.trans.flush()
5273 
 
5274 
  def recv_getReshippedOrderIds(self, ):
5275 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5276 
    if mtype == TMessageType.EXCEPTION:
5277 
      x = TApplicationException()
5278 
      x.read(self._iprot)
5279 
      self._iprot.readMessageEnd()
5280 
      raise x
5281 
    result = getReshippedOrderIds_result()
5282 
    result.read(self._iprot)
5283 
    self._iprot.readMessageEnd()
5284 
    if result.success is not None:
5285 
      return result.success
5286 
    if result.ex is not None:
5287 
      raise result.ex
5288 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5289 
 
5481 phani.kuma 5290 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5291 
    """
5292 
    Parameters:
5293 
     - vendorId
5481 phani.kuma 5294 
     - onlyVendorNotPaid
5295 
     - billingDateFrom
5296 
     - billingDateTo
4875 varun.gupt 5297 
    """
5481 phani.kuma 5298 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5299 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5300 
 
5481 phani.kuma 5301 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5302 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5303 
    args = getBilledOrders_args()
4875 varun.gupt 5304 
    args.vendorId = vendorId
5481 phani.kuma 5305 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5306 
    args.billingDateFrom = billingDateFrom
5307 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5308 
    args.write(self._oprot)
5309 
    self._oprot.writeMessageEnd()
5310 
    self._oprot.trans.flush()
5311 
 
5481 phani.kuma 5312 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5314 
    if mtype == TMessageType.EXCEPTION:
5315 
      x = TApplicationException()
5316 
      x.read(self._iprot)
5317 
      self._iprot.readMessageEnd()
5318 
      raise x
5481 phani.kuma 5319 
    result = getBilledOrders_result()
4875 varun.gupt 5320 
    result.read(self._iprot)
5321 
    self._iprot.readMessageEnd()
5322 
    if result.success is not None:
5323 
      return result.success
5324 
    if result.ex is not None:
5325 
      raise result.ex
5481 phani.kuma 5326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5327 
 
5031 varun.gupt 5328 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5329 
    """
5330 
    Parameters:
5331 
     - startDate
5332 
     - endDate
5333 
    """
5334 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5335 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5336 
 
5031 varun.gupt 5337 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5338 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5339 
    args = getStatusDistributionOfOrders_args()
5340 
    args.startDate = startDate
5341 
    args.endDate = endDate
5342 
    args.write(self._oprot)
5343 
    self._oprot.writeMessageEnd()
5344 
    self._oprot.trans.flush()
5345 
 
5346 
  def recv_getStatusDistributionOfOrders(self, ):
5347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5348 
    if mtype == TMessageType.EXCEPTION:
5349 
      x = TApplicationException()
5350 
      x.read(self._iprot)
5351 
      self._iprot.readMessageEnd()
5352 
      raise x
5353 
    result = getStatusDistributionOfOrders_result()
5354 
    result.read(self._iprot)
5355 
    self._iprot.readMessageEnd()
5356 
    if result.success is not None:
5357 
      return result.success
5358 
    if result.ex is not None:
5359 
      raise result.ex
5360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5361 
 
5067 varun.gupt 5362 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5363 
    """
5364 
    Parameters:
5365 
     - status
5366 
     - startDatetime
5367 
     - endDatetime
5368 
    """
5369 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5370 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5371 
 
5067 varun.gupt 5372 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5373 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5374 
    args = getOrderIdsForStatus_args()
5375 
    args.status = status
5376 
    args.startDatetime = startDatetime
5377 
    args.endDatetime = endDatetime
5378 
    args.write(self._oprot)
5379 
    self._oprot.writeMessageEnd()
5380 
    self._oprot.trans.flush()
5381 
 
5382 
  def recv_getOrderIdsForStatus(self, ):
5383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5384 
    if mtype == TMessageType.EXCEPTION:
5385 
      x = TApplicationException()
5386 
      x.read(self._iprot)
5387 
      self._iprot.readMessageEnd()
5388 
      raise x
5389 
    result = getOrderIdsForStatus_result()
5390 
    result.read(self._iprot)
5391 
    self._iprot.readMessageEnd()
5392 
    if result.success is not None:
5393 
      return result.success
5394 
    if result.ex is not None:
5395 
      raise result.ex
5396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5397 
 
5348 anupam.sin 5398 
  def updateCODAgent(self, agent, orderId):
5399 
    """
5400 
    Updates the agent who handled the COD verification call
5401 
 
5402 
    Parameters:
5403 
     - agent
5404 
     - orderId
5405 
    """
5406 
    self.send_updateCODAgent(agent, orderId)
5407 
    self.recv_updateCODAgent()
5408 
 
5409 
  def send_updateCODAgent(self, agent, orderId):
5410 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5411 
    args = updateCODAgent_args()
5412 
    args.agent = agent
5413 
    args.orderId = orderId
5414 
    args.write(self._oprot)
5415 
    self._oprot.writeMessageEnd()
5416 
    self._oprot.trans.flush()
5417 
 
5418 
  def recv_updateCODAgent(self, ):
5419 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5420 
    if mtype == TMessageType.EXCEPTION:
5421 
      x = TApplicationException()
5422 
      x.read(self._iprot)
5423 
      self._iprot.readMessageEnd()
5424 
      raise x
5425 
    result = updateCODAgent_result()
5426 
    result.read(self._iprot)
5427 
    self._iprot.readMessageEnd()
5428 
    if result.ex is not None:
5429 
      raise result.ex
5430 
    return
5431 
 
5099 varun.gupt 5432 
  def updateOrderAsPaidToVendor(self, orderId):
5433 
    """
5434 
    Parameters:
5435 
     - orderId
5436 
    """
5437 
    self.send_updateOrderAsPaidToVendor(orderId)
5438 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5439 
 
5099 varun.gupt 5440 
  def send_updateOrderAsPaidToVendor(self, orderId):
5441 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5442 
    args = updateOrderAsPaidToVendor_args()
5443 
    args.orderId = orderId
5444 
    args.write(self._oprot)
5445 
    self._oprot.writeMessageEnd()
5446 
    self._oprot.trans.flush()
5447 
 
5448 
  def recv_updateOrderAsPaidToVendor(self, ):
5449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5450 
    if mtype == TMessageType.EXCEPTION:
5451 
      x = TApplicationException()
5452 
      x.read(self._iprot)
5453 
      self._iprot.readMessageEnd()
5454 
      raise x
5455 
    result = updateOrderAsPaidToVendor_result()
5456 
    result.read(self._iprot)
5457 
    self._iprot.readMessageEnd()
5458 
    if result.ex is not None:
5459 
      raise result.ex
5460 
    return
5461 
 
5386 phani.kuma 5462 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5463 
    """
5464 
    Parameters:
5465 
     - orderId
5466 
    """
5467 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5468 
    self.recv_updateOrderOnlyAsPaidToVendor()
5469 
 
5470 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5471 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5472 
    args = updateOrderOnlyAsPaidToVendor_args()
5473 
    args.orderId = orderId
5474 
    args.write(self._oprot)
5475 
    self._oprot.writeMessageEnd()
5476 
    self._oprot.trans.flush()
5477 
 
5478 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5480 
    if mtype == TMessageType.EXCEPTION:
5481 
      x = TApplicationException()
5482 
      x.read(self._iprot)
5483 
      self._iprot.readMessageEnd()
5484 
      raise x
5485 
    result = updateOrderOnlyAsPaidToVendor_result()
5486 
    result.read(self._iprot)
5487 
    self._iprot.readMessageEnd()
5488 
    if result.ex is not None:
5489 
      raise result.ex
5490 
    return
5491 
 
5208 varun.gupt 5492 
  def getRefundedOrdersMarkedPaid(self, ):
5493 
    self.send_getRefundedOrdersMarkedPaid()
5494 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5495 
 
5208 varun.gupt 5496 
  def send_getRefundedOrdersMarkedPaid(self, ):
5497 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5498 
    args = getRefundedOrdersMarkedPaid_args()
5499 
    args.write(self._oprot)
5500 
    self._oprot.writeMessageEnd()
5501 
    self._oprot.trans.flush()
5502 
 
5503 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5505 
    if mtype == TMessageType.EXCEPTION:
5506 
      x = TApplicationException()
5507 
      x.read(self._iprot)
5508 
      self._iprot.readMessageEnd()
5509 
      raise x
5510 
    result = getRefundedOrdersMarkedPaid_result()
5511 
    result.read(self._iprot)
5512 
    self._iprot.readMessageEnd()
5513 
    if result.success is not None:
5514 
      return result.success
5515 
    if result.ex is not None:
5516 
      raise result.ex
5517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5518 
 
5447 anupam.sin 5519 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5520 
    """
5521 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5522 
 
5447 anupam.sin 5523 
 
5524 
    Parameters:
5525 
     - minOrderId
5526 
     - maxOrderId
5527 
    """
5528 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5529 
    return self.recv_getAllVerificationAgents()
5530 
 
5531 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5532 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5533 
    args = getAllVerificationAgents_args()
5534 
    args.minOrderId = minOrderId
5535 
    args.maxOrderId = maxOrderId
5536 
    args.write(self._oprot)
5537 
    self._oprot.writeMessageEnd()
5538 
    self._oprot.trans.flush()
5539 
 
5540 
  def recv_getAllVerificationAgents(self, ):
5541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5542 
    if mtype == TMessageType.EXCEPTION:
5543 
      x = TApplicationException()
5544 
      x.read(self._iprot)
5545 
      self._iprot.readMessageEnd()
5546 
      raise x
5547 
    result = getAllVerificationAgents_result()
5548 
    result.read(self._iprot)
5549 
    self._iprot.readMessageEnd()
5550 
    if result.success is not None:
5551 
      return result.success
5552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5553 
 
5527 anupam.sin 5554 
  def getAllAttributesForOrderId(self, orderId):
5555 
    """
5556 
    gets all attributes for a given orderId
5447 anupam.sin 5557 
 
5527 anupam.sin 5558 
    Parameters:
5559 
     - orderId
5560 
    """
5561 
    self.send_getAllAttributesForOrderId(orderId)
5562 
    return self.recv_getAllAttributesForOrderId()
5563 
 
5564 
  def send_getAllAttributesForOrderId(self, orderId):
5565 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5566 
    args = getAllAttributesForOrderId_args()
5567 
    args.orderId = orderId
5568 
    args.write(self._oprot)
5569 
    self._oprot.writeMessageEnd()
5570 
    self._oprot.trans.flush()
5571 
 
5572 
  def recv_getAllAttributesForOrderId(self, ):
5573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5574 
    if mtype == TMessageType.EXCEPTION:
5575 
      x = TApplicationException()
5576 
      x.read(self._iprot)
5577 
      self._iprot.readMessageEnd()
5578 
      raise x
5579 
    result = getAllAttributesForOrderId_result()
5580 
    result.read(self._iprot)
5581 
    self._iprot.readMessageEnd()
5582 
    if result.success is not None:
5583 
      return result.success
5584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5585 
 
5676 rajveer 5586 
  def setOrderAttributes(self, orderId, attributes):
5587 
    """
5588 
    sets attributes for an order
5589 
 
5590 
    Parameters:
5591 
     - orderId
5592 
     - attributes
5593 
    """
5594 
    self.send_setOrderAttributes(orderId, attributes)
5595 
    self.recv_setOrderAttributes()
5596 
 
5597 
  def send_setOrderAttributes(self, orderId, attributes):
5598 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5599 
    args = setOrderAttributes_args()
5600 
    args.orderId = orderId
5601 
    args.attributes = attributes
5602 
    args.write(self._oprot)
5603 
    self._oprot.writeMessageEnd()
5604 
    self._oprot.trans.flush()
5605 
 
5606 
  def recv_setOrderAttributes(self, ):
5607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5608 
    if mtype == TMessageType.EXCEPTION:
5609 
      x = TApplicationException()
5610 
      x.read(self._iprot)
5611 
      self._iprot.readMessageEnd()
5612 
      raise x
5613 
    result = setOrderAttributes_result()
5614 
    result.read(self._iprot)
5615 
    self._iprot.readMessageEnd()
5616 
    return
5617 
 
5527 anupam.sin 5618 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5619 
    """
5620 
    sets attributes for all orders in a transaction
5621 
 
5622 
    Parameters:
5623 
     - transactionId
5624 
     - attribute
5625 
    """
5626 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5627 
    self.recv_setOrderAttributeForTransaction()
5628 
 
5629 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5630 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5631 
    args = setOrderAttributeForTransaction_args()
5632 
    args.transactionId = transactionId
5633 
    args.attribute = attribute
5634 
    args.write(self._oprot)
5635 
    self._oprot.writeMessageEnd()
5636 
    self._oprot.trans.flush()
5637 
 
5638 
  def recv_setOrderAttributeForTransaction(self, ):
5639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5640 
    if mtype == TMessageType.EXCEPTION:
5641 
      x = TApplicationException()
5642 
      x.read(self._iprot)
5643 
      self._iprot.readMessageEnd()
5644 
      raise x
5645 
    result = setOrderAttributeForTransaction_result()
5646 
    result.read(self._iprot)
5647 
    self._iprot.readMessageEnd()
5648 
    return
5649 
 
5553 rajveer 5650 
  def getReceivePendingOrders(self, storeId):
5651 
    """
5652 
    Parameters:
5653 
     - storeId
5654 
    """
5655 
    self.send_getReceivePendingOrders(storeId)
5656 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5657 
 
5553 rajveer 5658 
  def send_getReceivePendingOrders(self, storeId):
5659 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5660 
    args = getReceivePendingOrders_args()
5661 
    args.storeId = storeId
5662 
    args.write(self._oprot)
5663 
    self._oprot.writeMessageEnd()
5664 
    self._oprot.trans.flush()
5665 
 
5666 
  def recv_getReceivePendingOrders(self, ):
5667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5668 
    if mtype == TMessageType.EXCEPTION:
5669 
      x = TApplicationException()
5670 
      x.read(self._iprot)
5671 
      self._iprot.readMessageEnd()
5672 
      raise x
5673 
    result = getReceivePendingOrders_result()
5674 
    result.read(self._iprot)
5675 
    self._iprot.readMessageEnd()
5676 
    if result.success is not None:
5677 
      return result.success
5678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5679 
 
5680 
  def getReceivedAtStoreOrders(self, storeId):
5681 
    """
5682 
    Parameters:
5683 
     - storeId
5684 
    """
5685 
    self.send_getReceivedAtStoreOrders(storeId)
5686 
    return self.recv_getReceivedAtStoreOrders()
5687 
 
5688 
  def send_getReceivedAtStoreOrders(self, storeId):
5689 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5690 
    args = getReceivedAtStoreOrders_args()
5691 
    args.storeId = storeId
5692 
    args.write(self._oprot)
5693 
    self._oprot.writeMessageEnd()
5694 
    self._oprot.trans.flush()
5695 
 
5696 
  def recv_getReceivedAtStoreOrders(self, ):
5697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5698 
    if mtype == TMessageType.EXCEPTION:
5699 
      x = TApplicationException()
5700 
      x.read(self._iprot)
5701 
      self._iprot.readMessageEnd()
5702 
      raise x
5703 
    result = getReceivedAtStoreOrders_result()
5704 
    result.read(self._iprot)
5705 
    self._iprot.readMessageEnd()
5706 
    if result.success is not None:
5707 
      return result.success
5708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5709 
 
5713 rajveer 5710 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5711 
    """
5712 
    Parameters:
5713 
     - storeId
5714 
     - fromDate
5715 
     - toDate
5716 
     - onlyCod
5717 
    """
5718 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5719 
    return self.recv_getOrdersCollectionAtStore()
5720 
 
5721 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5722 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5723 
    args = getOrdersCollectionAtStore_args()
5724 
    args.storeId = storeId
5725 
    args.fromDate = fromDate
5726 
    args.toDate = toDate
5727 
    args.onlyCod = onlyCod
5728 
    args.write(self._oprot)
5729 
    self._oprot.writeMessageEnd()
5730 
    self._oprot.trans.flush()
5731 
 
5732 
  def recv_getOrdersCollectionAtStore(self, ):
5733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5734 
    if mtype == TMessageType.EXCEPTION:
5735 
      x = TApplicationException()
5736 
      x.read(self._iprot)
5737 
      self._iprot.readMessageEnd()
5738 
      raise x
5739 
    result = getOrdersCollectionAtStore_result()
5740 
    result.read(self._iprot)
5741 
    self._iprot.readMessageEnd()
5742 
    if result.success is not None:
5743 
      return result.success
5744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5745 
 
5833 rajveer 5746 
  def getOrderAttributeValue(self, orderId, attributeName):
5747 
    """
5748 
    Parameters:
5749 
     - orderId
5750 
     - attributeName
5751 
    """
5752 
    self.send_getOrderAttributeValue(orderId, attributeName)
5753 
    return self.recv_getOrderAttributeValue()
5754 
 
5755 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5756 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5757 
    args = getOrderAttributeValue_args()
5758 
    args.orderId = orderId
5759 
    args.attributeName = attributeName
5760 
    args.write(self._oprot)
5761 
    self._oprot.writeMessageEnd()
5762 
    self._oprot.trans.flush()
5763 
 
5764 
  def recv_getOrderAttributeValue(self, ):
5765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5766 
    if mtype == TMessageType.EXCEPTION:
5767 
      x = TApplicationException()
5768 
      x.read(self._iprot)
5769 
      self._iprot.readMessageEnd()
5770 
      raise x
5771 
    result = getOrderAttributeValue_result()
5772 
    result.read(self._iprot)
5773 
    self._iprot.readMessageEnd()
5774 
    if result.success is not None:
5775 
      return result.success
5776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5777 
 
6019 rajveer 5778 
  def changeJacketNumber(self, orderId, jacketNumber):
5779 
    """
5780 
    Parameters:
5781 
     - orderId
5782 
     - jacketNumber
5783 
    """
5784 
    self.send_changeJacketNumber(orderId, jacketNumber)
5785 
    return self.recv_changeJacketNumber()
5786 
 
5787 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5788 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5789 
    args = changeJacketNumber_args()
5790 
    args.orderId = orderId
5791 
    args.jacketNumber = jacketNumber
5792 
    args.write(self._oprot)
5793 
    self._oprot.writeMessageEnd()
5794 
    self._oprot.trans.flush()
5795 
 
5796 
  def recv_changeJacketNumber(self, ):
5797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5798 
    if mtype == TMessageType.EXCEPTION:
5799 
      x = TApplicationException()
5800 
      x.read(self._iprot)
5801 
      self._iprot.readMessageEnd()
5802 
      raise x
5803 
    result = changeJacketNumber_result()
5804 
    result.read(self._iprot)
5805 
    self._iprot.readMessageEnd()
5806 
    if result.success is not None:
5807 
      return result.success
5808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5809 
 
5810 
  def markOrderAsRtoInTransit(self, orderId):
5811 
    """
5812 
    Parameters:
5813 
     - orderId
5814 
    """
5815 
    self.send_markOrderAsRtoInTransit(orderId)
5816 
    return self.recv_markOrderAsRtoInTransit()
5817 
 
5818 
  def send_markOrderAsRtoInTransit(self, orderId):
5819 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5820 
    args = markOrderAsRtoInTransit_args()
5821 
    args.orderId = orderId
5822 
    args.write(self._oprot)
5823 
    self._oprot.writeMessageEnd()
5824 
    self._oprot.trans.flush()
5825 
 
5826 
  def recv_markOrderAsRtoInTransit(self, ):
5827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5828 
    if mtype == TMessageType.EXCEPTION:
5829 
      x = TApplicationException()
5830 
      x.read(self._iprot)
5831 
      self._iprot.readMessageEnd()
5832 
      raise x
5833 
    result = markOrderAsRtoInTransit_result()
5834 
    result.read(self._iprot)
5835 
    self._iprot.readMessageEnd()
5836 
    if result.success is not None:
5837 
      return result.success
5838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5839 
 
5593 mandeep.dh 5840 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5841 
    """
5842 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5843 
    invoked while scanning IN of items.
5553 rajveer 5844 
 
5593 mandeep.dh 5845 
    Parameters:
5846 
     - itemId
5847 
     - quantity
5848 
     - fulfilmentWarehouseId
5849 
     - billingWarehouseId
5850 
    """
5851 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5852 
    self.recv_acceptOrderForItem()
5853 
 
5854 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5855 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5856 
    args = acceptOrderForItem_args()
5857 
    args.itemId = itemId
5858 
    args.quantity = quantity
5859 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5860 
    args.billingWarehouseId = billingWarehouseId
5861 
    args.write(self._oprot)
5862 
    self._oprot.writeMessageEnd()
5863 
    self._oprot.trans.flush()
5864 
 
5865 
  def recv_acceptOrderForItem(self, ):
5866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5867 
    if mtype == TMessageType.EXCEPTION:
5868 
      x = TApplicationException()
5869 
      x.read(self._iprot)
5870 
      self._iprot.readMessageEnd()
5871 
      raise x
5872 
    result = acceptOrderForItem_result()
5873 
    result.read(self._iprot)
5874 
    self._iprot.readMessageEnd()
5875 
    return
5876 
 
6000 mandeep.dh 5877 
  def createRechargeOrder(self, rechargeOrder):
5878 
    """
5879 
    Parameters:
5880 
     - rechargeOrder
5881 
    """
5882 
    self.send_createRechargeOrder(rechargeOrder)
5883 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5884 
 
6000 mandeep.dh 5885 
  def send_createRechargeOrder(self, rechargeOrder):
5886 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5887 
    args = createRechargeOrder_args()
5888 
    args.rechargeOrder = rechargeOrder
5889 
    args.write(self._oprot)
5890 
    self._oprot.writeMessageEnd()
5891 
    self._oprot.trans.flush()
5892 
 
5893 
  def recv_createRechargeOrder(self, ):
5894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5895 
    if mtype == TMessageType.EXCEPTION:
5896 
      x = TApplicationException()
5897 
      x.read(self._iprot)
5898 
      self._iprot.readMessageEnd()
5899 
      raise x
5900 
    result = createRechargeOrder_result()
5901 
    result.read(self._iprot)
5902 
    self._iprot.readMessageEnd()
5903 
    if result.success is not None:
5904 
      return result.success
5905 
    if result.ex is not None:
5906 
      raise result.ex
5907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5908 
 
6031 rajveer 5909 
  def getRechargeOrder(self, rechargeRrderId):
5910 
    """
5911 
    Parameters:
5912 
     - rechargeRrderId
5913 
    """
5914 
    self.send_getRechargeOrder(rechargeRrderId)
5915 
    return self.recv_getRechargeOrder()
5916 
 
5917 
  def send_getRechargeOrder(self, rechargeRrderId):
5918 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5919 
    args = getRechargeOrder_args()
5920 
    args.rechargeRrderId = rechargeRrderId
5921 
    args.write(self._oprot)
5922 
    self._oprot.writeMessageEnd()
5923 
    self._oprot.trans.flush()
5924 
 
5925 
  def recv_getRechargeOrder(self, ):
5926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5927 
    if mtype == TMessageType.EXCEPTION:
5928 
      x = TApplicationException()
5929 
      x.read(self._iprot)
5930 
      self._iprot.readMessageEnd()
5931 
      raise x
5932 
    result = getRechargeOrder_result()
5933 
    result.read(self._iprot)
5934 
    self._iprot.readMessageEnd()
5935 
    if result.success is not None:
5936 
      return result.success
5937 
    if result.ex is not None:
5938 
      raise result.ex
5939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5940 
 
5941 
  def getRechargeOrders(self, userId):
5942 
    """
5943 
    Parameters:
5944 
     - userId
5945 
    """
5946 
    self.send_getRechargeOrders(userId)
5947 
    return self.recv_getRechargeOrders()
5948 
 
5949 
  def send_getRechargeOrders(self, userId):
5950 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5951 
    args = getRechargeOrders_args()
5952 
    args.userId = userId
5953 
    args.write(self._oprot)
5954 
    self._oprot.writeMessageEnd()
5955 
    self._oprot.trans.flush()
5956 
 
5957 
  def recv_getRechargeOrders(self, ):
5958 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5959 
    if mtype == TMessageType.EXCEPTION:
5960 
      x = TApplicationException()
5961 
      x.read(self._iprot)
5962 
      self._iprot.readMessageEnd()
5963 
      raise x
5964 
    result = getRechargeOrders_result()
5965 
    result.read(self._iprot)
5966 
    self._iprot.readMessageEnd()
5967 
    if result.success is not None:
5968 
      return result.success
5969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5970 
 
6000 mandeep.dh 5971 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5972 
    """
5973 
    Parameters:
5974 
     - rechargeOrderId
5975 
     - rechargeOrderStatus
5976 
    """
5977 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5978 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5979 
 
5980 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5981 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5982 
    args = updateRechargeOrderStatus_args()
5983 
    args.rechargeOrderId = rechargeOrderId
5984 
    args.rechargeOrderStatus = rechargeOrderStatus
5985 
    args.write(self._oprot)
5986 
    self._oprot.writeMessageEnd()
5987 
    self._oprot.trans.flush()
5988 
 
5989 
  def recv_updateRechargeOrderStatus(self, ):
5990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5991 
    if mtype == TMessageType.EXCEPTION:
5992 
      x = TApplicationException()
5993 
      x.read(self._iprot)
5994 
      self._iprot.readMessageEnd()
5995 
      raise x
5996 
    result = updateRechargeOrderStatus_result()
5997 
    result.read(self._iprot)
5998 
    self._iprot.readMessageEnd()
6031 rajveer 5999 
    if result.success is not None:
6000 
      return result.success
6000 mandeep.dh 6001 
    if result.ex is not None:
6002 
      raise result.ex
6031 rajveer 6003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6004 
 
6031 rajveer 6005 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6006 
    """
6007 
    Parameters:
6031 rajveer 6008 
     - rechargeOrderId
6000 mandeep.dh 6009 
    """
6031 rajveer 6010 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6011 
    return self.recv_activateRechargeTxn()
6012 
 
6031 rajveer 6013 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6014 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6015 
    args = activateRechargeTxn_args()
6031 rajveer 6016 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6017 
    args.write(self._oprot)
6018 
    self._oprot.writeMessageEnd()
6019 
    self._oprot.trans.flush()
6020 
 
6021 
  def recv_activateRechargeTxn(self, ):
6022 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6023 
    if mtype == TMessageType.EXCEPTION:
6024 
      x = TApplicationException()
6025 
      x.read(self._iprot)
6026 
      self._iprot.readMessageEnd()
6027 
      raise x
6028 
    result = activateRechargeTxn_result()
6029 
    result.read(self._iprot)
6030 
    self._iprot.readMessageEnd()
6031 
    if result.success is not None:
6032 
      return result.success
6033 
    if result.ex is not None:
6034 
      raise result.ex
6035 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6036 
 
6031 rajveer 6037 
  def getUserWallet(self, userId):
6000 mandeep.dh 6038 
    """
6039 
    Parameters:
6031 rajveer 6040 
     - userId
6000 mandeep.dh 6041 
    """
6031 rajveer 6042 
    self.send_getUserWallet(userId)
6043 
    return self.recv_getUserWallet()
6000 mandeep.dh 6044 
 
6031 rajveer 6045 
  def send_getUserWallet(self, userId):
6046 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6047 
    args = getUserWallet_args()
6048 
    args.userId = userId
6000 mandeep.dh 6049 
    args.write(self._oprot)
6050 
    self._oprot.writeMessageEnd()
6051 
    self._oprot.trans.flush()
6052 
 
6031 rajveer 6053 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6055 
    if mtype == TMessageType.EXCEPTION:
6056 
      x = TApplicationException()
6057 
      x.read(self._iprot)
6058 
      self._iprot.readMessageEnd()
6059 
      raise x
6031 rajveer 6060 
    result = getUserWallet_result()
6000 mandeep.dh 6061 
    result.read(self._iprot)
6062 
    self._iprot.readMessageEnd()
6063 
    if result.success is not None:
6064 
      return result.success
6031 rajveer 6065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6066 
 
6031 rajveer 6067 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6068 
    """
6069 
    Parameters:
6031 rajveer 6070 
     - userId
6000 mandeep.dh 6071 
    """
6031 rajveer 6072 
    self.send_getUserWalletHistory(userId)
6073 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6074 
 
6031 rajveer 6075 
  def send_getUserWalletHistory(self, userId):
6076 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6077 
    args = getUserWalletHistory_args()
6078 
    args.userId = userId
6000 mandeep.dh 6079 
    args.write(self._oprot)
6080 
    self._oprot.writeMessageEnd()
6081 
    self._oprot.trans.flush()
6082 
 
6031 rajveer 6083 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6085 
    if mtype == TMessageType.EXCEPTION:
6086 
      x = TApplicationException()
6087 
      x.read(self._iprot)
6088 
      self._iprot.readMessageEnd()
6089 
      raise x
6031 rajveer 6090 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6091 
    result.read(self._iprot)
6092 
    self._iprot.readMessageEnd()
6093 
    if result.success is not None:
6094 
      return result.success
6031 rajveer 6095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6096 
 
6050 anupam.sin 6097 
  def getRechargeOrdersForTransaction(self, txnId):
6098 
    """
6099 
    Returns a recharge order for a given transactionId
6100 
 
6101 
    Parameters:
6102 
     - txnId
6103 
    """
6104 
    self.send_getRechargeOrdersForTransaction(txnId)
6105 
    return self.recv_getRechargeOrdersForTransaction()
6106 
 
6107 
  def send_getRechargeOrdersForTransaction(self, txnId):
6108 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6109 
    args = getRechargeOrdersForTransaction_args()
6110 
    args.txnId = txnId
6111 
    args.write(self._oprot)
6112 
    self._oprot.writeMessageEnd()
6113 
    self._oprot.trans.flush()
6114 
 
6115 
  def recv_getRechargeOrdersForTransaction(self, ):
6116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6117 
    if mtype == TMessageType.EXCEPTION:
6118 
      x = TApplicationException()
6119 
      x.read(self._iprot)
6120 
      self._iprot.readMessageEnd()
6121 
      raise x
6122 
    result = getRechargeOrdersForTransaction_result()
6123 
    result.read(self._iprot)
6124 
    self._iprot.readMessageEnd()
6125 
    if result.success is not None:
6126 
      return result.success
6127 
    if result.ex is not None:
6128 
      raise result.ex
6129 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6130 
 
6206 rajveer 6131 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6132 
    """
6133 
    Parameters:
6134 
     - rechargeType
6206 rajveer 6135 
     - onlyActive
6048 rajveer 6136 
    """
6206 rajveer 6137 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6138 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6139 
 
6206 rajveer 6140 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6141 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6142 
    args = getServiceProviders_args()
6143 
    args.rechargeType = rechargeType
6206 rajveer 6144 
    args.onlyActive = onlyActive
6048 rajveer 6145 
    args.write(self._oprot)
6146 
    self._oprot.writeMessageEnd()
6147 
    self._oprot.trans.flush()
6148 
 
6149 
  def recv_getServiceProviders(self, ):
6150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6151 
    if mtype == TMessageType.EXCEPTION:
6152 
      x = TApplicationException()
6153 
      x.read(self._iprot)
6154 
      self._iprot.readMessageEnd()
6155 
      raise x
6156 
    result = getServiceProviders_result()
6157 
    result.read(self._iprot)
6158 
    self._iprot.readMessageEnd()
6159 
    if result.success is not None:
6160 
      return result.success
6161 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6162 
 
6049 rajveer 6163 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6164 
    """
6165 
    Parameters:
6049 rajveer 6166 
     - rechargeType
6048 rajveer 6167 
     - deviceNumber
6168 
    """
6049 rajveer 6169 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6170 
    return self.recv_getServiceProviderForDevice()
6171 
 
6049 rajveer 6172 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6173 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6174 
    args = getServiceProviderForDevice_args()
6049 rajveer 6175 
    args.rechargeType = rechargeType
6048 rajveer 6176 
    args.deviceNumber = deviceNumber
6177 
    args.write(self._oprot)
6178 
    self._oprot.writeMessageEnd()
6179 
    self._oprot.trans.flush()
6180 
 
6181 
  def recv_getServiceProviderForDevice(self, ):
6182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6183 
    if mtype == TMessageType.EXCEPTION:
6184 
      x = TApplicationException()
6185 
      x.read(self._iprot)
6186 
      self._iprot.readMessageEnd()
6187 
      raise x
6188 
    result = getServiceProviderForDevice_result()
6189 
    result.read(self._iprot)
6190 
    self._iprot.readMessageEnd()
6191 
    if result.success is not None:
6192 
      return result.success
6193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6194 
 
6336 anupam.sin 6195 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6196 
    """
6197 
    Parameters:
6198 
     - rechargeType
6199 
     - deviceNumber
6307 anupam.sin 6200 
     - userSelectedProviderId
6269 rajveer 6201 
    """
6336 anupam.sin 6202 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId)
6269 rajveer 6203 
    return self.recv_validateRecharge()
6204 
 
6336 anupam.sin 6205 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6206 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6207 
    args = validateRecharge_args()
6208 
    args.rechargeType = rechargeType
6209 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6210 
    args.userSelectedProviderId = userSelectedProviderId
6269 rajveer 6211 
    args.write(self._oprot)
6212 
    self._oprot.writeMessageEnd()
6213 
    self._oprot.trans.flush()
6214 
 
6215 
  def recv_validateRecharge(self, ):
6216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6217 
    if mtype == TMessageType.EXCEPTION:
6218 
      x = TApplicationException()
6219 
      x.read(self._iprot)
6220 
      self._iprot.readMessageEnd()
6221 
      raise x
6222 
    result = validateRecharge_result()
6223 
    result.read(self._iprot)
6224 
    self._iprot.readMessageEnd()
6225 
    if result.success is not None:
6226 
      return result.success
6227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6228 
 
6094 rajveer 6229 
  def getRechargeOrdersForDevice(self, deviceNumber):
6230 
    """
6231 
    Parameters:
6232 
     - deviceNumber
6233 
    """
6234 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6235 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6236 
 
6094 rajveer 6237 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6238 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6239 
    args = getRechargeOrdersForDevice_args()
6240 
    args.deviceNumber = deviceNumber
6241 
    args.write(self._oprot)
6242 
    self._oprot.writeMessageEnd()
6243 
    self._oprot.trans.flush()
6244 
 
6245 
  def recv_getRechargeOrdersForDevice(self, ):
6246 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6247 
    if mtype == TMessageType.EXCEPTION:
6248 
      x = TApplicationException()
6249 
      x.read(self._iprot)
6250 
      self._iprot.readMessageEnd()
6251 
      raise x
6252 
    result = getRechargeOrdersForDevice_result()
6253 
    result.read(self._iprot)
6254 
    self._iprot.readMessageEnd()
6255 
    if result.success is not None:
6256 
      return result.success
6257 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6258 
 
6259 
  def addAmountToWallet(self, userId, orderId, amount):
6260 
    """
6261 
    Parameters:
6262 
     - userId
6263 
     - orderId
6264 
     - amount
6265 
    """
6266 
    self.send_addAmountToWallet(userId, orderId, amount)
6267 
    self.recv_addAmountToWallet()
6268 
 
6269 
  def send_addAmountToWallet(self, userId, orderId, amount):
6270 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6271 
    args = addAmountToWallet_args()
6272 
    args.userId = userId
6273 
    args.orderId = orderId
6274 
    args.amount = amount
6275 
    args.write(self._oprot)
6276 
    self._oprot.writeMessageEnd()
6277 
    self._oprot.trans.flush()
6278 
 
6279 
  def recv_addAmountToWallet(self, ):
6280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6281 
    if mtype == TMessageType.EXCEPTION:
6282 
      x = TApplicationException()
6283 
      x.read(self._iprot)
6284 
      self._iprot.readMessageEnd()
6285 
      raise x
6286 
    result = addAmountToWallet_result()
6287 
    result.read(self._iprot)
6288 
    self._iprot.readMessageEnd()
6289 
    return
6290 
 
6188 rajveer 6291 
  def getRechargeStatistics(self, ):
6292 
    self.send_getRechargeStatistics()
6293 
    return self.recv_getRechargeStatistics()
6294 
 
6295 
  def send_getRechargeStatistics(self, ):
6296 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6297 
    args = getRechargeStatistics_args()
6298 
    args.write(self._oprot)
6299 
    self._oprot.writeMessageEnd()
6300 
    self._oprot.trans.flush()
6301 
 
6302 
  def recv_getRechargeStatistics(self, ):
6303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6304 
    if mtype == TMessageType.EXCEPTION:
6305 
      x = TApplicationException()
6306 
      x.read(self._iprot)
6307 
      self._iprot.readMessageEnd()
6308 
      raise x
6309 
    result = getRechargeStatistics_result()
6310 
    result.read(self._iprot)
6311 
    self._iprot.readMessageEnd()
6312 
    if result.success is not None:
6313 
      return result.success
6314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6315 
 
6154 rajveer 6316 
  def getRechargeOrdersForStatus(self, status):
6317 
    """
6318 
    Parameters:
6319 
     - status
6320 
    """
6321 
    self.send_getRechargeOrdersForStatus(status)
6322 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6323 
 
6154 rajveer 6324 
  def send_getRechargeOrdersForStatus(self, status):
6325 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6326 
    args = getRechargeOrdersForStatus_args()
6327 
    args.status = status
6328 
    args.write(self._oprot)
6329 
    self._oprot.writeMessageEnd()
6330 
    self._oprot.trans.flush()
6331 
 
6332 
  def recv_getRechargeOrdersForStatus(self, ):
6333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6334 
    if mtype == TMessageType.EXCEPTION:
6335 
      x = TApplicationException()
6336 
      x.read(self._iprot)
6337 
      self._iprot.readMessageEnd()
6338 
      raise x
6339 
    result = getRechargeOrdersForStatus_result()
6340 
    result.read(self._iprot)
6341 
    self._iprot.readMessageEnd()
6342 
    if result.success is not None:
6343 
      return result.success
6344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6345 
 
6159 rajveer 6346 
  def getPlansForOperator(self, operatorId):
6347 
    """
6348 
    Parameters:
6349 
     - operatorId
6350 
    """
6351 
    self.send_getPlansForOperator(operatorId)
6352 
    return self.recv_getPlansForOperator()
6154 rajveer 6353 
 
6159 rajveer 6354 
  def send_getPlansForOperator(self, operatorId):
6355 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6356 
    args = getPlansForOperator_args()
6357 
    args.operatorId = operatorId
6358 
    args.write(self._oprot)
6359 
    self._oprot.writeMessageEnd()
6360 
    self._oprot.trans.flush()
6361 
 
6362 
  def recv_getPlansForOperator(self, ):
6363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6364 
    if mtype == TMessageType.EXCEPTION:
6365 
      x = TApplicationException()
6366 
      x.read(self._iprot)
6367 
      self._iprot.readMessageEnd()
6368 
      raise x
6369 
    result = getPlansForOperator_result()
6370 
    result.read(self._iprot)
6371 
    self._iprot.readMessageEnd()
6372 
    if result.success is not None:
6373 
      return result.success
6374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6375 
 
6307 anupam.sin 6376 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6377 
    """
6378 
    Returns denominations for a given operator and circle
6159 rajveer 6379 
 
6289 anupam.sin 6380 
    Parameters:
6381 
     - operatorId
6307 anupam.sin 6382 
     - circleCode
6289 anupam.sin 6383 
     - denominationType
6384 
    """
6307 anupam.sin 6385 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6386 
    return self.recv_getRechargeDenominations()
6387 
 
6307 anupam.sin 6388 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6389 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6390 
    args = getRechargeDenominations_args()
6391 
    args.operatorId = operatorId
6307 anupam.sin 6392 
    args.circleCode = circleCode
6289 anupam.sin 6393 
    args.denominationType = denominationType
6394 
    args.write(self._oprot)
6395 
    self._oprot.writeMessageEnd()
6396 
    self._oprot.trans.flush()
6397 
 
6398 
  def recv_getRechargeDenominations(self, ):
6399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6400 
    if mtype == TMessageType.EXCEPTION:
6401 
      x = TApplicationException()
6402 
      x.read(self._iprot)
6403 
      self._iprot.readMessageEnd()
6404 
      raise x
6405 
    result = getRechargeDenominations_result()
6406 
    result.read(self._iprot)
6407 
    self._iprot.readMessageEnd()
6408 
    if result.success is not None:
6409 
      return result.success
6410 
    if result.ex is not None:
6411 
      raise result.ex
6412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6413 
 
6371 rajveer 6414 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6415 
    """
6416 
    Parameters:
6417 
     - operatorId
6418 
     - circleId
6419 
     - isAvailable
6420 
    """
6421 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6422 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6423 
 
6371 rajveer 6424 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6425 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6426 
    args = updateAvailabilityStatus_args()
6427 
    args.operatorId = operatorId
6428 
    args.circleId = circleId
6429 
    args.isAvailable = isAvailable
6430 
    args.write(self._oprot)
6431 
    self._oprot.writeMessageEnd()
6432 
    self._oprot.trans.flush()
6433 
 
6434 
  def recv_updateAvailabilityStatus(self, ):
6435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6436 
    if mtype == TMessageType.EXCEPTION:
6437 
      x = TApplicationException()
6438 
      x.read(self._iprot)
6439 
      self._iprot.readMessageEnd()
6440 
      raise x
6441 
    result = updateAvailabilityStatus_result()
6442 
    result.read(self._iprot)
6443 
    self._iprot.readMessageEnd()
6444 
    return
6445 
 
6389 rajveer 6446 
  def getAvailableEmiSchemes(self, ):
6447 
    self.send_getAvailableEmiSchemes()
6448 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6449 
 
6389 rajveer 6450 
  def send_getAvailableEmiSchemes(self, ):
6451 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6452 
    args = getAvailableEmiSchemes_args()
6453 
    args.write(self._oprot)
6454 
    self._oprot.writeMessageEnd()
6455 
    self._oprot.trans.flush()
6456 
 
6457 
  def recv_getAvailableEmiSchemes(self, ):
6458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6459 
    if mtype == TMessageType.EXCEPTION:
6460 
      x = TApplicationException()
6461 
      x.read(self._iprot)
6462 
      self._iprot.readMessageEnd()
6463 
      raise x
6464 
    result = getAvailableEmiSchemes_result()
6465 
    result.read(self._iprot)
6466 
    self._iprot.readMessageEnd()
6467 
    if result.success is not None:
6468 
      return result.success
6469 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6470 
 
6471 
  def getMiscCharges(self, transactionId):
6472 
    """
6473 
    Parameters:
6474 
     - transactionId
6475 
    """
6476 
    self.send_getMiscCharges(transactionId)
6477 
    return self.recv_getMiscCharges()
6478 
 
6479 
  def send_getMiscCharges(self, transactionId):
6480 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6481 
    args = getMiscCharges_args()
6482 
    args.transactionId = transactionId
6483 
    args.write(self._oprot)
6484 
    self._oprot.writeMessageEnd()
6485 
    self._oprot.trans.flush()
6486 
 
6487 
  def recv_getMiscCharges(self, ):
6488 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6489 
    if mtype == TMessageType.EXCEPTION:
6490 
      x = TApplicationException()
6491 
      x.read(self._iprot)
6492 
      self._iprot.readMessageEnd()
6493 
      raise x
6494 
    result = getMiscCharges_result()
6495 
    result.read(self._iprot)
6496 
    self._iprot.readMessageEnd()
6497 
    if result.success is not None:
6498 
      return result.success
6499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6500 
 
6501 
 
3376 rajveer 6502 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6503 
  def __init__(self, handler):
3376 rajveer 6504 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6505 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6506 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6507 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6508 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6509 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6510 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6511 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6512 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6513 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6514 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6515 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6516 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6517 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6518 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6519 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6520 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6521 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6522 
    self._processMap["createOrder"] = Processor.process_createOrder
6523 
    self._processMap["getOrder"] = Processor.process_getOrder
6524 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6525 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6526 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6527 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6528 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6529 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6530 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6531 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6532 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6533 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6534 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6535 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6536 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6537 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6538 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6539 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6540 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6541 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6542 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6543 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6544 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6545 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6546 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6547 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6548 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6549 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6550 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6551 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6552 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6553 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6554 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6555 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6556 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6557 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6558 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6559 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6560 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6561 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6562 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6563 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6564 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6565 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6566 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6567 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6568 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6569 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6570 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6571 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6572 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6573 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6574 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6575 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6576 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6577 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6578 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6579 
    self._processMap["changeItem"] = Processor.process_changeItem
6580 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6581 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6582 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6583 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6584 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6585 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6586 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6587 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6588 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6589 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6590 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6591 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6592 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6593 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6594 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6595 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6596 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6597 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6598 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6599 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6600 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6601 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6602 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6603 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6604 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6605 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6606 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6607 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6608 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6609 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6610 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6611 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6612 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6613 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6614 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6615 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6616 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6617 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6618 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6619 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6620 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6621 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6622 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6623 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6624 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6625 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6626 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6627 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6628 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6629 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6630 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6631 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6632 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6633 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6634 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6635 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6636 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6637 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6638 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6639 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6640 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6641 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6642 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6643 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6644 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6645 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6646 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6647 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6648 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6649 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6650 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6651 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
94 ashish 6652 
 
6653 
  def process(self, iprot, oprot):
6654 
    (name, type, seqid) = iprot.readMessageBegin()
6655 
    if name not in self._processMap:
6656 
      iprot.skip(TType.STRUCT)
6657 
      iprot.readMessageEnd()
6658 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6659 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6660 
      x.write(oprot)
6661 
      oprot.writeMessageEnd()
6662 
      oprot.trans.flush()
6663 
      return
6664 
    else:
6665 
      self._processMap[name](self, seqid, iprot, oprot)
6666 
    return True
6667 
 
6668 
  def process_createTransaction(self, seqid, iprot, oprot):
6669 
    args = createTransaction_args()
6670 
    args.read(iprot)
6671 
    iprot.readMessageEnd()
6672 
    result = createTransaction_result()
6673 
    try:
132 ashish 6674 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6675 
    except TransactionServiceException, ex:
6676 
      result.ex = ex
6677 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6678 
    result.write(oprot)
6679 
    oprot.writeMessageEnd()
6680 
    oprot.trans.flush()
6681 
 
6682 
  def process_getTransaction(self, seqid, iprot, oprot):
6683 
    args = getTransaction_args()
6684 
    args.read(iprot)
6685 
    iprot.readMessageEnd()
6686 
    result = getTransaction_result()
6687 
    try:
6688 
      result.success = self._handler.getTransaction(args.id)
6689 
    except TransactionServiceException, ex:
6690 
      result.ex = ex
6691 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6692 
    result.write(oprot)
6693 
    oprot.writeMessageEnd()
6694 
    oprot.trans.flush()
6695 
 
6696 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6697 
    args = getTransactionsForCustomer_args()
6698 
    args.read(iprot)
6699 
    iprot.readMessageEnd()
6700 
    result = getTransactionsForCustomer_result()
6701 
    try:
6702 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6703 
    except TransactionServiceException, ex:
6704 
      result.ex = ex
6705 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6706 
    result.write(oprot)
6707 
    oprot.writeMessageEnd()
6708 
    oprot.trans.flush()
6709 
 
132 ashish 6710 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6711 
    args = getTransactionsForShoppingCartId_args()
6712 
    args.read(iprot)
6713 
    iprot.readMessageEnd()
6714 
    result = getTransactionsForShoppingCartId_result()
6715 
    try:
6716 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6717 
    except TransactionServiceException, ex:
6718 
      result.ex = ex
6719 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6720 
    result.write(oprot)
6721 
    oprot.writeMessageEnd()
6722 
    oprot.trans.flush()
6723 
 
94 ashish 6724 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6725 
    args = getTransactionStatus_args()
6726 
    args.read(iprot)
6727 
    iprot.readMessageEnd()
6728 
    result = getTransactionStatus_result()
6729 
    try:
6730 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6731 
    except TransactionServiceException, ex:
6732 
      result.ex = ex
6733 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6734 
    result.write(oprot)
6735 
    oprot.writeMessageEnd()
6736 
    oprot.trans.flush()
6737 
 
6738 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6739 
    args = changeTransactionStatus_args()
6740 
    args.read(iprot)
6741 
    iprot.readMessageEnd()
6742 
    result = changeTransactionStatus_result()
6743 
    try:
5527 anupam.sin 6744 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6745 
    except TransactionServiceException, ex:
6746 
      result.ex = ex
6747 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6748 
    result.write(oprot)
6749 
    oprot.writeMessageEnd()
6750 
    oprot.trans.flush()
6751 
 
1398 varun.gupt 6752 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6753 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6754 
    args.read(iprot)
6755 
    iprot.readMessageEnd()
1398 varun.gupt 6756 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6757 
    try:
1398 varun.gupt 6758 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6759 
    except TransactionServiceException, ex:
6760 
      result.ex = ex
1398 varun.gupt 6761 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6762 
    result.write(oprot)
6763 
    oprot.writeMessageEnd()
6764 
    oprot.trans.flush()
6765 
 
483 rajveer 6766 
  def process_getAllOrders(self, seqid, iprot, oprot):
6767 
    args = getAllOrders_args()
94 ashish 6768 
    args.read(iprot)
6769 
    iprot.readMessageEnd()
483 rajveer 6770 
    result = getAllOrders_result()
94 ashish 6771 
    try:
4801 anupam.sin 6772 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6773 
    except TransactionServiceException, ex:
6774 
      result.ex = ex
483 rajveer 6775 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6776 
    result.write(oprot)
6777 
    oprot.writeMessageEnd()
6778 
    oprot.trans.flush()
6779 
 
4133 chandransh 6780 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6781 
    args = getOrdersInBatch_args()
6782 
    args.read(iprot)
6783 
    iprot.readMessageEnd()
6784 
    result = getOrdersInBatch_result()
6785 
    try:
6786 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6787 
    except TransactionServiceException, ex:
6788 
      result.ex = ex
6789 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6790 
    result.write(oprot)
6791 
    oprot.writeMessageEnd()
6792 
    oprot.trans.flush()
6793 
 
6794 
  def process_getOrderCount(self, seqid, iprot, oprot):
6795 
    args = getOrderCount_args()
6796 
    args.read(iprot)
6797 
    iprot.readMessageEnd()
6798 
    result = getOrderCount_result()
6799 
    try:
6800 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6801 
    except TransactionServiceException, ex:
6802 
      result.ex = ex
6803 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6804 
    result.write(oprot)
6805 
    oprot.writeMessageEnd()
6806 
    oprot.trans.flush()
6807 
 
999 varun.gupt 6808 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6809 
    args = getOrdersByBillingDate_args()
6810 
    args.read(iprot)
6811 
    iprot.readMessageEnd()
6812 
    result = getOrdersByBillingDate_result()
6813 
    try:
6814 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6815 
    except TransactionServiceException, ex:
6816 
      result.ex = ex
6817 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6818 
    result.write(oprot)
6819 
    oprot.writeMessageEnd()
6820 
    oprot.trans.flush()
6821 
 
3427 chandransh 6822 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6823 
    args = getOrdersByShippingDate_args()
6824 
    args.read(iprot)
6825 
    iprot.readMessageEnd()
6826 
    result = getOrdersByShippingDate_result()
6827 
    try:
3451 chandransh 6828 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6829 
    except TransactionServiceException, ex:
6830 
      result.ex = ex
6831 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6832 
    result.write(oprot)
6833 
    oprot.writeMessageEnd()
6834 
    oprot.trans.flush()
6835 
 
1382 varun.gupt 6836 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6837 
    args = getReturnableOrdersForCustomer_args()
6838 
    args.read(iprot)
6839 
    iprot.readMessageEnd()
6840 
    result = getReturnableOrdersForCustomer_result()
6841 
    try:
6842 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6843 
    except TransactionServiceException, ex:
6844 
      result.ex = ex
6845 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6846 
    result.write(oprot)
6847 
    oprot.writeMessageEnd()
6848 
    oprot.trans.flush()
6849 
 
6850 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6851 
    args = getCancellableOrdersForCustomer_args()
6852 
    args.read(iprot)
6853 
    iprot.readMessageEnd()
6854 
    result = getCancellableOrdersForCustomer_result()
6855 
    try:
6856 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6857 
    except TransactionServiceException, ex:
6858 
      result.ex = ex
6859 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6860 
    result.write(oprot)
6861 
    oprot.writeMessageEnd()
6862 
    oprot.trans.flush()
6863 
 
483 rajveer 6864 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6865 
    args = changeOrderStatus_args()
94 ashish 6866 
    args.read(iprot)
6867 
    iprot.readMessageEnd()
483 rajveer 6868 
    result = changeOrderStatus_result()
94 ashish 6869 
    try:
483 rajveer 6870 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6871 
    except TransactionServiceException, ex:
6872 
      result.ex = ex
483 rajveer 6873 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6874 
    result.write(oprot)
6875 
    oprot.writeMessageEnd()
6876 
    oprot.trans.flush()
6877 
 
483 rajveer 6878 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6879 
    args = getOrdersForTransaction_args()
94 ashish 6880 
    args.read(iprot)
6881 
    iprot.readMessageEnd()
483 rajveer 6882 
    result = getOrdersForTransaction_result()
94 ashish 6883 
    try:
1528 ankur.sing 6884 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6885 
    except TransactionServiceException, ex:
6886 
      result.ex = ex
483 rajveer 6887 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6888 
    result.write(oprot)
6889 
    oprot.writeMessageEnd()
6890 
    oprot.trans.flush()
6891 
 
483 rajveer 6892 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6893 
    args = getOrdersForCustomer_args()
94 ashish 6894 
    args.read(iprot)
6895 
    iprot.readMessageEnd()
483 rajveer 6896 
    result = getOrdersForCustomer_result()
94 ashish 6897 
    try:
3014 chandransh 6898 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6899 
    except TransactionServiceException, ex:
6900 
      result.ex = ex
483 rajveer 6901 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6902 
    result.write(oprot)
6903 
    oprot.writeMessageEnd()
6904 
    oprot.trans.flush()
6905 
 
483 rajveer 6906 
  def process_createOrder(self, seqid, iprot, oprot):
6907 
    args = createOrder_args()
94 ashish 6908 
    args.read(iprot)
6909 
    iprot.readMessageEnd()
483 rajveer 6910 
    result = createOrder_result()
94 ashish 6911 
    try:
483 rajveer 6912 
      result.success = self._handler.createOrder(args.order)
94 ashish 6913 
    except TransactionServiceException, ex:
6914 
      result.ex = ex
483 rajveer 6915 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6916 
    result.write(oprot)
6917 
    oprot.writeMessageEnd()
6918 
    oprot.trans.flush()
6919 
 
483 rajveer 6920 
  def process_getOrder(self, seqid, iprot, oprot):
6921 
    args = getOrder_args()
94 ashish 6922 
    args.read(iprot)
6923 
    iprot.readMessageEnd()
483 rajveer 6924 
    result = getOrder_result()
94 ashish 6925 
    try:
483 rajveer 6926 
      result.success = self._handler.getOrder(args.id)
94 ashish 6927 
    except TransactionServiceException, ex:
6928 
      result.ex = ex
483 rajveer 6929 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6930 
    result.write(oprot)
6931 
    oprot.writeMessageEnd()
6932 
    oprot.trans.flush()
6933 
 
483 rajveer 6934 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6935 
    args = getLineItemsForOrder_args()
94 ashish 6936 
    args.read(iprot)
6937 
    iprot.readMessageEnd()
483 rajveer 6938 
    result = getLineItemsForOrder_result()
94 ashish 6939 
    try:
483 rajveer 6940 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6941 
    except TransactionServiceException, ex:
6942 
      result.ex = ex
483 rajveer 6943 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6944 
    result.write(oprot)
6945 
    oprot.writeMessageEnd()
6946 
    oprot.trans.flush()
6947 
 
4999 phani.kuma 6948 
  def process_getOrderList(self, seqid, iprot, oprot):
6949 
    args = getOrderList_args()
6950 
    args.read(iprot)
6951 
    iprot.readMessageEnd()
6952 
    result = getOrderList_result()
6953 
    result.success = self._handler.getOrderList(args.order_ids)
6954 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6955 
    result.write(oprot)
6956 
    oprot.writeMessageEnd()
6957 
    oprot.trans.flush()
6958 
 
5386 phani.kuma 6959 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6960 
    args = getOrderListForVendor_args()
6961 
    args.read(iprot)
6962 
    iprot.readMessageEnd()
6963 
    result = getOrderListForVendor_result()
6964 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6965 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6966 
    result.write(oprot)
6967 
    oprot.writeMessageEnd()
6968 
    oprot.trans.flush()
6969 
 
1528 ankur.sing 6970 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6971 
    args = getOrderForCustomer_args()
6972 
    args.read(iprot)
6973 
    iprot.readMessageEnd()
6974 
    result = getOrderForCustomer_result()
6975 
    try:
6976 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6977 
    except TransactionServiceException, ex:
6978 
      result.ex = ex
6979 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6980 
    result.write(oprot)
6981 
    oprot.writeMessageEnd()
6982 
    oprot.trans.flush()
6983 
 
3064 chandransh 6984 
  def process_getAlerts(self, seqid, iprot, oprot):
6985 
    args = getAlerts_args()
6986 
    args.read(iprot)
6987 
    iprot.readMessageEnd()
6988 
    result = getAlerts_result()
4444 rajveer 6989 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6990 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6991 
    result.write(oprot)
6992 
    oprot.writeMessageEnd()
6993 
    oprot.trans.flush()
6994 
 
4394 rajveer 6995 
  def process_addAlert(self, seqid, iprot, oprot):
6996 
    args = addAlert_args()
3064 chandransh 6997 
    args.read(iprot)
6998 
    iprot.readMessageEnd()
4394 rajveer 6999 
    result = addAlert_result()
4444 rajveer 7000 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7001 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7002 
    result.write(oprot)
7003 
    oprot.writeMessageEnd()
7004 
    oprot.trans.flush()
7005 
 
4444 rajveer 7006 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7007 
    args = markAlertsAsSeen_args()
7008 
    args.read(iprot)
7009 
    iprot.readMessageEnd()
7010 
    result = markAlertsAsSeen_result()
7011 
    self._handler.markAlertsAsSeen(args.warehouseId)
7012 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7013 
    result.write(oprot)
7014 
    oprot.writeMessageEnd()
7015 
    oprot.trans.flush()
7016 
 
3064 chandransh 7017 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7018 
    args = getValidOrderCount_args()
7019 
    args.read(iprot)
7020 
    iprot.readMessageEnd()
7021 
    result = getValidOrderCount_result()
7022 
    result.success = self._handler.getValidOrderCount()
7023 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7024 
    result.write(oprot)
7025 
    oprot.writeMessageEnd()
7026 
    oprot.trans.flush()
7027 
 
7028 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7029 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7030 
    args.read(iprot)
7031 
    iprot.readMessageEnd()
7032 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7033 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7034 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
7039 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7040 
    args = getValidOrdersAmountRange_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = getValidOrdersAmountRange_result()
7044 
    result.success = self._handler.getValidOrdersAmountRange()
7045 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
7050 
  def process_getValidOrders(self, seqid, iprot, oprot):
7051 
    args = getValidOrders_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = getValidOrders_result()
5874 rajveer 7055 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7056 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7057 
    result.write(oprot)
7058 
    oprot.writeMessageEnd()
7059 
    oprot.trans.flush()
7060 
 
1220 chandransh 7061 
  def process_batchOrders(self, seqid, iprot, oprot):
7062 
    args = batchOrders_args()
7063 
    args.read(iprot)
7064 
    iprot.readMessageEnd()
7065 
    result = batchOrders_result()
7066 
    try:
7067 
      result.success = self._handler.batchOrders(args.warehouseId)
7068 
    except TransactionServiceException, ex:
7069 
      result.ex = ex
7070 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7071 
    result.write(oprot)
7072 
    oprot.writeMessageEnd()
7073 
    oprot.trans.flush()
7074 
 
1208 chandransh 7075 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7076 
    args = markOrderAsOutOfStock_args()
7077 
    args.read(iprot)
7078 
    iprot.readMessageEnd()
7079 
    result = markOrderAsOutOfStock_result()
7080 
    try:
7081 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7082 
    except TransactionServiceException, ex:
7083 
      result.ex = ex
7084 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7085 
    result.write(oprot)
7086 
    oprot.writeMessageEnd()
7087 
    oprot.trans.flush()
7088 
 
3064 chandransh 7089 
  def process_verifyOrder(self, seqid, iprot, oprot):
7090 
    args = verifyOrder_args()
759 chandransh 7091 
    args.read(iprot)
7092 
    iprot.readMessageEnd()
3064 chandransh 7093 
    result = verifyOrder_result()
759 chandransh 7094 
    try:
3064 chandransh 7095 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7096 
    except TransactionServiceException, ex:
7097 
      result.ex = ex
3064 chandransh 7098 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7099 
    result.write(oprot)
7100 
    oprot.writeMessageEnd()
7101 
    oprot.trans.flush()
7102 
 
3064 chandransh 7103 
  def process_acceptOrder(self, seqid, iprot, oprot):
7104 
    args = acceptOrder_args()
1113 chandransh 7105 
    args.read(iprot)
7106 
    iprot.readMessageEnd()
3064 chandransh 7107 
    result = acceptOrder_result()
1113 chandransh 7108 
    try:
3064 chandransh 7109 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7110 
    except TransactionServiceException, ex:
7111 
      result.ex = ex
3064 chandransh 7112 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7113 
    result.write(oprot)
7114 
    oprot.writeMessageEnd()
7115 
    oprot.trans.flush()
7116 
 
3064 chandransh 7117 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7118 
    args = addBillingDetails_args()
1135 chandransh 7119 
    args.read(iprot)
7120 
    iprot.readMessageEnd()
3064 chandransh 7121 
    result = addBillingDetails_result()
1135 chandransh 7122 
    try:
5110 mandeep.dh 7123 
      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 7124 
    except TransactionServiceException, ex:
7125 
      result.ex = ex
3064 chandransh 7126 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
4579 rajveer 7131 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7132 
    args = addInvoiceNumber_args()
7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
7135 
    result = addInvoiceNumber_result()
7136 
    try:
4763 rajveer 7137 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7138 
    except TransactionServiceException, ex:
7139 
      result.ex = ex
7140 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7141 
    result.write(oprot)
7142 
    oprot.writeMessageEnd()
7143 
    oprot.trans.flush()
7144 
 
4410 rajveer 7145 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7146 
    args = markOrdersAsShippedFromWarehouse_args()
7147 
    args.read(iprot)
7148 
    iprot.readMessageEnd()
7149 
    result = markOrdersAsShippedFromWarehouse_result()
7150 
    try:
4789 rajveer 7151 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7152 
    except TransactionServiceException, ex:
7153 
      result.ex = ex
7154 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7155 
    result.write(oprot)
7156 
    oprot.writeMessageEnd()
7157 
    oprot.trans.flush()
7158 
 
5676 rajveer 7159 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7160 
    args = markOrdersAsReturnedFromStore_args()
7161 
    args.read(iprot)
7162 
    iprot.readMessageEnd()
7163 
    result = markOrdersAsReturnedFromStore_result()
7164 
    try:
5713 rajveer 7165 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7166 
    except TransactionServiceException, ex:
7167 
      result.ex = ex
7168 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7169 
    result.write(oprot)
7170 
    oprot.writeMessageEnd()
7171 
    oprot.trans.flush()
7172 
 
3064 chandransh 7173 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7174 
    args = markOrdersAsPickedUp_args()
304 ashish 7175 
    args.read(iprot)
7176 
    iprot.readMessageEnd()
3064 chandransh 7177 
    result = markOrdersAsPickedUp_result()
7178 
    try:
4910 phani.kuma 7179 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7180 
    except TransactionServiceException, ex:
7181 
      result.ex = ex
7182 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7183 
    result.write(oprot)
7184 
    oprot.writeMessageEnd()
7185 
    oprot.trans.flush()
94 ashish 7186 
 
4910 phani.kuma 7187 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7188 
    args = getOrdersNotPickedUp_args()
7189 
    args.read(iprot)
7190 
    iprot.readMessageEnd()
7191 
    result = getOrdersNotPickedUp_result()
7192 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7193 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7194 
    result.write(oprot)
7195 
    oprot.writeMessageEnd()
7196 
    oprot.trans.flush()
7197 
 
3064 chandransh 7198 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7199 
    args = markOrdersAsDelivered_args()
304 ashish 7200 
    args.read(iprot)
7201 
    iprot.readMessageEnd()
3064 chandransh 7202 
    result = markOrdersAsDelivered_result()
7203 
    try:
7204 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7205 
    except TransactionServiceException, ex:
7206 
      result.ex = ex
7207 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7208 
    result.write(oprot)
7209 
    oprot.writeMessageEnd()
7210 
    oprot.trans.flush()
7211 
 
4910 phani.kuma 7212 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7213 
    args = markAsRTOrders_args()
1596 ankur.sing 7214 
    args.read(iprot)
7215 
    iprot.readMessageEnd()
4910 phani.kuma 7216 
    result = markAsRTOrders_result()
3064 chandransh 7217 
    try:
4910 phani.kuma 7218 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7219 
    except TransactionServiceException, ex:
7220 
      result.ex = ex
4910 phani.kuma 7221 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7222 
    result.write(oprot)
7223 
    oprot.writeMessageEnd()
7224 
    oprot.trans.flush()
304 ashish 7225 
 
4910 phani.kuma 7226 
  def process_getRTOrders(self, seqid, iprot, oprot):
7227 
    args = getRTOrders_args()
7228 
    args.read(iprot)
7229 
    iprot.readMessageEnd()
7230 
    result = getRTOrders_result()
7231 
    result.success = self._handler.getRTOrders(args.providerId)
7232 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7233 
    result.write(oprot)
7234 
    oprot.writeMessageEnd()
7235 
    oprot.trans.flush()
7236 
 
3064 chandransh 7237 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7238 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7239 
    args.read(iprot)
7240 
    iprot.readMessageEnd()
3064 chandransh 7241 
    result = updateNonDeliveryReason_result()
7242 
    try:
4910 phani.kuma 7243 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7244 
    except TransactionServiceException, ex:
7245 
      result.ex = ex
7246 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7247 
    result.write(oprot)
7248 
    oprot.writeMessageEnd()
7249 
    oprot.trans.flush()
1596 ankur.sing 7250 
 
4910 phani.kuma 7251 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7252 
    args = getNonDeliveredOrdersbyCourier_args()
7253 
    args.read(iprot)
7254 
    iprot.readMessageEnd()
7255 
    result = getNonDeliveredOrdersbyCourier_result()
7256 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7257 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
7261 
 
7262 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7263 
    args = markOrdersAsLocalConnected_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = markOrdersAsLocalConnected_result()
7267 
    try:
7268 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7269 
    except TransactionServiceException, ex:
7270 
      result.ex = ex
7271 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
7276 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7277 
    args = getOrdersNotLocalConnected_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = getOrdersNotLocalConnected_result()
7281 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7282 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7283 
    result.write(oprot)
7284 
    oprot.writeMessageEnd()
7285 
    oprot.trans.flush()
7286 
 
7287 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7288 
    args = markOrdersAsDestinationCityReached_args()
7289 
    args.read(iprot)
7290 
    iprot.readMessageEnd()
7291 
    result = markOrdersAsDestinationCityReached_result()
7292 
    try:
7293 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7294 
    except TransactionServiceException, ex:
7295 
      result.ex = ex
7296 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7297 
    result.write(oprot)
7298 
    oprot.writeMessageEnd()
7299 
    oprot.trans.flush()
7300 
 
7301 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7302 
    args = markOrdersAsFirstDeliveryAttempted_args()
7303 
    args.read(iprot)
7304 
    iprot.readMessageEnd()
7305 
    result = markOrdersAsFirstDeliveryAttempted_result()
7306 
    try:
7307 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7308 
    except TransactionServiceException, ex:
7309 
      result.ex = ex
7310 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
3064 chandransh 7315 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7316 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
3064 chandransh 7319 
    result = getUndeliveredOrders_result()
7320 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7321 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
4783 phani.kuma 7326 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7327 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7331 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7332 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7333 
    result.write(oprot)
7334 
    oprot.writeMessageEnd()
7335 
    oprot.trans.flush()
7336 
 
2536 chandransh 7337 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7338 
    args = toggleDOAFlag_args()
7339 
    args.read(iprot)
7340 
    iprot.readMessageEnd()
7341 
    result = toggleDOAFlag_result()
7342 
    try:
7343 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7344 
    except TransactionServiceException, ex:
7345 
      result.ex = ex
7346 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7347 
    result.write(oprot)
7348 
    oprot.writeMessageEnd()
7349 
    oprot.trans.flush()
1886 ankur.sing 7350 
 
4712 rajveer 7351 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7352 
    args = markOrderAsDelivered_args()
7353 
    args.read(iprot)
7354 
    iprot.readMessageEnd()
7355 
    result = markOrderAsDelivered_result()
7356 
    try:
7357 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7358 
    except TransactionServiceException, ex:
7359 
      result.ex = ex
7360 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7361 
    result.write(oprot)
7362 
    oprot.writeMessageEnd()
7363 
    oprot.trans.flush()
7364 
 
5553 rajveer 7365 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7366 
    args = markOrderAsReceivedAtStore_args()
7367 
    args.read(iprot)
7368 
    iprot.readMessageEnd()
7369 
    result = markOrderAsReceivedAtStore_result()
7370 
    try:
7371 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7372 
    except TransactionServiceException, ex:
7373 
      result.ex = ex
7374 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
4454 rajveer 7379 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7380 
    args = markOrderDoaRequestReceived_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = markOrderDoaRequestReceived_result()
7384 
    try:
7385 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7386 
    except TransactionServiceException, ex:
7387 
      result.ex = ex
7388 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7389 
    result.write(oprot)
7390 
    oprot.writeMessageEnd()
7391 
    oprot.trans.flush()
7392 
 
7393 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7394 
    args = markOrderDoaRequestAuthorized_args()
7395 
    args.read(iprot)
7396 
    iprot.readMessageEnd()
7397 
    result = markOrderDoaRequestAuthorized_result()
7398 
    try:
7399 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7400 
    except TransactionServiceException, ex:
7401 
      result.ex = ex
7402 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
4488 rajveer 7407 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7408 
    args = markOrderReturnRequestReceived_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = markOrderReturnRequestReceived_result()
7412 
    try:
7413 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7414 
    except TransactionServiceException, ex:
7415 
      result.ex = ex
7416 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
7421 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7422 
    args = markOrderReturnRequestAuthorized_args()
7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
7425 
    result = markOrderReturnRequestAuthorized_result()
7426 
    try:
7427 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7428 
    except TransactionServiceException, ex:
7429 
      result.ex = ex
7430 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
7434 
 
2536 chandransh 7435 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7436 
    args = requestPickupNumber_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = requestPickupNumber_result()
7440 
    try:
4579 rajveer 7441 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7442 
    except TransactionServiceException, ex:
7443 
      result.ex = ex
7444 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7445 
    result.write(oprot)
7446 
    oprot.writeMessageEnd()
7447 
    oprot.trans.flush()
7448 
 
7449 
  def process_authorizePickup(self, seqid, iprot, oprot):
7450 
    args = authorizePickup_args()
7451 
    args.read(iprot)
7452 
    iprot.readMessageEnd()
7453 
    result = authorizePickup_result()
7454 
    try:
4602 rajveer 7455 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7456 
    except TransactionServiceException, ex:
7457 
      result.ex = ex
7458 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7459 
    result.write(oprot)
7460 
    oprot.writeMessageEnd()
7461 
    oprot.trans.flush()
7462 
 
2764 chandransh 7463 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7464 
    args = markDoasAsPickedUp_args()
7465 
    args.read(iprot)
7466 
    iprot.readMessageEnd()
7467 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7468 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7469 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7470 
    result.write(oprot)
7471 
    oprot.writeMessageEnd()
7472 
    oprot.trans.flush()
7473 
 
4910 phani.kuma 7474 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7475 
    args = getDoasNotPickedUp_args()
7476 
    args.read(iprot)
7477 
    iprot.readMessageEnd()
7478 
    result = getDoasNotPickedUp_result()
7479 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7480 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7481 
    result.write(oprot)
7482 
    oprot.writeMessageEnd()
7483 
    oprot.trans.flush()
7484 
 
4741 phani.kuma 7485 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7486 
    args = markReturnOrdersAsPickedUp_args()
7487 
    args.read(iprot)
7488 
    iprot.readMessageEnd()
7489 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7490 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7491 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
7495 
 
4910 phani.kuma 7496 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7497 
    args = getReturnOrdersNotPickedUp_args()
7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
7500 
    result = getReturnOrdersNotPickedUp_result()
7501 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7502 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7506 
 
2616 chandransh 7507 
  def process_receiveReturn(self, seqid, iprot, oprot):
7508 
    args = receiveReturn_args()
2591 chandransh 7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
2616 chandransh 7511 
    result = receiveReturn_result()
2591 chandransh 7512 
    try:
4479 rajveer 7513 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7514 
    except TransactionServiceException, ex:
7515 
      result.ex = ex
2616 chandransh 7516 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
2536 chandransh 7520 
 
2591 chandransh 7521 
  def process_validateDoa(self, seqid, iprot, oprot):
7522 
    args = validateDoa_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = validateDoa_result()
7526 
    try:
7527 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
7530 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
7534 
 
4495 rajveer 7535 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7536 
    args = validateReturnProduct_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = validateReturnProduct_result()
7540 
    try:
7541 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
7548 
 
2616 chandransh 7549 
  def process_reshipOrder(self, seqid, iprot, oprot):
7550 
    args = reshipOrder_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = reshipOrder_result()
7554 
    try:
7555 
      result.success = self._handler.reshipOrder(args.orderId)
7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
2591 chandransh 7562 
 
2616 chandransh 7563 
  def process_refundOrder(self, seqid, iprot, oprot):
7564 
    args = refundOrder_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = refundOrder_result()
7568 
    try:
3226 chandransh 7569 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
2690 chandransh 7577 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7578 
    args = getReturnOrders_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = getReturnOrders_result()
7582 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7583 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
2616 chandransh 7587 
 
5481 phani.kuma 7588 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7589 
    args = getAllReturnOrders_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = getAllReturnOrders_result()
7593 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7594 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7595 
    result.write(oprot)
7596 
    oprot.writeMessageEnd()
7597 
    oprot.trans.flush()
7598 
 
2700 chandransh 7599 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7600 
    args = getReturnOrder_args()
7601 
    args.read(iprot)
7602 
    iprot.readMessageEnd()
7603 
    result = getReturnOrder_result()
7604 
    try:
7605 
      result.success = self._handler.getReturnOrder(args.id)
7606 
    except TransactionServiceException, ex:
7607 
      result.ex = ex
7608 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
2690 chandransh 7613 
  def process_processReturn(self, seqid, iprot, oprot):
7614 
    args = processReturn_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = processReturn_result()
7618 
    try:
7619 
      self._handler.processReturn(args.returnOrderId)
7620 
    except TransactionServiceException, ex:
7621 
      result.ex = ex
7622 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7623 
    result.write(oprot)
7624 
    oprot.writeMessageEnd()
7625 
    oprot.trans.flush()
7626 
 
3451 chandransh 7627 
  def process_updateWeight(self, seqid, iprot, oprot):
7628 
    args = updateWeight_args()
7629 
    args.read(iprot)
7630 
    iprot.readMessageEnd()
7631 
    result = updateWeight_result()
7632 
    try:
7633 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7634 
    except TransactionServiceException, ex:
7635 
      result.ex = ex
7636 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7637 
    result.write(oprot)
7638 
    oprot.writeMessageEnd()
7639 
    oprot.trans.flush()
2819 chandransh 7640 
 
3469 chandransh 7641 
  def process_changeItem(self, seqid, iprot, oprot):
7642 
    args = changeItem_args()
7643 
    args.read(iprot)
7644 
    iprot.readMessageEnd()
7645 
    result = changeItem_result()
7646 
    try:
7647 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7648 
    except TransactionServiceException, ex:
7649 
      result.ex = ex
7650 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7651 
    result.write(oprot)
7652 
    oprot.writeMessageEnd()
7653 
    oprot.trans.flush()
3451 chandransh 7654 
 
3469 chandransh 7655 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7656 
    args = shiftToWarehouse_args()
7657 
    args.read(iprot)
7658 
    iprot.readMessageEnd()
7659 
    result = shiftToWarehouse_result()
7660 
    try:
7661 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7662 
    except TransactionServiceException, ex:
7663 
      result.ex = ex
7664 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7665 
    result.write(oprot)
7666 
    oprot.writeMessageEnd()
7667 
    oprot.trans.flush()
7668 
 
3553 chandransh 7669 
  def process_addDelayReason(self, seqid, iprot, oprot):
7670 
    args = addDelayReason_args()
7671 
    args.read(iprot)
7672 
    iprot.readMessageEnd()
7673 
    result = addDelayReason_result()
7674 
    try:
4647 rajveer 7675 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7676 
    except TransactionServiceException, ex:
7677 
      result.ex = ex
7678 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7679 
    result.write(oprot)
7680 
    oprot.writeMessageEnd()
7681 
    oprot.trans.flush()
3469 chandransh 7682 
 
3956 chandransh 7683 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7684 
    args = reconcileCodCollection_args()
7685 
    args.read(iprot)
7686 
    iprot.readMessageEnd()
7687 
    result = reconcileCodCollection_result()
7688 
    try:
7689 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7690 
    except TransactionServiceException, ex:
7691 
      result.ex = ex
7692 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7693 
    result.write(oprot)
7694 
    oprot.writeMessageEnd()
7695 
    oprot.trans.flush()
3553 chandransh 7696 
 
4008 mandeep.dh 7697 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7698 
    args = getTransactionsRequiringExtraProcessing_args()
7699 
    args.read(iprot)
7700 
    iprot.readMessageEnd()
7701 
    result = getTransactionsRequiringExtraProcessing_result()
7702 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7703 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7704 
    result.write(oprot)
7705 
    oprot.writeMessageEnd()
7706 
    oprot.trans.flush()
3956 chandransh 7707 
 
4008 mandeep.dh 7708 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7709 
    args = markTransactionAsProcessed_args()
7710 
    args.read(iprot)
7711 
    iprot.readMessageEnd()
7712 
    result = markTransactionAsProcessed_result()
7713 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7714 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
4018 chandransh 7719 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7720 
    args = getItemWiseRiskyOrdersCount_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = getItemWiseRiskyOrdersCount_result()
7724 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7725 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
4008 mandeep.dh 7729 
 
4295 varun.gupt 7730 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7731 
    args = getOrdersForItemIds_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = getOrdersForItemIds_result()
7735 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7736 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7737 
    result.write(oprot)
7738 
    oprot.writeMessageEnd()
7739 
    oprot.trans.flush()
7740 
 
4247 rajveer 7741 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7742 
    args = markOrderCancellationRequestReceived_args()
7743 
    args.read(iprot)
7744 
    iprot.readMessageEnd()
7745 
    result = markOrderCancellationRequestReceived_result()
7746 
    try:
7747 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7748 
    except TransactionServiceException, ex:
7749 
      result.ex = ex
7750 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7751 
    result.write(oprot)
7752 
    oprot.writeMessageEnd()
7753 
    oprot.trans.flush()
4018 chandransh 7754 
 
4247 rajveer 7755 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7756 
    args = markOrderCancellationRequestConfirmed_args()
7757 
    args.read(iprot)
7758 
    iprot.readMessageEnd()
7759 
    result = markOrderCancellationRequestConfirmed_result()
7760 
    try:
7761 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7762 
    except TransactionServiceException, ex:
7763 
      result.ex = ex
7764 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7765 
    result.write(oprot)
7766 
    oprot.writeMessageEnd()
7767 
    oprot.trans.flush()
7768 
 
7769 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7770 
    args = markOrderCancellationRequestDenied_args()
7771 
    args.read(iprot)
7772 
    iprot.readMessageEnd()
7773 
    result = markOrderCancellationRequestDenied_result()
7774 
    try:
7775 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7776 
    except TransactionServiceException, ex:
7777 
      result.ex = ex
7778 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
7782 
 
4258 rajveer 7783 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7784 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
4258 rajveer 7787 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7788 
    try:
4258 rajveer 7789 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7790 
    except TransactionServiceException, ex:
7791 
      result.ex = ex
4258 rajveer 7792 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
4259 anupam.sin 7797 
  def process_refundTransaction(self, seqid, iprot, oprot):
7798 
    args = refundTransaction_args()
7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
7801 
    result = refundTransaction_result()
7802 
    try:
7803 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7804 
    except TransactionServiceException, ex:
7805 
      result.ex = ex
7806 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
4247 rajveer 7810 
 
4324 mandeep.dh 7811 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7812 
    args = updateShipmentAddress_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = updateShipmentAddress_result()
7816 
    try:
7817 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7818 
    except TransactionServiceException, ex:
7819 
      result.ex = ex
7820 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
7824 
 
4285 rajveer 7825 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7826 
    args = acceptOrdersForItemId_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = acceptOrdersForItemId_result()
7830 
    try:
7831 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7832 
    except TransactionServiceException, ex:
7833 
      result.ex = ex
7834 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
4259 anupam.sin 7838 
 
4303 rajveer 7839 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7840 
    args = markOrdersAsPORaised_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = markOrdersAsPORaised_result()
7844 
    try:
4369 rajveer 7845 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7846 
    except TransactionServiceException, ex:
7847 
      result.ex = ex
7848 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
4285 rajveer 7852 
 
4303 rajveer 7853 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7854 
    args = markOrdersAsReversalInitiated_args()
7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
7857 
    result = markOrdersAsReversalInitiated_result()
7858 
    try:
4369 rajveer 7859 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7860 
    except TransactionServiceException, ex:
7861 
      result.ex = ex
7862 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
7866 
 
7867 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7868 
    args = markOrdersAsNotAvailabke_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = markOrdersAsNotAvailabke_result()
7872 
    try:
4369 rajveer 7873 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7874 
    except TransactionServiceException, ex:
7875 
      result.ex = ex
7876 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
7880 
 
4369 rajveer 7881 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7882 
    args = markOrdersAsTimeout_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = markOrdersAsTimeout_result()
7886 
    try:
7887 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7888 
    except TransactionServiceException, ex:
7889 
      result.ex = ex
7890 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7891 
    result.write(oprot)
7892 
    oprot.writeMessageEnd()
7893 
    oprot.trans.flush()
4303 rajveer 7894 
 
4662 rajveer 7895 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7896 
    args = markOrderAsLostInTransit_args()
7897 
    args.read(iprot)
7898 
    iprot.readMessageEnd()
7899 
    result = markOrderAsLostInTransit_result()
7900 
    try:
7901 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7902 
    except TransactionServiceException, ex:
7903 
      result.ex = ex
7904 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7905 
    result.write(oprot)
7906 
    oprot.writeMessageEnd()
7907 
    oprot.trans.flush()
7908 
 
4386 anupam.sin 7909 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7910 
    args = getOrderForAwb_args()
7911 
    args.read(iprot)
7912 
    iprot.readMessageEnd()
7913 
    result = getOrderForAwb_result()
7914 
    try:
7915 
      result.success = self._handler.getOrderForAwb(args.awb)
7916 
    except TransactionServiceException, ex:
7917 
      result.ex = ex
7918 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7919 
    result.write(oprot)
7920 
    oprot.writeMessageEnd()
7921 
    oprot.trans.flush()
4369 rajveer 7922 
 
4506 phani.kuma 7923 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7924 
    args = getOrdersForProviderForStatus_args()
7925 
    args.read(iprot)
7926 
    iprot.readMessageEnd()
7927 
    result = getOrdersForProviderForStatus_result()
7928 
    try:
4910 phani.kuma 7929 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7930 
    except TransactionServiceException, ex:
7931 
      result.ex = ex
7932 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7933 
    result.write(oprot)
7934 
    oprot.writeMessageEnd()
7935 
    oprot.trans.flush()
4386 anupam.sin 7936 
 
4600 varun.gupt 7937 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7938 
    args = getBilledOrdersForVendor_args()
7939 
    args.read(iprot)
7940 
    iprot.readMessageEnd()
7941 
    result = getBilledOrdersForVendor_result()
7942 
    try:
7943 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7944 
    except TransactionServiceException, ex:
7945 
      result.ex = ex
7946 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
4506 phani.kuma 7950 
 
4607 rajveer 7951 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7952 
    args = getSlippedSippingDateOrders_args()
7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
7955 
    result = getSlippedSippingDateOrders_result()
7956 
    try:
7957 
      result.success = self._handler.getSlippedSippingDateOrders()
7958 
    except TransactionServiceException, ex:
7959 
      result.ex = ex
7960 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
7964 
 
4709 rajveer 7965 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7966 
    args = getCancelledOrders_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = getCancelledOrders_result()
7970 
    try:
7971 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7972 
    except TransactionServiceException, ex:
7973 
      result.ex = ex
7974 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
4600 varun.gupt 7979 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7980 
    args = saveBluedartSettlements_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = saveBluedartSettlements_result()
7984 
    try:
7985 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7986 
    except TransactionServiceException, ex:
7987 
      result.ex = ex
7988 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7989 
    result.write(oprot)
7990 
    oprot.writeMessageEnd()
7991 
    oprot.trans.flush()
7992 
 
7993 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7994 
    args = savePaymentSettlements_args()
7995 
    args.read(iprot)
7996 
    iprot.readMessageEnd()
7997 
    result = savePaymentSettlements_result()
7998 
    try:
4905 varun.gupt 7999 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8000 
    except TransactionServiceException, ex:
8001 
      result.ex = ex
8002 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8003 
    result.write(oprot)
8004 
    oprot.writeMessageEnd()
8005 
    oprot.trans.flush()
8006 
 
8007 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8008 
    args = saveEBSSettlementSummary_args()
8009 
    args.read(iprot)
8010 
    iprot.readMessageEnd()
8011 
    result = saveEBSSettlementSummary_result()
8012 
    try:
8013 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8014 
    except TransactionServiceException, ex:
8015 
      result.ex = ex
8016 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8017 
    result.write(oprot)
8018 
    oprot.writeMessageEnd()
8019 
    oprot.trans.flush()
8020 
 
5386 phani.kuma 8021 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8022 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8023 
    args.read(iprot)
8024 
    iprot.readMessageEnd()
5386 phani.kuma 8025 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8026 
    try:
5386 phani.kuma 8027 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8028 
    except TransactionServiceException, ex:
8029 
      result.ex = ex
5386 phani.kuma 8030 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8031 
    result.write(oprot)
8032 
    oprot.writeMessageEnd()
8033 
    oprot.trans.flush()
8034 
 
5386 phani.kuma 8035 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8036 
    args = getSettlementForCod_args()
8037 
    args.read(iprot)
8038 
    iprot.readMessageEnd()
8039 
    result = getSettlementForCod_result()
8040 
    try:
8041 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8042 
    except TransactionServiceException, ex:
8043 
      result.ex = ex
8044 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8045 
    result.write(oprot)
8046 
    oprot.writeMessageEnd()
8047 
    oprot.trans.flush()
8048 
 
4600 varun.gupt 8049 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8050 
    args = getEBSSettlementSummaries_args()
8051 
    args.read(iprot)
8052 
    iprot.readMessageEnd()
8053 
    result = getEBSSettlementSummaries_result()
8054 
    try:
8055 
      result.success = self._handler.getEBSSettlementSummaries()
8056 
    except TransactionServiceException, ex:
8057 
      result.ex = ex
8058 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8059 
    result.write(oprot)
8060 
    oprot.writeMessageEnd()
8061 
    oprot.trans.flush()
8062 
 
8063 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8064 
    args = markEBSSettlementUploaded_args()
8065 
    args.read(iprot)
8066 
    iprot.readMessageEnd()
8067 
    result = markEBSSettlementUploaded_result()
8068 
    try:
8069 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8070 
    except TransactionServiceException, ex:
8071 
      result.ex = ex
8072 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8073 
    result.write(oprot)
8074 
    oprot.writeMessageEnd()
8075 
    oprot.trans.flush()
8076 
 
8077 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8078 
    args = getEBSSettlementDate_args()
8079 
    args.read(iprot)
8080 
    iprot.readMessageEnd()
8081 
    result = getEBSSettlementDate_result()
8082 
    try:
8083 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8084 
    except TransactionServiceException, ex:
8085 
      result.ex = ex
8086 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8087 
    result.write(oprot)
8088 
    oprot.writeMessageEnd()
8089 
    oprot.trans.flush()
8090 
 
4715 varun.gupt 8091 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8092 
    args = getSettlementsByDate_args()
8093 
    args.read(iprot)
8094 
    iprot.readMessageEnd()
8095 
    result = getSettlementsByDate_result()
8096 
    try:
8097 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8098 
    except TransactionServiceException, ex:
8099 
      result.ex = ex
8100 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8101 
    result.write(oprot)
8102 
    oprot.writeMessageEnd()
8103 
    oprot.trans.flush()
4600 varun.gupt 8104 
 
4715 varun.gupt 8105 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8106 
    args = getReshippedOrderIds_args()
8107 
    args.read(iprot)
8108 
    iprot.readMessageEnd()
8109 
    result = getReshippedOrderIds_result()
8110 
    try:
8111 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8112 
    except TransactionServiceException, ex:
8113 
      result.ex = ex
8114 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8115 
    result.write(oprot)
8116 
    oprot.writeMessageEnd()
8117 
    oprot.trans.flush()
8118 
 
5481 phani.kuma 8119 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8120 
    args = getBilledOrders_args()
4875 varun.gupt 8121 
    args.read(iprot)
8122 
    iprot.readMessageEnd()
5481 phani.kuma 8123 
    result = getBilledOrders_result()
4875 varun.gupt 8124 
    try:
5481 phani.kuma 8125 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8126 
    except TransactionServiceException, ex:
8127 
      result.ex = ex
5481 phani.kuma 8128 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8129 
    result.write(oprot)
8130 
    oprot.writeMessageEnd()
8131 
    oprot.trans.flush()
4757 mandeep.dh 8132 
 
5031 varun.gupt 8133 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8134 
    args = getStatusDistributionOfOrders_args()
8135 
    args.read(iprot)
8136 
    iprot.readMessageEnd()
8137 
    result = getStatusDistributionOfOrders_result()
8138 
    try:
8139 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8140 
    except TransactionServiceException, ex:
8141 
      result.ex = ex
8142 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8143 
    result.write(oprot)
8144 
    oprot.writeMessageEnd()
8145 
    oprot.trans.flush()
4875 varun.gupt 8146 
 
5067 varun.gupt 8147 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8148 
    args = getOrderIdsForStatus_args()
8149 
    args.read(iprot)
8150 
    iprot.readMessageEnd()
8151 
    result = getOrderIdsForStatus_result()
8152 
    try:
8153 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8154 
    except TransactionServiceException, ex:
8155 
      result.ex = ex
8156 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8157 
    result.write(oprot)
8158 
    oprot.writeMessageEnd()
8159 
    oprot.trans.flush()
5031 varun.gupt 8160 
 
5348 anupam.sin 8161 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8162 
    args = updateCODAgent_args()
8163 
    args.read(iprot)
8164 
    iprot.readMessageEnd()
8165 
    result = updateCODAgent_result()
8166 
    try:
8167 
      self._handler.updateCODAgent(args.agent, args.orderId)
8168 
    except TransactionServiceException, ex:
8169 
      result.ex = ex
8170 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8171 
    result.write(oprot)
8172 
    oprot.writeMessageEnd()
8173 
    oprot.trans.flush()
8174 
 
5099 varun.gupt 8175 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8176 
    args = updateOrderAsPaidToVendor_args()
8177 
    args.read(iprot)
8178 
    iprot.readMessageEnd()
8179 
    result = updateOrderAsPaidToVendor_result()
8180 
    try:
8181 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8182 
    except TransactionServiceException, ex:
8183 
      result.ex = ex
8184 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8185 
    result.write(oprot)
8186 
    oprot.writeMessageEnd()
8187 
    oprot.trans.flush()
5067 varun.gupt 8188 
 
5386 phani.kuma 8189 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8190 
    args = updateOrderOnlyAsPaidToVendor_args()
8191 
    args.read(iprot)
8192 
    iprot.readMessageEnd()
8193 
    result = updateOrderOnlyAsPaidToVendor_result()
8194 
    try:
8195 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8196 
    except TransactionServiceException, ex:
8197 
      result.ex = ex
8198 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8199 
    result.write(oprot)
8200 
    oprot.writeMessageEnd()
8201 
    oprot.trans.flush()
8202 
 
5208 varun.gupt 8203 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8204 
    args = getRefundedOrdersMarkedPaid_args()
8205 
    args.read(iprot)
8206 
    iprot.readMessageEnd()
8207 
    result = getRefundedOrdersMarkedPaid_result()
8208 
    try:
8209 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8210 
    except TransactionServiceException, ex:
8211 
      result.ex = ex
8212 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8213 
    result.write(oprot)
8214 
    oprot.writeMessageEnd()
8215 
    oprot.trans.flush()
5099 varun.gupt 8216 
 
5447 anupam.sin 8217 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8218 
    args = getAllVerificationAgents_args()
8219 
    args.read(iprot)
8220 
    iprot.readMessageEnd()
8221 
    result = getAllVerificationAgents_result()
8222 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8223 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8224 
    result.write(oprot)
8225 
    oprot.writeMessageEnd()
8226 
    oprot.trans.flush()
5208 varun.gupt 8227 
 
5527 anupam.sin 8228 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8229 
    args = getAllAttributesForOrderId_args()
8230 
    args.read(iprot)
8231 
    iprot.readMessageEnd()
8232 
    result = getAllAttributesForOrderId_result()
8233 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8234 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8235 
    result.write(oprot)
8236 
    oprot.writeMessageEnd()
8237 
    oprot.trans.flush()
5447 anupam.sin 8238 
 
5676 rajveer 8239 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8240 
    args = setOrderAttributes_args()
8241 
    args.read(iprot)
8242 
    iprot.readMessageEnd()
8243 
    result = setOrderAttributes_result()
8244 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8245 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8246 
    result.write(oprot)
8247 
    oprot.writeMessageEnd()
8248 
    oprot.trans.flush()
8249 
 
5527 anupam.sin 8250 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8251 
    args = setOrderAttributeForTransaction_args()
8252 
    args.read(iprot)
8253 
    iprot.readMessageEnd()
8254 
    result = setOrderAttributeForTransaction_result()
8255 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8256 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8257 
    result.write(oprot)
8258 
    oprot.writeMessageEnd()
8259 
    oprot.trans.flush()
8260 
 
5553 rajveer 8261 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8262 
    args = getReceivePendingOrders_args()
8263 
    args.read(iprot)
8264 
    iprot.readMessageEnd()
8265 
    result = getReceivePendingOrders_result()
8266 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8267 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8268 
    result.write(oprot)
8269 
    oprot.writeMessageEnd()
8270 
    oprot.trans.flush()
5527 anupam.sin 8271 
 
5553 rajveer 8272 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8273 
    args = getReceivedAtStoreOrders_args()
8274 
    args.read(iprot)
8275 
    iprot.readMessageEnd()
8276 
    result = getReceivedAtStoreOrders_result()
8277 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8278 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8279 
    result.write(oprot)
8280 
    oprot.writeMessageEnd()
8281 
    oprot.trans.flush()
8282 
 
5713 rajveer 8283 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8284 
    args = getOrdersCollectionAtStore_args()
8285 
    args.read(iprot)
8286 
    iprot.readMessageEnd()
8287 
    result = getOrdersCollectionAtStore_result()
8288 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8289 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8290 
    result.write(oprot)
8291 
    oprot.writeMessageEnd()
8292 
    oprot.trans.flush()
8293 
 
5833 rajveer 8294 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8295 
    args = getOrderAttributeValue_args()
8296 
    args.read(iprot)
8297 
    iprot.readMessageEnd()
8298 
    result = getOrderAttributeValue_result()
8299 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8300 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8301 
    result.write(oprot)
8302 
    oprot.writeMessageEnd()
8303 
    oprot.trans.flush()
8304 
 
6019 rajveer 8305 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8306 
    args = changeJacketNumber_args()
8307 
    args.read(iprot)
8308 
    iprot.readMessageEnd()
8309 
    result = changeJacketNumber_result()
8310 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8311 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8312 
    result.write(oprot)
8313 
    oprot.writeMessageEnd()
8314 
    oprot.trans.flush()
8315 
 
8316 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8317 
    args = markOrderAsRtoInTransit_args()
8318 
    args.read(iprot)
8319 
    iprot.readMessageEnd()
8320 
    result = markOrderAsRtoInTransit_result()
8321 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8322 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8323 
    result.write(oprot)
8324 
    oprot.writeMessageEnd()
8325 
    oprot.trans.flush()
8326 
 
5593 mandeep.dh 8327 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8328 
    args = acceptOrderForItem_args()
8329 
    args.read(iprot)
8330 
    iprot.readMessageEnd()
8331 
    result = acceptOrderForItem_result()
8332 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8333 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8334 
    result.write(oprot)
8335 
    oprot.writeMessageEnd()
8336 
    oprot.trans.flush()
5553 rajveer 8337 
 
6000 mandeep.dh 8338 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8339 
    args = createRechargeOrder_args()
8340 
    args.read(iprot)
8341 
    iprot.readMessageEnd()
8342 
    result = createRechargeOrder_result()
8343 
    try:
8344 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8345 
    except TransactionServiceException, ex:
8346 
      result.ex = ex
8347 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8348 
    result.write(oprot)
8349 
    oprot.writeMessageEnd()
8350 
    oprot.trans.flush()
5593 mandeep.dh 8351 
 
6031 rajveer 8352 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8353 
    args = getRechargeOrder_args()
8354 
    args.read(iprot)
8355 
    iprot.readMessageEnd()
8356 
    result = getRechargeOrder_result()
8357 
    try:
8358 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8359 
    except TransactionServiceException, ex:
8360 
      result.ex = ex
8361 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8362 
    result.write(oprot)
8363 
    oprot.writeMessageEnd()
8364 
    oprot.trans.flush()
8365 
 
8366 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8367 
    args = getRechargeOrders_args()
8368 
    args.read(iprot)
8369 
    iprot.readMessageEnd()
8370 
    result = getRechargeOrders_result()
8371 
    result.success = self._handler.getRechargeOrders(args.userId)
8372 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8373 
    result.write(oprot)
8374 
    oprot.writeMessageEnd()
8375 
    oprot.trans.flush()
8376 
 
6000 mandeep.dh 8377 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8378 
    args = updateRechargeOrderStatus_args()
8379 
    args.read(iprot)
8380 
    iprot.readMessageEnd()
8381 
    result = updateRechargeOrderStatus_result()
8382 
    try:
6031 rajveer 8383 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8384 
    except TransactionServiceException, ex:
8385 
      result.ex = ex
8386 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8387 
    result.write(oprot)
8388 
    oprot.writeMessageEnd()
8389 
    oprot.trans.flush()
8390 
 
8391 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8392 
    args = activateRechargeTxn_args()
8393 
    args.read(iprot)
8394 
    iprot.readMessageEnd()
8395 
    result = activateRechargeTxn_result()
8396 
    try:
6031 rajveer 8397 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8398 
    except TransactionServiceException, ex:
8399 
      result.ex = ex
8400 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8401 
    result.write(oprot)
8402 
    oprot.writeMessageEnd()
8403 
    oprot.trans.flush()
8404 
 
6031 rajveer 8405 
  def process_getUserWallet(self, seqid, iprot, oprot):
8406 
    args = getUserWallet_args()
6000 mandeep.dh 8407 
    args.read(iprot)
8408 
    iprot.readMessageEnd()
6031 rajveer 8409 
    result = getUserWallet_result()
8410 
    result.success = self._handler.getUserWallet(args.userId)
8411 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8412 
    result.write(oprot)
8413 
    oprot.writeMessageEnd()
8414 
    oprot.trans.flush()
8415 
 
6031 rajveer 8416 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8417 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8418 
    args.read(iprot)
8419 
    iprot.readMessageEnd()
6031 rajveer 8420 
    result = getUserWalletHistory_result()
8421 
    result.success = self._handler.getUserWalletHistory(args.userId)
8422 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8423 
    result.write(oprot)
8424 
    oprot.writeMessageEnd()
8425 
    oprot.trans.flush()
8426 
 
6050 anupam.sin 8427 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8428 
    args = getRechargeOrdersForTransaction_args()
8429 
    args.read(iprot)
8430 
    iprot.readMessageEnd()
8431 
    result = getRechargeOrdersForTransaction_result()
8432 
    try:
8433 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8434 
    except TransactionServiceException, ex:
8435 
      result.ex = ex
8436 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8437 
    result.write(oprot)
8438 
    oprot.writeMessageEnd()
8439 
    oprot.trans.flush()
8440 
 
6048 rajveer 8441 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8442 
    args = getServiceProviders_args()
8443 
    args.read(iprot)
8444 
    iprot.readMessageEnd()
8445 
    result = getServiceProviders_result()
6206 rajveer 8446 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8447 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8448 
    result.write(oprot)
8449 
    oprot.writeMessageEnd()
8450 
    oprot.trans.flush()
6000 mandeep.dh 8451 
 
6048 rajveer 8452 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8453 
    args = getServiceProviderForDevice_args()
8454 
    args.read(iprot)
8455 
    iprot.readMessageEnd()
8456 
    result = getServiceProviderForDevice_result()
6049 rajveer 8457 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8458 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8459 
    result.write(oprot)
8460 
    oprot.writeMessageEnd()
8461 
    oprot.trans.flush()
8462 
 
6269 rajveer 8463 
  def process_validateRecharge(self, seqid, iprot, oprot):
8464 
    args = validateRecharge_args()
8465 
    args.read(iprot)
8466 
    iprot.readMessageEnd()
8467 
    result = validateRecharge_result()
6336 anupam.sin 8468 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId)
6269 rajveer 8469 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8470 
    result.write(oprot)
8471 
    oprot.writeMessageEnd()
8472 
    oprot.trans.flush()
8473 
 
6094 rajveer 8474 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8475 
    args = getRechargeOrdersForDevice_args()
8476 
    args.read(iprot)
8477 
    iprot.readMessageEnd()
8478 
    result = getRechargeOrdersForDevice_result()
8479 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8480 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8481 
    result.write(oprot)
8482 
    oprot.writeMessageEnd()
8483 
    oprot.trans.flush()
6048 rajveer 8484 
 
6094 rajveer 8485 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8486 
    args = addAmountToWallet_args()
8487 
    args.read(iprot)
8488 
    iprot.readMessageEnd()
8489 
    result = addAmountToWallet_result()
8490 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8491 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8492 
    result.write(oprot)
8493 
    oprot.writeMessageEnd()
8494 
    oprot.trans.flush()
8495 
 
6188 rajveer 8496 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8497 
    args = getRechargeStatistics_args()
8498 
    args.read(iprot)
8499 
    iprot.readMessageEnd()
8500 
    result = getRechargeStatistics_result()
8501 
    result.success = self._handler.getRechargeStatistics()
8502 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8503 
    result.write(oprot)
8504 
    oprot.writeMessageEnd()
8505 
    oprot.trans.flush()
8506 
 
6154 rajveer 8507 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8508 
    args = getRechargeOrdersForStatus_args()
8509 
    args.read(iprot)
8510 
    iprot.readMessageEnd()
8511 
    result = getRechargeOrdersForStatus_result()
8512 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8513 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8514 
    result.write(oprot)
8515 
    oprot.writeMessageEnd()
8516 
    oprot.trans.flush()
6094 rajveer 8517 
 
6159 rajveer 8518 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8519 
    args = getPlansForOperator_args()
8520 
    args.read(iprot)
8521 
    iprot.readMessageEnd()
8522 
    result = getPlansForOperator_result()
8523 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8524 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8525 
    result.write(oprot)
8526 
    oprot.writeMessageEnd()
8527 
    oprot.trans.flush()
6154 rajveer 8528 
 
6289 anupam.sin 8529 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8530 
    args = getRechargeDenominations_args()
8531 
    args.read(iprot)
8532 
    iprot.readMessageEnd()
8533 
    result = getRechargeDenominations_result()
8534 
    try:
6307 anupam.sin 8535 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8536 
    except TransactionServiceException, ex:
8537 
      result.ex = ex
8538 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8539 
    result.write(oprot)
8540 
    oprot.writeMessageEnd()
8541 
    oprot.trans.flush()
6159 rajveer 8542 
 
6371 rajveer 8543 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8544 
    args = updateAvailabilityStatus_args()
8545 
    args.read(iprot)
8546 
    iprot.readMessageEnd()
8547 
    result = updateAvailabilityStatus_result()
8548 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8549 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8550 
    result.write(oprot)
8551 
    oprot.writeMessageEnd()
8552 
    oprot.trans.flush()
6289 anupam.sin 8553 
 
6389 rajveer 8554 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8555 
    args = getAvailableEmiSchemes_args()
8556 
    args.read(iprot)
8557 
    iprot.readMessageEnd()
8558 
    result = getAvailableEmiSchemes_result()
8559 
    result.success = self._handler.getAvailableEmiSchemes()
8560 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8561 
    result.write(oprot)
8562 
    oprot.writeMessageEnd()
8563 
    oprot.trans.flush()
6371 rajveer 8564 
 
6389 rajveer 8565 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8566 
    args = getMiscCharges_args()
8567 
    args.read(iprot)
8568 
    iprot.readMessageEnd()
8569 
    result = getMiscCharges_result()
8570 
    result.success = self._handler.getMiscCharges(args.transactionId)
8571 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8572 
    result.write(oprot)
8573 
    oprot.writeMessageEnd()
8574 
    oprot.trans.flush()
8575 
 
8576 
 
94 ashish 8577 
# HELPER FUNCTIONS AND STRUCTURES
8578 
 
8579 
class createTransaction_args:
8580 
  """
8581 
  Attributes:
8582 
   - transaction
8583 
  """
8584 
 
8585 
  thrift_spec = (
8586 
    None, # 0
8587 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8588 
  )
8589 
 
8590 
  def __init__(self, transaction=None,):
8591 
    self.transaction = transaction
8592 
 
8593 
  def read(self, iprot):
8594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8596 
      return
8597 
    iprot.readStructBegin()
8598 
    while True:
8599 
      (fname, ftype, fid) = iprot.readFieldBegin()
8600 
      if ftype == TType.STOP:
8601 
        break
8602 
      if fid == 1:
8603 
        if ftype == TType.STRUCT:
8604 
          self.transaction = Transaction()
8605 
          self.transaction.read(iprot)
8606 
        else:
8607 
          iprot.skip(ftype)
8608 
      else:
8609 
        iprot.skip(ftype)
8610 
      iprot.readFieldEnd()
8611 
    iprot.readStructEnd()
8612 
 
8613 
  def write(self, oprot):
8614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8616 
      return
8617 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8618 
    if self.transaction is not None:
94 ashish 8619 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8620 
      self.transaction.write(oprot)
8621 
      oprot.writeFieldEnd()
8622 
    oprot.writeFieldStop()
8623 
    oprot.writeStructEnd()
8624 
 
3431 rajveer 8625 
  def validate(self):
8626 
    return
8627 
 
8628 
 
94 ashish 8629 
  def __repr__(self):
8630 
    L = ['%s=%r' % (key, value)
8631 
      for key, value in self.__dict__.iteritems()]
8632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8633 
 
8634 
  def __eq__(self, other):
8635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8636 
 
8637 
  def __ne__(self, other):
8638 
    return not (self == other)
8639 
 
8640 
class createTransaction_result:
8641 
  """
8642 
  Attributes:
132 ashish 8643 
   - success
94 ashish 8644 
   - ex
8645 
  """
8646 
 
8647 
  thrift_spec = (
132 ashish 8648 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8650 
  )
8651 
 
132 ashish 8652 
  def __init__(self, success=None, ex=None,):
8653 
    self.success = success
94 ashish 8654 
    self.ex = ex
8655 
 
8656 
  def read(self, iprot):
8657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8659 
      return
8660 
    iprot.readStructBegin()
8661 
    while True:
8662 
      (fname, ftype, fid) = iprot.readFieldBegin()
8663 
      if ftype == TType.STOP:
8664 
        break
132 ashish 8665 
      if fid == 0:
8666 
        if ftype == TType.I64:
8667 
          self.success = iprot.readI64();
8668 
        else:
8669 
          iprot.skip(ftype)
8670 
      elif fid == 1:
94 ashish 8671 
        if ftype == TType.STRUCT:
8672 
          self.ex = TransactionServiceException()
8673 
          self.ex.read(iprot)
8674 
        else:
8675 
          iprot.skip(ftype)
8676 
      else:
8677 
        iprot.skip(ftype)
8678 
      iprot.readFieldEnd()
8679 
    iprot.readStructEnd()
8680 
 
8681 
  def write(self, oprot):
8682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8684 
      return
8685 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8686 
    if self.success is not None:
132 ashish 8687 
      oprot.writeFieldBegin('success', TType.I64, 0)
8688 
      oprot.writeI64(self.success)
8689 
      oprot.writeFieldEnd()
3431 rajveer 8690 
    if self.ex is not None:
94 ashish 8691 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8692 
      self.ex.write(oprot)
8693 
      oprot.writeFieldEnd()
8694 
    oprot.writeFieldStop()
8695 
    oprot.writeStructEnd()
8696 
 
3431 rajveer 8697 
  def validate(self):
8698 
    return
8699 
 
8700 
 
94 ashish 8701 
  def __repr__(self):
8702 
    L = ['%s=%r' % (key, value)
8703 
      for key, value in self.__dict__.iteritems()]
8704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8705 
 
8706 
  def __eq__(self, other):
8707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8708 
 
8709 
  def __ne__(self, other):
8710 
    return not (self == other)
8711 
 
8712 
class getTransaction_args:
8713 
  """
8714 
  Attributes:
8715 
   - id
8716 
  """
8717 
 
8718 
  thrift_spec = (
8719 
    None, # 0
8720 
    (1, TType.I64, 'id', None, None, ), # 1
8721 
  )
8722 
 
8723 
  def __init__(self, id=None,):
8724 
    self.id = id
8725 
 
8726 
  def read(self, iprot):
8727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8729 
      return
8730 
    iprot.readStructBegin()
8731 
    while True:
8732 
      (fname, ftype, fid) = iprot.readFieldBegin()
8733 
      if ftype == TType.STOP:
8734 
        break
8735 
      if fid == 1:
8736 
        if ftype == TType.I64:
8737 
          self.id = iprot.readI64();
8738 
        else:
8739 
          iprot.skip(ftype)
8740 
      else:
8741 
        iprot.skip(ftype)
8742 
      iprot.readFieldEnd()
8743 
    iprot.readStructEnd()
8744 
 
8745 
  def write(self, oprot):
8746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8748 
      return
8749 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8750 
    if self.id is not None:
94 ashish 8751 
      oprot.writeFieldBegin('id', TType.I64, 1)
8752 
      oprot.writeI64(self.id)
8753 
      oprot.writeFieldEnd()
8754 
    oprot.writeFieldStop()
8755 
    oprot.writeStructEnd()
8756 
 
3431 rajveer 8757 
  def validate(self):
8758 
    return
8759 
 
8760 
 
94 ashish 8761 
  def __repr__(self):
8762 
    L = ['%s=%r' % (key, value)
8763 
      for key, value in self.__dict__.iteritems()]
8764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8765 
 
8766 
  def __eq__(self, other):
8767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8768 
 
8769 
  def __ne__(self, other):
8770 
    return not (self == other)
8771 
 
8772 
class getTransaction_result:
8773 
  """
8774 
  Attributes:
8775 
   - success
8776 
   - ex
8777 
  """
8778 
 
8779 
  thrift_spec = (
8780 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8781 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8782 
  )
8783 
 
8784 
  def __init__(self, success=None, ex=None,):
8785 
    self.success = success
8786 
    self.ex = ex
8787 
 
8788 
  def read(self, iprot):
8789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8791 
      return
8792 
    iprot.readStructBegin()
8793 
    while True:
8794 
      (fname, ftype, fid) = iprot.readFieldBegin()
8795 
      if ftype == TType.STOP:
8796 
        break
8797 
      if fid == 0:
8798 
        if ftype == TType.STRUCT:
8799 
          self.success = Transaction()
8800 
          self.success.read(iprot)
8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      elif fid == 1:
8804 
        if ftype == TType.STRUCT:
8805 
          self.ex = TransactionServiceException()
8806 
          self.ex.read(iprot)
8807 
        else:
8808 
          iprot.skip(ftype)
8809 
      else:
8810 
        iprot.skip(ftype)
8811 
      iprot.readFieldEnd()
8812 
    iprot.readStructEnd()
8813 
 
8814 
  def write(self, oprot):
8815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8817 
      return
8818 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8819 
    if self.success is not None:
94 ashish 8820 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8821 
      self.success.write(oprot)
8822 
      oprot.writeFieldEnd()
3431 rajveer 8823 
    if self.ex is not None:
94 ashish 8824 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8825 
      self.ex.write(oprot)
8826 
      oprot.writeFieldEnd()
8827 
    oprot.writeFieldStop()
8828 
    oprot.writeStructEnd()
8829 
 
3431 rajveer 8830 
  def validate(self):
8831 
    return
8832 
 
8833 
 
94 ashish 8834 
  def __repr__(self):
8835 
    L = ['%s=%r' % (key, value)
8836 
      for key, value in self.__dict__.iteritems()]
8837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8838 
 
8839 
  def __eq__(self, other):
8840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8841 
 
8842 
  def __ne__(self, other):
8843 
    return not (self == other)
8844 
 
8845 
class getTransactionsForCustomer_args:
8846 
  """
8847 
  Attributes:
8848 
   - customerId
8849 
   - from_date
8850 
   - to_date
8851 
   - status
8852 
  """
8853 
 
8854 
  thrift_spec = (
8855 
    None, # 0
8856 
    (1, TType.I64, 'customerId', None, None, ), # 1
8857 
    (2, TType.I64, 'from_date', None, None, ), # 2
8858 
    (3, TType.I64, 'to_date', None, None, ), # 3
8859 
    (4, TType.I32, 'status', None, None, ), # 4
8860 
  )
8861 
 
8862 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8863 
    self.customerId = customerId
8864 
    self.from_date = from_date
8865 
    self.to_date = to_date
8866 
    self.status = status
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 == 1:
8878 
        if ftype == TType.I64:
8879 
          self.customerId = iprot.readI64();
8880 
        else:
8881 
          iprot.skip(ftype)
8882 
      elif fid == 2:
8883 
        if ftype == TType.I64:
8884 
          self.from_date = iprot.readI64();
8885 
        else:
8886 
          iprot.skip(ftype)
8887 
      elif fid == 3:
8888 
        if ftype == TType.I64:
8889 
          self.to_date = iprot.readI64();
8890 
        else:
8891 
          iprot.skip(ftype)
8892 
      elif fid == 4:
8893 
        if ftype == TType.I32:
8894 
          self.status = iprot.readI32();
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      else:
8898 
        iprot.skip(ftype)
8899 
      iprot.readFieldEnd()
8900 
    iprot.readStructEnd()
8901 
 
8902 
  def write(self, oprot):
8903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8905 
      return
8906 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8907 
    if self.customerId is not None:
94 ashish 8908 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8909 
      oprot.writeI64(self.customerId)
8910 
      oprot.writeFieldEnd()
3431 rajveer 8911 
    if self.from_date is not None:
94 ashish 8912 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8913 
      oprot.writeI64(self.from_date)
8914 
      oprot.writeFieldEnd()
3431 rajveer 8915 
    if self.to_date is not None:
94 ashish 8916 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8917 
      oprot.writeI64(self.to_date)
8918 
      oprot.writeFieldEnd()
3431 rajveer 8919 
    if self.status is not None:
94 ashish 8920 
      oprot.writeFieldBegin('status', TType.I32, 4)
8921 
      oprot.writeI32(self.status)
8922 
      oprot.writeFieldEnd()
8923 
    oprot.writeFieldStop()
8924 
    oprot.writeStructEnd()
8925 
 
3431 rajveer 8926 
  def validate(self):
8927 
    return
8928 
 
8929 
 
94 ashish 8930 
  def __repr__(self):
8931 
    L = ['%s=%r' % (key, value)
8932 
      for key, value in self.__dict__.iteritems()]
8933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8934 
 
8935 
  def __eq__(self, other):
8936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8937 
 
8938 
  def __ne__(self, other):
8939 
    return not (self == other)
8940 
 
8941 
class getTransactionsForCustomer_result:
8942 
  """
8943 
  Attributes:
8944 
   - success
8945 
   - ex
8946 
  """
8947 
 
8948 
  thrift_spec = (
8949 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8950 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8951 
  )
8952 
 
8953 
  def __init__(self, success=None, ex=None,):
8954 
    self.success = success
8955 
    self.ex = ex
8956 
 
8957 
  def read(self, iprot):
8958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8960 
      return
8961 
    iprot.readStructBegin()
8962 
    while True:
8963 
      (fname, ftype, fid) = iprot.readFieldBegin()
8964 
      if ftype == TType.STOP:
8965 
        break
8966 
      if fid == 0:
8967 
        if ftype == TType.LIST:
8968 
          self.success = []
6188 rajveer 8969 
          (_etype109, _size106) = iprot.readListBegin()
8970 
          for _i110 in xrange(_size106):
8971 
            _elem111 = Transaction()
8972 
            _elem111.read(iprot)
8973 
            self.success.append(_elem111)
94 ashish 8974 
          iprot.readListEnd()
8975 
        else:
8976 
          iprot.skip(ftype)
8977 
      elif fid == 1:
8978 
        if ftype == TType.STRUCT:
8979 
          self.ex = TransactionServiceException()
8980 
          self.ex.read(iprot)
8981 
        else:
8982 
          iprot.skip(ftype)
8983 
      else:
8984 
        iprot.skip(ftype)
8985 
      iprot.readFieldEnd()
8986 
    iprot.readStructEnd()
8987 
 
8988 
  def write(self, oprot):
8989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8991 
      return
8992 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8993 
    if self.success is not None:
94 ashish 8994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8996 
      for iter112 in self.success:
8997 
        iter112.write(oprot)
94 ashish 8998 
      oprot.writeListEnd()
8999 
      oprot.writeFieldEnd()
3431 rajveer 9000 
    if self.ex is not None:
94 ashish 9001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9002 
      self.ex.write(oprot)
9003 
      oprot.writeFieldEnd()
9004 
    oprot.writeFieldStop()
9005 
    oprot.writeStructEnd()
9006 
 
3431 rajveer 9007 
  def validate(self):
9008 
    return
9009 
 
9010 
 
94 ashish 9011 
  def __repr__(self):
9012 
    L = ['%s=%r' % (key, value)
9013 
      for key, value in self.__dict__.iteritems()]
9014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9015 
 
9016 
  def __eq__(self, other):
9017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9018 
 
9019 
  def __ne__(self, other):
9020 
    return not (self == other)
9021 
 
132 ashish 9022 
class getTransactionsForShoppingCartId_args:
9023 
  """
9024 
  Attributes:
9025 
   - shoppingCartId
9026 
  """
9027 
 
9028 
  thrift_spec = (
9029 
    None, # 0
9030 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9031 
  )
9032 
 
9033 
  def __init__(self, shoppingCartId=None,):
9034 
    self.shoppingCartId = shoppingCartId
9035 
 
9036 
  def read(self, iprot):
9037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9039 
      return
9040 
    iprot.readStructBegin()
9041 
    while True:
9042 
      (fname, ftype, fid) = iprot.readFieldBegin()
9043 
      if ftype == TType.STOP:
9044 
        break
9045 
      if fid == 1:
9046 
        if ftype == TType.I64:
9047 
          self.shoppingCartId = iprot.readI64();
9048 
        else:
9049 
          iprot.skip(ftype)
9050 
      else:
9051 
        iprot.skip(ftype)
9052 
      iprot.readFieldEnd()
9053 
    iprot.readStructEnd()
9054 
 
9055 
  def write(self, oprot):
9056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9058 
      return
9059 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9060 
    if self.shoppingCartId is not None:
132 ashish 9061 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9062 
      oprot.writeI64(self.shoppingCartId)
9063 
      oprot.writeFieldEnd()
9064 
    oprot.writeFieldStop()
9065 
    oprot.writeStructEnd()
9066 
 
3431 rajveer 9067 
  def validate(self):
9068 
    return
9069 
 
9070 
 
132 ashish 9071 
  def __repr__(self):
9072 
    L = ['%s=%r' % (key, value)
9073 
      for key, value in self.__dict__.iteritems()]
9074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9075 
 
9076 
  def __eq__(self, other):
9077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9078 
 
9079 
  def __ne__(self, other):
9080 
    return not (self == other)
9081 
 
9082 
class getTransactionsForShoppingCartId_result:
9083 
  """
9084 
  Attributes:
9085 
   - success
9086 
   - ex
9087 
  """
9088 
 
9089 
  thrift_spec = (
9090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9092 
  )
9093 
 
9094 
  def __init__(self, success=None, ex=None,):
9095 
    self.success = success
9096 
    self.ex = ex
9097 
 
9098 
  def read(self, iprot):
9099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9101 
      return
9102 
    iprot.readStructBegin()
9103 
    while True:
9104 
      (fname, ftype, fid) = iprot.readFieldBegin()
9105 
      if ftype == TType.STOP:
9106 
        break
9107 
      if fid == 0:
9108 
        if ftype == TType.LIST:
9109 
          self.success = []
6188 rajveer 9110 
          (_etype116, _size113) = iprot.readListBegin()
9111 
          for _i117 in xrange(_size113):
9112 
            _elem118 = Transaction()
9113 
            _elem118.read(iprot)
9114 
            self.success.append(_elem118)
132 ashish 9115 
          iprot.readListEnd()
9116 
        else:
9117 
          iprot.skip(ftype)
9118 
      elif fid == 1:
9119 
        if ftype == TType.STRUCT:
9120 
          self.ex = TransactionServiceException()
9121 
          self.ex.read(iprot)
9122 
        else:
9123 
          iprot.skip(ftype)
9124 
      else:
9125 
        iprot.skip(ftype)
9126 
      iprot.readFieldEnd()
9127 
    iprot.readStructEnd()
9128 
 
9129 
  def write(self, oprot):
9130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9132 
      return
9133 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9134 
    if self.success is not None:
132 ashish 9135 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9136 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9137 
      for iter119 in self.success:
9138 
        iter119.write(oprot)
132 ashish 9139 
      oprot.writeListEnd()
9140 
      oprot.writeFieldEnd()
3431 rajveer 9141 
    if self.ex is not None:
132 ashish 9142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9143 
      self.ex.write(oprot)
9144 
      oprot.writeFieldEnd()
9145 
    oprot.writeFieldStop()
9146 
    oprot.writeStructEnd()
9147 
 
3431 rajveer 9148 
  def validate(self):
9149 
    return
9150 
 
9151 
 
132 ashish 9152 
  def __repr__(self):
9153 
    L = ['%s=%r' % (key, value)
9154 
      for key, value in self.__dict__.iteritems()]
9155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9156 
 
9157 
  def __eq__(self, other):
9158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9159 
 
9160 
  def __ne__(self, other):
9161 
    return not (self == other)
9162 
 
94 ashish 9163 
class getTransactionStatus_args:
9164 
  """
9165 
  Attributes:
9166 
   - transactionId
9167 
  """
9168 
 
9169 
  thrift_spec = (
9170 
    None, # 0
9171 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9172 
  )
9173 
 
9174 
  def __init__(self, transactionId=None,):
9175 
    self.transactionId = transactionId
9176 
 
9177 
  def read(self, iprot):
9178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9180 
      return
9181 
    iprot.readStructBegin()
9182 
    while True:
9183 
      (fname, ftype, fid) = iprot.readFieldBegin()
9184 
      if ftype == TType.STOP:
9185 
        break
9186 
      if fid == 1:
9187 
        if ftype == TType.I64:
9188 
          self.transactionId = iprot.readI64();
9189 
        else:
9190 
          iprot.skip(ftype)
9191 
      else:
9192 
        iprot.skip(ftype)
9193 
      iprot.readFieldEnd()
9194 
    iprot.readStructEnd()
9195 
 
9196 
  def write(self, oprot):
9197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9199 
      return
9200 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9201 
    if self.transactionId is not None:
94 ashish 9202 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9203 
      oprot.writeI64(self.transactionId)
9204 
      oprot.writeFieldEnd()
9205 
    oprot.writeFieldStop()
9206 
    oprot.writeStructEnd()
9207 
 
3431 rajveer 9208 
  def validate(self):
9209 
    return
9210 
 
9211 
 
94 ashish 9212 
  def __repr__(self):
9213 
    L = ['%s=%r' % (key, value)
9214 
      for key, value in self.__dict__.iteritems()]
9215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9216 
 
9217 
  def __eq__(self, other):
9218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9219 
 
9220 
  def __ne__(self, other):
9221 
    return not (self == other)
9222 
 
9223 
class getTransactionStatus_result:
9224 
  """
9225 
  Attributes:
9226 
   - success
9227 
   - ex
9228 
  """
9229 
 
9230 
  thrift_spec = (
9231 
    (0, TType.I32, 'success', None, None, ), # 0
9232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9233 
  )
9234 
 
9235 
  def __init__(self, success=None, ex=None,):
9236 
    self.success = success
9237 
    self.ex = ex
9238 
 
9239 
  def read(self, iprot):
9240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9242 
      return
9243 
    iprot.readStructBegin()
9244 
    while True:
9245 
      (fname, ftype, fid) = iprot.readFieldBegin()
9246 
      if ftype == TType.STOP:
9247 
        break
9248 
      if fid == 0:
9249 
        if ftype == TType.I32:
9250 
          self.success = iprot.readI32();
9251 
        else:
9252 
          iprot.skip(ftype)
9253 
      elif fid == 1:
9254 
        if ftype == TType.STRUCT:
9255 
          self.ex = TransactionServiceException()
9256 
          self.ex.read(iprot)
9257 
        else:
9258 
          iprot.skip(ftype)
9259 
      else:
9260 
        iprot.skip(ftype)
9261 
      iprot.readFieldEnd()
9262 
    iprot.readStructEnd()
9263 
 
9264 
  def write(self, oprot):
9265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9267 
      return
9268 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9269 
    if self.success is not None:
94 ashish 9270 
      oprot.writeFieldBegin('success', TType.I32, 0)
9271 
      oprot.writeI32(self.success)
9272 
      oprot.writeFieldEnd()
3431 rajveer 9273 
    if self.ex is not None:
94 ashish 9274 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9275 
      self.ex.write(oprot)
9276 
      oprot.writeFieldEnd()
9277 
    oprot.writeFieldStop()
9278 
    oprot.writeStructEnd()
9279 
 
3431 rajveer 9280 
  def validate(self):
9281 
    return
9282 
 
9283 
 
94 ashish 9284 
  def __repr__(self):
9285 
    L = ['%s=%r' % (key, value)
9286 
      for key, value in self.__dict__.iteritems()]
9287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9288 
 
9289 
  def __eq__(self, other):
9290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9291 
 
9292 
  def __ne__(self, other):
9293 
    return not (self == other)
9294 
 
9295 
class changeTransactionStatus_args:
9296 
  """
9297 
  Attributes:
9298 
   - transactionId
9299 
   - status
9300 
   - description
5527 anupam.sin 9301 
   - pickUp
9302 
   - orderType
94 ashish 9303 
  """
9304 
 
9305 
  thrift_spec = (
9306 
    None, # 0
9307 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9308 
    (2, TType.I32, 'status', None, None, ), # 2
9309 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9310 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9311 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9312 
  )
9313 
 
5527 anupam.sin 9314 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9315 
    self.transactionId = transactionId
9316 
    self.status = status
9317 
    self.description = description
5527 anupam.sin 9318 
    self.pickUp = pickUp
9319 
    self.orderType = orderType
94 ashish 9320 
 
9321 
  def read(self, iprot):
9322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9324 
      return
9325 
    iprot.readStructBegin()
9326 
    while True:
9327 
      (fname, ftype, fid) = iprot.readFieldBegin()
9328 
      if ftype == TType.STOP:
9329 
        break
9330 
      if fid == 1:
9331 
        if ftype == TType.I64:
9332 
          self.transactionId = iprot.readI64();
9333 
        else:
9334 
          iprot.skip(ftype)
9335 
      elif fid == 2:
9336 
        if ftype == TType.I32:
9337 
          self.status = iprot.readI32();
9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      elif fid == 3:
9341 
        if ftype == TType.STRING:
9342 
          self.description = iprot.readString();
9343 
        else:
9344 
          iprot.skip(ftype)
5387 rajveer 9345 
      elif fid == 4:
5527 anupam.sin 9346 
        if ftype == TType.I64:
9347 
          self.pickUp = iprot.readI64();
5387 rajveer 9348 
        else:
9349 
          iprot.skip(ftype)
5527 anupam.sin 9350 
      elif fid == 5:
9351 
        if ftype == TType.I32:
9352 
          self.orderType = iprot.readI32();
9353 
        else:
9354 
          iprot.skip(ftype)
94 ashish 9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9365 
    if self.transactionId is not None:
94 ashish 9366 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9367 
      oprot.writeI64(self.transactionId)
9368 
      oprot.writeFieldEnd()
3431 rajveer 9369 
    if self.status is not None:
94 ashish 9370 
      oprot.writeFieldBegin('status', TType.I32, 2)
9371 
      oprot.writeI32(self.status)
9372 
      oprot.writeFieldEnd()
3431 rajveer 9373 
    if self.description is not None:
94 ashish 9374 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9375 
      oprot.writeString(self.description)
9376 
      oprot.writeFieldEnd()
5527 anupam.sin 9377 
    if self.pickUp is not None:
9378 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9379 
      oprot.writeI64(self.pickUp)
5387 rajveer 9380 
      oprot.writeFieldEnd()
5527 anupam.sin 9381 
    if self.orderType is not None:
9382 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9383 
      oprot.writeI32(self.orderType)
9384 
      oprot.writeFieldEnd()
94 ashish 9385 
    oprot.writeFieldStop()
9386 
    oprot.writeStructEnd()
9387 
 
3431 rajveer 9388 
  def validate(self):
9389 
    return
9390 
 
9391 
 
94 ashish 9392 
  def __repr__(self):
9393 
    L = ['%s=%r' % (key, value)
9394 
      for key, value in self.__dict__.iteritems()]
9395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9396 
 
9397 
  def __eq__(self, other):
9398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9399 
 
9400 
  def __ne__(self, other):
9401 
    return not (self == other)
9402 
 
9403 
class changeTransactionStatus_result:
9404 
  """
9405 
  Attributes:
9406 
   - success
9407 
   - ex
9408 
  """
9409 
 
9410 
  thrift_spec = (
9411 
    (0, TType.BOOL, 'success', None, None, ), # 0
9412 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9413 
  )
9414 
 
9415 
  def __init__(self, success=None, ex=None,):
9416 
    self.success = success
9417 
    self.ex = ex
9418 
 
9419 
  def read(self, iprot):
9420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9422 
      return
9423 
    iprot.readStructBegin()
9424 
    while True:
9425 
      (fname, ftype, fid) = iprot.readFieldBegin()
9426 
      if ftype == TType.STOP:
9427 
        break
9428 
      if fid == 0:
9429 
        if ftype == TType.BOOL:
9430 
          self.success = iprot.readBool();
9431 
        else:
9432 
          iprot.skip(ftype)
9433 
      elif fid == 1:
9434 
        if ftype == TType.STRUCT:
9435 
          self.ex = TransactionServiceException()
9436 
          self.ex.read(iprot)
9437 
        else:
9438 
          iprot.skip(ftype)
9439 
      else:
9440 
        iprot.skip(ftype)
9441 
      iprot.readFieldEnd()
9442 
    iprot.readStructEnd()
9443 
 
9444 
  def write(self, oprot):
9445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9447 
      return
9448 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9449 
    if self.success is not None:
94 ashish 9450 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9451 
      oprot.writeBool(self.success)
9452 
      oprot.writeFieldEnd()
3431 rajveer 9453 
    if self.ex is not None:
94 ashish 9454 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9455 
      self.ex.write(oprot)
9456 
      oprot.writeFieldEnd()
9457 
    oprot.writeFieldStop()
9458 
    oprot.writeStructEnd()
9459 
 
3431 rajveer 9460 
  def validate(self):
9461 
    return
9462 
 
9463 
 
94 ashish 9464 
  def __repr__(self):
9465 
    L = ['%s=%r' % (key, value)
9466 
      for key, value in self.__dict__.iteritems()]
9467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9468 
 
9469 
  def __eq__(self, other):
9470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9471 
 
9472 
  def __ne__(self, other):
9473 
    return not (self == other)
9474 
 
1398 varun.gupt 9475 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9476 
  """
9477 
  Attributes:
9478 
   - transactionId
9479 
  """
9480 
 
9481 
  thrift_spec = (
9482 
    None, # 0
9483 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9484 
  )
9485 
 
9486 
  def __init__(self, transactionId=None,):
9487 
    self.transactionId = transactionId
9488 
 
9489 
  def read(self, iprot):
9490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9492 
      return
9493 
    iprot.readStructBegin()
9494 
    while True:
9495 
      (fname, ftype, fid) = iprot.readFieldBegin()
9496 
      if ftype == TType.STOP:
9497 
        break
9498 
      if fid == 1:
9499 
        if ftype == TType.I64:
9500 
          self.transactionId = iprot.readI64();
9501 
        else:
9502 
          iprot.skip(ftype)
9503 
      else:
9504 
        iprot.skip(ftype)
9505 
      iprot.readFieldEnd()
9506 
    iprot.readStructEnd()
9507 
 
9508 
  def write(self, oprot):
9509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9511 
      return
1398 varun.gupt 9512 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9513 
    if self.transactionId is not None:
1382 varun.gupt 9514 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9515 
      oprot.writeI64(self.transactionId)
9516 
      oprot.writeFieldEnd()
9517 
    oprot.writeFieldStop()
9518 
    oprot.writeStructEnd()
9519 
 
3431 rajveer 9520 
  def validate(self):
9521 
    return
9522 
 
9523 
 
1382 varun.gupt 9524 
  def __repr__(self):
9525 
    L = ['%s=%r' % (key, value)
9526 
      for key, value in self.__dict__.iteritems()]
9527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9528 
 
9529 
  def __eq__(self, other):
9530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9531 
 
9532 
  def __ne__(self, other):
9533 
    return not (self == other)
9534 
 
1398 varun.gupt 9535 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9536 
  """
9537 
  Attributes:
9538 
   - success
9539 
   - ex
9540 
  """
9541 
 
9542 
  thrift_spec = (
9543 
    (0, TType.BOOL, 'success', None, None, ), # 0
9544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9545 
  )
9546 
 
9547 
  def __init__(self, success=None, ex=None,):
9548 
    self.success = success
9549 
    self.ex = ex
9550 
 
9551 
  def read(self, iprot):
9552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9554 
      return
9555 
    iprot.readStructBegin()
9556 
    while True:
9557 
      (fname, ftype, fid) = iprot.readFieldBegin()
9558 
      if ftype == TType.STOP:
9559 
        break
9560 
      if fid == 0:
9561 
        if ftype == TType.BOOL:
9562 
          self.success = iprot.readBool();
9563 
        else:
9564 
          iprot.skip(ftype)
9565 
      elif fid == 1:
9566 
        if ftype == TType.STRUCT:
9567 
          self.ex = TransactionServiceException()
9568 
          self.ex.read(iprot)
9569 
        else:
9570 
          iprot.skip(ftype)
9571 
      else:
9572 
        iprot.skip(ftype)
9573 
      iprot.readFieldEnd()
9574 
    iprot.readStructEnd()
9575 
 
9576 
  def write(self, oprot):
9577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9579 
      return
1398 varun.gupt 9580 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9581 
    if self.success is not None:
1382 varun.gupt 9582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9583 
      oprot.writeBool(self.success)
9584 
      oprot.writeFieldEnd()
3431 rajveer 9585 
    if self.ex is not None:
1382 varun.gupt 9586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9587 
      self.ex.write(oprot)
9588 
      oprot.writeFieldEnd()
9589 
    oprot.writeFieldStop()
9590 
    oprot.writeStructEnd()
9591 
 
3431 rajveer 9592 
  def validate(self):
9593 
    return
9594 
 
9595 
 
1382 varun.gupt 9596 
  def __repr__(self):
9597 
    L = ['%s=%r' % (key, value)
9598 
      for key, value in self.__dict__.iteritems()]
9599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9600 
 
9601 
  def __eq__(self, other):
9602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9603 
 
9604 
  def __ne__(self, other):
9605 
    return not (self == other)
9606 
 
483 rajveer 9607 
class getAllOrders_args:
94 ashish 9608 
  """
9609 
  Attributes:
4801 anupam.sin 9610 
   - statuses
483 rajveer 9611 
   - from_date
9612 
   - to_date
9613 
   - warehouse_id
94 ashish 9614 
  """
9615 
 
9616 
  thrift_spec = (
9617 
    None, # 0
4801 anupam.sin 9618 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9619 
    (2, TType.I64, 'from_date', None, None, ), # 2
9620 
    (3, TType.I64, 'to_date', None, None, ), # 3
9621 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9622 
  )
9623 
 
4801 anupam.sin 9624 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9625 
    self.statuses = statuses
483 rajveer 9626 
    self.from_date = from_date
9627 
    self.to_date = to_date
9628 
    self.warehouse_id = warehouse_id
94 ashish 9629 
 
9630 
  def read(self, iprot):
9631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9633 
      return
9634 
    iprot.readStructBegin()
9635 
    while True:
9636 
      (fname, ftype, fid) = iprot.readFieldBegin()
9637 
      if ftype == TType.STOP:
9638 
        break
9639 
      if fid == 1:
4801 anupam.sin 9640 
        if ftype == TType.LIST:
9641 
          self.statuses = []
6188 rajveer 9642 
          (_etype123, _size120) = iprot.readListBegin()
9643 
          for _i124 in xrange(_size120):
9644 
            _elem125 = iprot.readI32();
9645 
            self.statuses.append(_elem125)
4801 anupam.sin 9646 
          iprot.readListEnd()
94 ashish 9647 
        else:
9648 
          iprot.skip(ftype)
483 rajveer 9649 
      elif fid == 2:
9650 
        if ftype == TType.I64:
9651 
          self.from_date = iprot.readI64();
94 ashish 9652 
        else:
9653 
          iprot.skip(ftype)
483 rajveer 9654 
      elif fid == 3:
9655 
        if ftype == TType.I64:
9656 
          self.to_date = iprot.readI64();
94 ashish 9657 
        else:
9658 
          iprot.skip(ftype)
483 rajveer 9659 
      elif fid == 4:
94 ashish 9660 
        if ftype == TType.I64:
483 rajveer 9661 
          self.warehouse_id = iprot.readI64();
94 ashish 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_args')
4801 anupam.sin 9674 
    if self.statuses is not None:
9675 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9676 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9677 
      for iter126 in self.statuses:
9678 
        oprot.writeI32(iter126)
4801 anupam.sin 9679 
      oprot.writeListEnd()
94 ashish 9680 
      oprot.writeFieldEnd()
3431 rajveer 9681 
    if self.from_date is not None:
483 rajveer 9682 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9683 
      oprot.writeI64(self.from_date)
94 ashish 9684 
      oprot.writeFieldEnd()
3431 rajveer 9685 
    if self.to_date is not None:
483 rajveer 9686 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9687 
      oprot.writeI64(self.to_date)
94 ashish 9688 
      oprot.writeFieldEnd()
3431 rajveer 9689 
    if self.warehouse_id is not None:
483 rajveer 9690 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9691 
      oprot.writeI64(self.warehouse_id)
94 ashish 9692 
      oprot.writeFieldEnd()
9693 
    oprot.writeFieldStop()
9694 
    oprot.writeStructEnd()
9695 
 
3431 rajveer 9696 
  def validate(self):
9697 
    return
9698 
 
9699 
 
94 ashish 9700 
  def __repr__(self):
9701 
    L = ['%s=%r' % (key, value)
9702 
      for key, value in self.__dict__.iteritems()]
9703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9704 
 
9705 
  def __eq__(self, other):
9706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9707 
 
9708 
  def __ne__(self, other):
9709 
    return not (self == other)
9710 
 
483 rajveer 9711 
class getAllOrders_result:
94 ashish 9712 
  """
9713 
  Attributes:
9714 
   - success
9715 
   - ex
9716 
  """
9717 
 
9718 
  thrift_spec = (
483 rajveer 9719 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9721 
  )
9722 
 
9723 
  def __init__(self, success=None, ex=None,):
9724 
    self.success = success
9725 
    self.ex = ex
9726 
 
9727 
  def read(self, iprot):
9728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9730 
      return
9731 
    iprot.readStructBegin()
9732 
    while True:
9733 
      (fname, ftype, fid) = iprot.readFieldBegin()
9734 
      if ftype == TType.STOP:
9735 
        break
9736 
      if fid == 0:
483 rajveer 9737 
        if ftype == TType.LIST:
9738 
          self.success = []
6188 rajveer 9739 
          (_etype130, _size127) = iprot.readListBegin()
9740 
          for _i131 in xrange(_size127):
9741 
            _elem132 = Order()
9742 
            _elem132.read(iprot)
9743 
            self.success.append(_elem132)
483 rajveer 9744 
          iprot.readListEnd()
94 ashish 9745 
        else:
9746 
          iprot.skip(ftype)
9747 
      elif fid == 1:
9748 
        if ftype == TType.STRUCT:
9749 
          self.ex = TransactionServiceException()
9750 
          self.ex.read(iprot)
9751 
        else:
9752 
          iprot.skip(ftype)
9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
483 rajveer 9762 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9763 
    if self.success is not None:
483 rajveer 9764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9766 
      for iter133 in self.success:
9767 
        iter133.write(oprot)
483 rajveer 9768 
      oprot.writeListEnd()
94 ashish 9769 
      oprot.writeFieldEnd()
3431 rajveer 9770 
    if self.ex is not None:
94 ashish 9771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9772 
      self.ex.write(oprot)
9773 
      oprot.writeFieldEnd()
9774 
    oprot.writeFieldStop()
9775 
    oprot.writeStructEnd()
9776 
 
3431 rajveer 9777 
  def validate(self):
9778 
    return
9779 
 
9780 
 
94 ashish 9781 
  def __repr__(self):
9782 
    L = ['%s=%r' % (key, value)
9783 
      for key, value in self.__dict__.iteritems()]
9784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9785 
 
9786 
  def __eq__(self, other):
9787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9788 
 
9789 
  def __ne__(self, other):
9790 
    return not (self == other)
9791 
 
4133 chandransh 9792 
class getOrdersInBatch_args:
9793 
  """
9794 
  Attributes:
9795 
   - statuses
9796 
   - offset
9797 
   - limit
9798 
   - warehouse_id
9799 
  """
9800 
 
9801 
  thrift_spec = (
9802 
    None, # 0
9803 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9804 
    (2, TType.I64, 'offset', None, None, ), # 2
9805 
    (3, TType.I64, 'limit', None, None, ), # 3
9806 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9807 
  )
9808 
 
9809 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9810 
    self.statuses = statuses
9811 
    self.offset = offset
9812 
    self.limit = limit
9813 
    self.warehouse_id = warehouse_id
9814 
 
9815 
  def read(self, iprot):
9816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9818 
      return
9819 
    iprot.readStructBegin()
9820 
    while True:
9821 
      (fname, ftype, fid) = iprot.readFieldBegin()
9822 
      if ftype == TType.STOP:
9823 
        break
9824 
      if fid == 1:
9825 
        if ftype == TType.LIST:
9826 
          self.statuses = []
6188 rajveer 9827 
          (_etype137, _size134) = iprot.readListBegin()
9828 
          for _i138 in xrange(_size134):
9829 
            _elem139 = iprot.readI32();
9830 
            self.statuses.append(_elem139)
4133 chandransh 9831 
          iprot.readListEnd()
9832 
        else:
9833 
          iprot.skip(ftype)
9834 
      elif fid == 2:
9835 
        if ftype == TType.I64:
9836 
          self.offset = iprot.readI64();
9837 
        else:
9838 
          iprot.skip(ftype)
9839 
      elif fid == 3:
9840 
        if ftype == TType.I64:
9841 
          self.limit = iprot.readI64();
9842 
        else:
9843 
          iprot.skip(ftype)
9844 
      elif fid == 4:
9845 
        if ftype == TType.I64:
9846 
          self.warehouse_id = iprot.readI64();
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_args')
9859 
    if self.statuses is not None:
9860 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9861 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9862 
      for iter140 in self.statuses:
9863 
        oprot.writeI32(iter140)
4133 chandransh 9864 
      oprot.writeListEnd()
9865 
      oprot.writeFieldEnd()
9866 
    if self.offset is not None:
9867 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9868 
      oprot.writeI64(self.offset)
9869 
      oprot.writeFieldEnd()
9870 
    if self.limit is not None:
9871 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9872 
      oprot.writeI64(self.limit)
9873 
      oprot.writeFieldEnd()
9874 
    if self.warehouse_id is not None:
9875 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9876 
      oprot.writeI64(self.warehouse_id)
9877 
      oprot.writeFieldEnd()
9878 
    oprot.writeFieldStop()
9879 
    oprot.writeStructEnd()
9880 
 
9881 
  def validate(self):
9882 
    return
9883 
 
9884 
 
9885 
  def __repr__(self):
9886 
    L = ['%s=%r' % (key, value)
9887 
      for key, value in self.__dict__.iteritems()]
9888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9889 
 
9890 
  def __eq__(self, other):
9891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9892 
 
9893 
  def __ne__(self, other):
9894 
    return not (self == other)
9895 
 
9896 
class getOrdersInBatch_result:
9897 
  """
9898 
  Attributes:
9899 
   - success
9900 
   - ex
9901 
  """
9902 
 
9903 
  thrift_spec = (
9904 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9906 
  )
9907 
 
9908 
  def __init__(self, success=None, ex=None,):
9909 
    self.success = success
9910 
    self.ex = ex
9911 
 
9912 
  def read(self, iprot):
9913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9915 
      return
9916 
    iprot.readStructBegin()
9917 
    while True:
9918 
      (fname, ftype, fid) = iprot.readFieldBegin()
9919 
      if ftype == TType.STOP:
9920 
        break
9921 
      if fid == 0:
9922 
        if ftype == TType.LIST:
9923 
          self.success = []
6188 rajveer 9924 
          (_etype144, _size141) = iprot.readListBegin()
9925 
          for _i145 in xrange(_size141):
9926 
            _elem146 = Order()
9927 
            _elem146.read(iprot)
9928 
            self.success.append(_elem146)
4133 chandransh 9929 
          iprot.readListEnd()
9930 
        else:
9931 
          iprot.skip(ftype)
9932 
      elif fid == 1:
9933 
        if ftype == TType.STRUCT:
9934 
          self.ex = TransactionServiceException()
9935 
          self.ex.read(iprot)
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      else:
9939 
        iprot.skip(ftype)
9940 
      iprot.readFieldEnd()
9941 
    iprot.readStructEnd()
9942 
 
9943 
  def write(self, oprot):
9944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9946 
      return
9947 
    oprot.writeStructBegin('getOrdersInBatch_result')
9948 
    if self.success is not None:
9949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9951 
      for iter147 in self.success:
9952 
        iter147.write(oprot)
4133 chandransh 9953 
      oprot.writeListEnd()
9954 
      oprot.writeFieldEnd()
9955 
    if self.ex is not None:
9956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9957 
      self.ex.write(oprot)
9958 
      oprot.writeFieldEnd()
9959 
    oprot.writeFieldStop()
9960 
    oprot.writeStructEnd()
9961 
 
9962 
  def validate(self):
9963 
    return
9964 
 
9965 
 
9966 
  def __repr__(self):
9967 
    L = ['%s=%r' % (key, value)
9968 
      for key, value in self.__dict__.iteritems()]
9969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9970 
 
9971 
  def __eq__(self, other):
9972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9973 
 
9974 
  def __ne__(self, other):
9975 
    return not (self == other)
9976 
 
9977 
class getOrderCount_args:
9978 
  """
9979 
  Attributes:
9980 
   - statuses
9981 
   - warehouseId
9982 
  """
9983 
 
9984 
  thrift_spec = (
9985 
    None, # 0
9986 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9987 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9988 
  )
9989 
 
9990 
  def __init__(self, statuses=None, warehouseId=None,):
9991 
    self.statuses = statuses
9992 
    self.warehouseId = warehouseId
9993 
 
9994 
  def read(self, iprot):
9995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9997 
      return
9998 
    iprot.readStructBegin()
9999 
    while True:
10000 
      (fname, ftype, fid) = iprot.readFieldBegin()
10001 
      if ftype == TType.STOP:
10002 
        break
10003 
      if fid == 1:
10004 
        if ftype == TType.LIST:
10005 
          self.statuses = []
6188 rajveer 10006 
          (_etype151, _size148) = iprot.readListBegin()
10007 
          for _i152 in xrange(_size148):
10008 
            _elem153 = iprot.readI32();
10009 
            self.statuses.append(_elem153)
4133 chandransh 10010 
          iprot.readListEnd()
10011 
        else:
10012 
          iprot.skip(ftype)
10013 
      elif fid == 2:
10014 
        if ftype == TType.I64:
10015 
          self.warehouseId = iprot.readI64();
10016 
        else:
10017 
          iprot.skip(ftype)
10018 
      else:
10019 
        iprot.skip(ftype)
10020 
      iprot.readFieldEnd()
10021 
    iprot.readStructEnd()
10022 
 
10023 
  def write(self, oprot):
10024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10026 
      return
10027 
    oprot.writeStructBegin('getOrderCount_args')
10028 
    if self.statuses is not None:
10029 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10030 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10031 
      for iter154 in self.statuses:
10032 
        oprot.writeI32(iter154)
4133 chandransh 10033 
      oprot.writeListEnd()
10034 
      oprot.writeFieldEnd()
10035 
    if self.warehouseId is not None:
10036 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10037 
      oprot.writeI64(self.warehouseId)
10038 
      oprot.writeFieldEnd()
10039 
    oprot.writeFieldStop()
10040 
    oprot.writeStructEnd()
10041 
 
10042 
  def validate(self):
10043 
    return
10044 
 
10045 
 
10046 
  def __repr__(self):
10047 
    L = ['%s=%r' % (key, value)
10048 
      for key, value in self.__dict__.iteritems()]
10049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10050 
 
10051 
  def __eq__(self, other):
10052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10053 
 
10054 
  def __ne__(self, other):
10055 
    return not (self == other)
10056 
 
10057 
class getOrderCount_result:
10058 
  """
10059 
  Attributes:
10060 
   - success
10061 
   - ex
10062 
  """
10063 
 
10064 
  thrift_spec = (
10065 
    (0, TType.I32, 'success', None, None, ), # 0
10066 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10067 
  )
10068 
 
10069 
  def __init__(self, success=None, ex=None,):
10070 
    self.success = success
10071 
    self.ex = ex
10072 
 
10073 
  def read(self, iprot):
10074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10076 
      return
10077 
    iprot.readStructBegin()
10078 
    while True:
10079 
      (fname, ftype, fid) = iprot.readFieldBegin()
10080 
      if ftype == TType.STOP:
10081 
        break
10082 
      if fid == 0:
10083 
        if ftype == TType.I32:
10084 
          self.success = iprot.readI32();
10085 
        else:
10086 
          iprot.skip(ftype)
10087 
      elif fid == 1:
10088 
        if ftype == TType.STRUCT:
10089 
          self.ex = TransactionServiceException()
10090 
          self.ex.read(iprot)
10091 
        else:
10092 
          iprot.skip(ftype)
10093 
      else:
10094 
        iprot.skip(ftype)
10095 
      iprot.readFieldEnd()
10096 
    iprot.readStructEnd()
10097 
 
10098 
  def write(self, oprot):
10099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10101 
      return
10102 
    oprot.writeStructBegin('getOrderCount_result')
10103 
    if self.success is not None:
10104 
      oprot.writeFieldBegin('success', TType.I32, 0)
10105 
      oprot.writeI32(self.success)
10106 
      oprot.writeFieldEnd()
10107 
    if self.ex is not None:
10108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10109 
      self.ex.write(oprot)
10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
10114 
  def validate(self):
10115 
    return
10116 
 
10117 
 
10118 
  def __repr__(self):
10119 
    L = ['%s=%r' % (key, value)
10120 
      for key, value in self.__dict__.iteritems()]
10121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10122 
 
10123 
  def __eq__(self, other):
10124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10125 
 
10126 
  def __ne__(self, other):
10127 
    return not (self == other)
10128 
 
999 varun.gupt 10129 
class getOrdersByBillingDate_args:
10130 
  """
10131 
  Attributes:
10132 
   - status
10133 
   - start_billing_date
10134 
   - end_billing_date
10135 
   - warehouse_id
10136 
  """
10137 
 
10138 
  thrift_spec = (
10139 
    None, # 0
10140 
    (1, TType.I32, 'status', None, None, ), # 1
10141 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10142 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10143 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10144 
  )
10145 
 
10146 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10147 
    self.status = status
10148 
    self.start_billing_date = start_billing_date
10149 
    self.end_billing_date = end_billing_date
10150 
    self.warehouse_id = warehouse_id
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 == 1:
10162 
        if ftype == TType.I32:
10163 
          self.status = iprot.readI32();
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      elif fid == 2:
10167 
        if ftype == TType.I64:
10168 
          self.start_billing_date = iprot.readI64();
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      elif fid == 3:
10172 
        if ftype == TType.I64:
10173 
          self.end_billing_date = iprot.readI64();
10174 
        else:
10175 
          iprot.skip(ftype)
10176 
      elif fid == 4:
10177 
        if ftype == TType.I64:
10178 
          self.warehouse_id = iprot.readI64();
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10191 
    if self.status is not None:
999 varun.gupt 10192 
      oprot.writeFieldBegin('status', TType.I32, 1)
10193 
      oprot.writeI32(self.status)
10194 
      oprot.writeFieldEnd()
3431 rajveer 10195 
    if self.start_billing_date is not None:
999 varun.gupt 10196 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10197 
      oprot.writeI64(self.start_billing_date)
10198 
      oprot.writeFieldEnd()
3431 rajveer 10199 
    if self.end_billing_date is not None:
999 varun.gupt 10200 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10201 
      oprot.writeI64(self.end_billing_date)
10202 
      oprot.writeFieldEnd()
3431 rajveer 10203 
    if self.warehouse_id is not None:
999 varun.gupt 10204 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10205 
      oprot.writeI64(self.warehouse_id)
10206 
      oprot.writeFieldEnd()
10207 
    oprot.writeFieldStop()
10208 
    oprot.writeStructEnd()
10209 
 
3431 rajveer 10210 
  def validate(self):
10211 
    return
10212 
 
10213 
 
999 varun.gupt 10214 
  def __repr__(self):
10215 
    L = ['%s=%r' % (key, value)
10216 
      for key, value in self.__dict__.iteritems()]
10217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10218 
 
10219 
  def __eq__(self, other):
10220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10221 
 
10222 
  def __ne__(self, other):
10223 
    return not (self == other)
10224 
 
10225 
class getOrdersByBillingDate_result:
10226 
  """
10227 
  Attributes:
10228 
   - success
10229 
   - ex
10230 
  """
10231 
 
10232 
  thrift_spec = (
10233 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10235 
  )
10236 
 
10237 
  def __init__(self, success=None, ex=None,):
10238 
    self.success = success
10239 
    self.ex = ex
10240 
 
10241 
  def read(self, iprot):
10242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10244 
      return
10245 
    iprot.readStructBegin()
10246 
    while True:
10247 
      (fname, ftype, fid) = iprot.readFieldBegin()
10248 
      if ftype == TType.STOP:
10249 
        break
10250 
      if fid == 0:
10251 
        if ftype == TType.LIST:
10252 
          self.success = []
6188 rajveer 10253 
          (_etype158, _size155) = iprot.readListBegin()
10254 
          for _i159 in xrange(_size155):
10255 
            _elem160 = Order()
10256 
            _elem160.read(iprot)
10257 
            self.success.append(_elem160)
999 varun.gupt 10258 
          iprot.readListEnd()
10259 
        else:
10260 
          iprot.skip(ftype)
10261 
      elif fid == 1:
10262 
        if ftype == TType.STRUCT:
10263 
          self.ex = TransactionServiceException()
10264 
          self.ex.read(iprot)
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      else:
10268 
        iprot.skip(ftype)
10269 
      iprot.readFieldEnd()
10270 
    iprot.readStructEnd()
10271 
 
10272 
  def write(self, oprot):
10273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10275 
      return
10276 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10277 
    if self.success is not None:
999 varun.gupt 10278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10280 
      for iter161 in self.success:
10281 
        iter161.write(oprot)
999 varun.gupt 10282 
      oprot.writeListEnd()
10283 
      oprot.writeFieldEnd()
3431 rajveer 10284 
    if self.ex is not None:
999 varun.gupt 10285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10286 
      self.ex.write(oprot)
10287 
      oprot.writeFieldEnd()
10288 
    oprot.writeFieldStop()
10289 
    oprot.writeStructEnd()
10290 
 
3431 rajveer 10291 
  def validate(self):
10292 
    return
10293 
 
10294 
 
999 varun.gupt 10295 
  def __repr__(self):
10296 
    L = ['%s=%r' % (key, value)
10297 
      for key, value in self.__dict__.iteritems()]
10298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10299 
 
10300 
  def __eq__(self, other):
10301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10302 
 
10303 
  def __ne__(self, other):
10304 
    return not (self == other)
10305 
 
3427 chandransh 10306 
class getOrdersByShippingDate_args:
10307 
  """
10308 
  Attributes:
10309 
   - fromShippingDate
10310 
   - toShippingDate
10311 
   - providerId
10312 
   - warehouseId
3451 chandransh 10313 
   - cod
3427 chandransh 10314 
  """
10315 
 
10316 
  thrift_spec = (
10317 
    None, # 0
10318 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10319 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10320 
    (3, TType.I64, 'providerId', None, None, ), # 3
10321 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10322 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10323 
  )
10324 
 
3451 chandransh 10325 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10326 
    self.fromShippingDate = fromShippingDate
10327 
    self.toShippingDate = toShippingDate
10328 
    self.providerId = providerId
10329 
    self.warehouseId = warehouseId
3451 chandransh 10330 
    self.cod = cod
3427 chandransh 10331 
 
10332 
  def read(self, iprot):
10333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10335 
      return
10336 
    iprot.readStructBegin()
10337 
    while True:
10338 
      (fname, ftype, fid) = iprot.readFieldBegin()
10339 
      if ftype == TType.STOP:
10340 
        break
10341 
      if fid == 1:
10342 
        if ftype == TType.I64:
10343 
          self.fromShippingDate = iprot.readI64();
10344 
        else:
10345 
          iprot.skip(ftype)
10346 
      elif fid == 2:
10347 
        if ftype == TType.I64:
10348 
          self.toShippingDate = iprot.readI64();
10349 
        else:
10350 
          iprot.skip(ftype)
10351 
      elif fid == 3:
10352 
        if ftype == TType.I64:
10353 
          self.providerId = iprot.readI64();
10354 
        else:
10355 
          iprot.skip(ftype)
10356 
      elif fid == 4:
10357 
        if ftype == TType.I64:
10358 
          self.warehouseId = iprot.readI64();
10359 
        else:
10360 
          iprot.skip(ftype)
3451 chandransh 10361 
      elif fid == 5:
10362 
        if ftype == TType.BOOL:
10363 
          self.cod = iprot.readBool();
10364 
        else:
10365 
          iprot.skip(ftype)
3427 chandransh 10366 
      else:
10367 
        iprot.skip(ftype)
10368 
      iprot.readFieldEnd()
10369 
    iprot.readStructEnd()
10370 
 
10371 
  def write(self, oprot):
10372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10374 
      return
10375 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10376 
    if self.fromShippingDate is not None:
3427 chandransh 10377 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10378 
      oprot.writeI64(self.fromShippingDate)
10379 
      oprot.writeFieldEnd()
3431 rajveer 10380 
    if self.toShippingDate is not None:
3427 chandransh 10381 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10382 
      oprot.writeI64(self.toShippingDate)
10383 
      oprot.writeFieldEnd()
3431 rajveer 10384 
    if self.providerId is not None:
3427 chandransh 10385 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10386 
      oprot.writeI64(self.providerId)
10387 
      oprot.writeFieldEnd()
3431 rajveer 10388 
    if self.warehouseId is not None:
3427 chandransh 10389 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10390 
      oprot.writeI64(self.warehouseId)
10391 
      oprot.writeFieldEnd()
3451 chandransh 10392 
    if self.cod is not None:
10393 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10394 
      oprot.writeBool(self.cod)
10395 
      oprot.writeFieldEnd()
3427 chandransh 10396 
    oprot.writeFieldStop()
10397 
    oprot.writeStructEnd()
10398 
 
3431 rajveer 10399 
  def validate(self):
10400 
    return
10401 
 
10402 
 
3427 chandransh 10403 
  def __repr__(self):
10404 
    L = ['%s=%r' % (key, value)
10405 
      for key, value in self.__dict__.iteritems()]
10406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10407 
 
10408 
  def __eq__(self, other):
10409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10410 
 
10411 
  def __ne__(self, other):
10412 
    return not (self == other)
10413 
 
10414 
class getOrdersByShippingDate_result:
10415 
  """
10416 
  Attributes:
10417 
   - success
10418 
   - ex
10419 
  """
10420 
 
10421 
  thrift_spec = (
10422 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10424 
  )
10425 
 
10426 
  def __init__(self, success=None, ex=None,):
10427 
    self.success = success
10428 
    self.ex = ex
10429 
 
10430 
  def read(self, iprot):
10431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10433 
      return
10434 
    iprot.readStructBegin()
10435 
    while True:
10436 
      (fname, ftype, fid) = iprot.readFieldBegin()
10437 
      if ftype == TType.STOP:
10438 
        break
10439 
      if fid == 0:
10440 
        if ftype == TType.LIST:
10441 
          self.success = []
6188 rajveer 10442 
          (_etype165, _size162) = iprot.readListBegin()
10443 
          for _i166 in xrange(_size162):
10444 
            _elem167 = Order()
10445 
            _elem167.read(iprot)
10446 
            self.success.append(_elem167)
3427 chandransh 10447 
          iprot.readListEnd()
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      elif fid == 1:
10451 
        if ftype == TType.STRUCT:
10452 
          self.ex = TransactionServiceException()
10453 
          self.ex.read(iprot)
10454 
        else:
10455 
          iprot.skip(ftype)
10456 
      else:
10457 
        iprot.skip(ftype)
10458 
      iprot.readFieldEnd()
10459 
    iprot.readStructEnd()
10460 
 
10461 
  def write(self, oprot):
10462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10464 
      return
10465 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10466 
    if self.success is not None:
3427 chandransh 10467 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10468 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10469 
      for iter168 in self.success:
10470 
        iter168.write(oprot)
3427 chandransh 10471 
      oprot.writeListEnd()
10472 
      oprot.writeFieldEnd()
3431 rajveer 10473 
    if self.ex is not None:
3427 chandransh 10474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10475 
      self.ex.write(oprot)
10476 
      oprot.writeFieldEnd()
10477 
    oprot.writeFieldStop()
10478 
    oprot.writeStructEnd()
10479 
 
3431 rajveer 10480 
  def validate(self):
10481 
    return
10482 
 
10483 
 
3427 chandransh 10484 
  def __repr__(self):
10485 
    L = ['%s=%r' % (key, value)
10486 
      for key, value in self.__dict__.iteritems()]
10487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10488 
 
10489 
  def __eq__(self, other):
10490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10491 
 
10492 
  def __ne__(self, other):
10493 
    return not (self == other)
10494 
 
1382 varun.gupt 10495 
class getReturnableOrdersForCustomer_args:
10496 
  """
10497 
  Attributes:
10498 
   - customer_id
10499 
   - limit
10500 
  """
10501 
 
10502 
  thrift_spec = (
10503 
    None, # 0
10504 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10505 
    (2, TType.I64, 'limit', None, None, ), # 2
10506 
  )
10507 
 
10508 
  def __init__(self, customer_id=None, limit=None,):
10509 
    self.customer_id = customer_id
10510 
    self.limit = limit
10511 
 
10512 
  def read(self, iprot):
10513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10515 
      return
10516 
    iprot.readStructBegin()
10517 
    while True:
10518 
      (fname, ftype, fid) = iprot.readFieldBegin()
10519 
      if ftype == TType.STOP:
10520 
        break
10521 
      if fid == 1:
10522 
        if ftype == TType.I64:
10523 
          self.customer_id = iprot.readI64();
10524 
        else:
10525 
          iprot.skip(ftype)
10526 
      elif fid == 2:
10527 
        if ftype == TType.I64:
10528 
          self.limit = iprot.readI64();
10529 
        else:
10530 
          iprot.skip(ftype)
10531 
      else:
10532 
        iprot.skip(ftype)
10533 
      iprot.readFieldEnd()
10534 
    iprot.readStructEnd()
10535 
 
10536 
  def write(self, oprot):
10537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10539 
      return
10540 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10541 
    if self.customer_id is not None:
1382 varun.gupt 10542 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10543 
      oprot.writeI64(self.customer_id)
10544 
      oprot.writeFieldEnd()
3431 rajveer 10545 
    if self.limit is not None:
1382 varun.gupt 10546 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10547 
      oprot.writeI64(self.limit)
10548 
      oprot.writeFieldEnd()
10549 
    oprot.writeFieldStop()
10550 
    oprot.writeStructEnd()
10551 
 
3431 rajveer 10552 
  def validate(self):
10553 
    return
10554 
 
10555 
 
1382 varun.gupt 10556 
  def __repr__(self):
10557 
    L = ['%s=%r' % (key, value)
10558 
      for key, value in self.__dict__.iteritems()]
10559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10560 
 
10561 
  def __eq__(self, other):
10562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10563 
 
10564 
  def __ne__(self, other):
10565 
    return not (self == other)
10566 
 
10567 
class getReturnableOrdersForCustomer_result:
10568 
  """
10569 
  Attributes:
10570 
   - success
10571 
   - ex
10572 
  """
10573 
 
10574 
  thrift_spec = (
10575 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10577 
  )
10578 
 
10579 
  def __init__(self, success=None, ex=None,):
10580 
    self.success = success
10581 
    self.ex = ex
10582 
 
10583 
  def read(self, iprot):
10584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10586 
      return
10587 
    iprot.readStructBegin()
10588 
    while True:
10589 
      (fname, ftype, fid) = iprot.readFieldBegin()
10590 
      if ftype == TType.STOP:
10591 
        break
10592 
      if fid == 0:
10593 
        if ftype == TType.LIST:
10594 
          self.success = []
6188 rajveer 10595 
          (_etype172, _size169) = iprot.readListBegin()
10596 
          for _i173 in xrange(_size169):
10597 
            _elem174 = iprot.readI64();
10598 
            self.success.append(_elem174)
1382 varun.gupt 10599 
          iprot.readListEnd()
10600 
        else:
10601 
          iprot.skip(ftype)
10602 
      elif fid == 1:
10603 
        if ftype == TType.STRUCT:
10604 
          self.ex = TransactionServiceException()
10605 
          self.ex.read(iprot)
10606 
        else:
10607 
          iprot.skip(ftype)
10608 
      else:
10609 
        iprot.skip(ftype)
10610 
      iprot.readFieldEnd()
10611 
    iprot.readStructEnd()
10612 
 
10613 
  def write(self, oprot):
10614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10616 
      return
10617 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10618 
    if self.success is not None:
1382 varun.gupt 10619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10620 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10621 
      for iter175 in self.success:
10622 
        oprot.writeI64(iter175)
1382 varun.gupt 10623 
      oprot.writeListEnd()
10624 
      oprot.writeFieldEnd()
3431 rajveer 10625 
    if self.ex is not None:
1382 varun.gupt 10626 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10627 
      self.ex.write(oprot)
10628 
      oprot.writeFieldEnd()
10629 
    oprot.writeFieldStop()
10630 
    oprot.writeStructEnd()
10631 
 
3431 rajveer 10632 
  def validate(self):
10633 
    return
10634 
 
10635 
 
1382 varun.gupt 10636 
  def __repr__(self):
10637 
    L = ['%s=%r' % (key, value)
10638 
      for key, value in self.__dict__.iteritems()]
10639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10640 
 
10641 
  def __eq__(self, other):
10642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10643 
 
10644 
  def __ne__(self, other):
10645 
    return not (self == other)
10646 
 
10647 
class getCancellableOrdersForCustomer_args:
10648 
  """
10649 
  Attributes:
10650 
   - customer_id
10651 
   - limit
10652 
  """
10653 
 
10654 
  thrift_spec = (
10655 
    None, # 0
10656 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10657 
    (2, TType.I64, 'limit', None, None, ), # 2
10658 
  )
10659 
 
10660 
  def __init__(self, customer_id=None, limit=None,):
10661 
    self.customer_id = customer_id
10662 
    self.limit = limit
10663 
 
10664 
  def read(self, iprot):
10665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10667 
      return
10668 
    iprot.readStructBegin()
10669 
    while True:
10670 
      (fname, ftype, fid) = iprot.readFieldBegin()
10671 
      if ftype == TType.STOP:
10672 
        break
10673 
      if fid == 1:
10674 
        if ftype == TType.I64:
10675 
          self.customer_id = iprot.readI64();
10676 
        else:
10677 
          iprot.skip(ftype)
10678 
      elif fid == 2:
10679 
        if ftype == TType.I64:
10680 
          self.limit = iprot.readI64();
10681 
        else:
10682 
          iprot.skip(ftype)
10683 
      else:
10684 
        iprot.skip(ftype)
10685 
      iprot.readFieldEnd()
10686 
    iprot.readStructEnd()
10687 
 
10688 
  def write(self, oprot):
10689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10691 
      return
10692 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10693 
    if self.customer_id is not None:
1382 varun.gupt 10694 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10695 
      oprot.writeI64(self.customer_id)
10696 
      oprot.writeFieldEnd()
3431 rajveer 10697 
    if self.limit is not None:
1382 varun.gupt 10698 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10699 
      oprot.writeI64(self.limit)
10700 
      oprot.writeFieldEnd()
10701 
    oprot.writeFieldStop()
10702 
    oprot.writeStructEnd()
10703 
 
3431 rajveer 10704 
  def validate(self):
10705 
    return
10706 
 
10707 
 
1382 varun.gupt 10708 
  def __repr__(self):
10709 
    L = ['%s=%r' % (key, value)
10710 
      for key, value in self.__dict__.iteritems()]
10711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10712 
 
10713 
  def __eq__(self, other):
10714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10715 
 
10716 
  def __ne__(self, other):
10717 
    return not (self == other)
10718 
 
10719 
class getCancellableOrdersForCustomer_result:
10720 
  """
10721 
  Attributes:
10722 
   - success
10723 
   - ex
10724 
  """
10725 
 
10726 
  thrift_spec = (
10727 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10728 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10729 
  )
10730 
 
10731 
  def __init__(self, success=None, ex=None,):
10732 
    self.success = success
10733 
    self.ex = ex
10734 
 
10735 
  def read(self, iprot):
10736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10738 
      return
10739 
    iprot.readStructBegin()
10740 
    while True:
10741 
      (fname, ftype, fid) = iprot.readFieldBegin()
10742 
      if ftype == TType.STOP:
10743 
        break
10744 
      if fid == 0:
10745 
        if ftype == TType.LIST:
10746 
          self.success = []
6188 rajveer 10747 
          (_etype179, _size176) = iprot.readListBegin()
10748 
          for _i180 in xrange(_size176):
10749 
            _elem181 = iprot.readI64();
10750 
            self.success.append(_elem181)
1382 varun.gupt 10751 
          iprot.readListEnd()
10752 
        else:
10753 
          iprot.skip(ftype)
10754 
      elif fid == 1:
10755 
        if ftype == TType.STRUCT:
10756 
          self.ex = TransactionServiceException()
10757 
          self.ex.read(iprot)
10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      else:
10761 
        iprot.skip(ftype)
10762 
      iprot.readFieldEnd()
10763 
    iprot.readStructEnd()
10764 
 
10765 
  def write(self, oprot):
10766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10768 
      return
10769 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10770 
    if self.success is not None:
1382 varun.gupt 10771 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10772 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10773 
      for iter182 in self.success:
10774 
        oprot.writeI64(iter182)
1382 varun.gupt 10775 
      oprot.writeListEnd()
10776 
      oprot.writeFieldEnd()
3431 rajveer 10777 
    if self.ex is not None:
1382 varun.gupt 10778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10779 
      self.ex.write(oprot)
10780 
      oprot.writeFieldEnd()
10781 
    oprot.writeFieldStop()
10782 
    oprot.writeStructEnd()
10783 
 
3431 rajveer 10784 
  def validate(self):
10785 
    return
10786 
 
10787 
 
1382 varun.gupt 10788 
  def __repr__(self):
10789 
    L = ['%s=%r' % (key, value)
10790 
      for key, value in self.__dict__.iteritems()]
10791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10792 
 
10793 
  def __eq__(self, other):
10794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10795 
 
10796 
  def __ne__(self, other):
10797 
    return not (self == other)
10798 
 
483 rajveer 10799 
class changeOrderStatus_args:
94 ashish 10800 
  """
10801 
  Attributes:
483 rajveer 10802 
   - orderId
10803 
   - status
10804 
   - description
94 ashish 10805 
  """
10806 
 
10807 
  thrift_spec = (
10808 
    None, # 0
483 rajveer 10809 
    (1, TType.I64, 'orderId', None, None, ), # 1
10810 
    (2, TType.I32, 'status', None, None, ), # 2
10811 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10812 
  )
10813 
 
483 rajveer 10814 
  def __init__(self, orderId=None, status=None, description=None,):
10815 
    self.orderId = orderId
10816 
    self.status = status
10817 
    self.description = description
94 ashish 10818 
 
10819 
  def read(self, iprot):
10820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10822 
      return
10823 
    iprot.readStructBegin()
10824 
    while True:
10825 
      (fname, ftype, fid) = iprot.readFieldBegin()
10826 
      if ftype == TType.STOP:
10827 
        break
10828 
      if fid == 1:
10829 
        if ftype == TType.I64:
483 rajveer 10830 
          self.orderId = iprot.readI64();
94 ashish 10831 
        else:
10832 
          iprot.skip(ftype)
10833 
      elif fid == 2:
483 rajveer 10834 
        if ftype == TType.I32:
10835 
          self.status = iprot.readI32();
94 ashish 10836 
        else:
10837 
          iprot.skip(ftype)
483 rajveer 10838 
      elif fid == 3:
10839 
        if ftype == TType.STRING:
10840 
          self.description = iprot.readString();
10841 
        else:
10842 
          iprot.skip(ftype)
94 ashish 10843 
      else:
10844 
        iprot.skip(ftype)
10845 
      iprot.readFieldEnd()
10846 
    iprot.readStructEnd()
10847 
 
10848 
  def write(self, oprot):
10849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10851 
      return
483 rajveer 10852 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10853 
    if self.orderId is not None:
483 rajveer 10854 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10855 
      oprot.writeI64(self.orderId)
94 ashish 10856 
      oprot.writeFieldEnd()
3431 rajveer 10857 
    if self.status is not None:
483 rajveer 10858 
      oprot.writeFieldBegin('status', TType.I32, 2)
10859 
      oprot.writeI32(self.status)
94 ashish 10860 
      oprot.writeFieldEnd()
3431 rajveer 10861 
    if self.description is not None:
483 rajveer 10862 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10863 
      oprot.writeString(self.description)
10864 
      oprot.writeFieldEnd()
94 ashish 10865 
    oprot.writeFieldStop()
10866 
    oprot.writeStructEnd()
10867 
 
3431 rajveer 10868 
  def validate(self):
10869 
    return
10870 
 
10871 
 
94 ashish 10872 
  def __repr__(self):
10873 
    L = ['%s=%r' % (key, value)
10874 
      for key, value in self.__dict__.iteritems()]
10875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10876 
 
10877 
  def __eq__(self, other):
10878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10879 
 
10880 
  def __ne__(self, other):
10881 
    return not (self == other)
10882 
 
483 rajveer 10883 
class changeOrderStatus_result:
94 ashish 10884 
  """
10885 
  Attributes:
10886 
   - success
10887 
   - ex
10888 
  """
10889 
 
10890 
  thrift_spec = (
10891 
    (0, TType.BOOL, 'success', None, None, ), # 0
10892 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10893 
  )
10894 
 
10895 
  def __init__(self, success=None, ex=None,):
10896 
    self.success = success
10897 
    self.ex = ex
10898 
 
10899 
  def read(self, iprot):
10900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10902 
      return
10903 
    iprot.readStructBegin()
10904 
    while True:
10905 
      (fname, ftype, fid) = iprot.readFieldBegin()
10906 
      if ftype == TType.STOP:
10907 
        break
10908 
      if fid == 0:
10909 
        if ftype == TType.BOOL:
10910 
          self.success = iprot.readBool();
10911 
        else:
10912 
          iprot.skip(ftype)
10913 
      elif fid == 1:
10914 
        if ftype == TType.STRUCT:
10915 
          self.ex = TransactionServiceException()
10916 
          self.ex.read(iprot)
10917 
        else:
10918 
          iprot.skip(ftype)
10919 
      else:
10920 
        iprot.skip(ftype)
10921 
      iprot.readFieldEnd()
10922 
    iprot.readStructEnd()
10923 
 
10924 
  def write(self, oprot):
10925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10927 
      return
483 rajveer 10928 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10929 
    if self.success is not None:
94 ashish 10930 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10931 
      oprot.writeBool(self.success)
10932 
      oprot.writeFieldEnd()
3431 rajveer 10933 
    if self.ex is not None:
94 ashish 10934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10935 
      self.ex.write(oprot)
10936 
      oprot.writeFieldEnd()
10937 
    oprot.writeFieldStop()
10938 
    oprot.writeStructEnd()
10939 
 
3431 rajveer 10940 
  def validate(self):
10941 
    return
10942 
 
10943 
 
94 ashish 10944 
  def __repr__(self):
10945 
    L = ['%s=%r' % (key, value)
10946 
      for key, value in self.__dict__.iteritems()]
10947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10948 
 
10949 
  def __eq__(self, other):
10950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10951 
 
10952 
  def __ne__(self, other):
10953 
    return not (self == other)
10954 
 
3064 chandransh 10955 
class getOrdersForTransaction_args:
494 rajveer 10956 
  """
10957 
  Attributes:
3064 chandransh 10958 
   - transactionId
10959 
   - customerId
494 rajveer 10960 
  """
10961 
 
10962 
  thrift_spec = (
10963 
    None, # 0
3064 chandransh 10964 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10965 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10966 
  )
10967 
 
3064 chandransh 10968 
  def __init__(self, transactionId=None, customerId=None,):
10969 
    self.transactionId = transactionId
10970 
    self.customerId = customerId
494 rajveer 10971 
 
10972 
  def read(self, iprot):
10973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10975 
      return
10976 
    iprot.readStructBegin()
10977 
    while True:
10978 
      (fname, ftype, fid) = iprot.readFieldBegin()
10979 
      if ftype == TType.STOP:
10980 
        break
10981 
      if fid == 1:
10982 
        if ftype == TType.I64:
3064 chandransh 10983 
          self.transactionId = iprot.readI64();
494 rajveer 10984 
        else:
10985 
          iprot.skip(ftype)
10986 
      elif fid == 2:
3064 chandransh 10987 
        if ftype == TType.I64:
10988 
          self.customerId = iprot.readI64();
494 rajveer 10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      else:
10992 
        iprot.skip(ftype)
10993 
      iprot.readFieldEnd()
10994 
    iprot.readStructEnd()
10995 
 
10996 
  def write(self, oprot):
10997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10999 
      return
3064 chandransh 11000 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11001 
    if self.transactionId is not None:
3064 chandransh 11002 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11003 
      oprot.writeI64(self.transactionId)
494 rajveer 11004 
      oprot.writeFieldEnd()
3431 rajveer 11005 
    if self.customerId is not None:
3064 chandransh 11006 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11007 
      oprot.writeI64(self.customerId)
494 rajveer 11008 
      oprot.writeFieldEnd()
11009 
    oprot.writeFieldStop()
11010 
    oprot.writeStructEnd()
11011 
 
3431 rajveer 11012 
  def validate(self):
11013 
    return
11014 
 
11015 
 
494 rajveer 11016 
  def __repr__(self):
11017 
    L = ['%s=%r' % (key, value)
11018 
      for key, value in self.__dict__.iteritems()]
11019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11020 
 
11021 
  def __eq__(self, other):
11022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11023 
 
11024 
  def __ne__(self, other):
11025 
    return not (self == other)
11026 
 
3064 chandransh 11027 
class getOrdersForTransaction_result:
494 rajveer 11028 
  """
11029 
  Attributes:
11030 
   - success
11031 
   - ex
11032 
  """
11033 
 
11034 
  thrift_spec = (
3064 chandransh 11035 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11037 
  )
11038 
 
11039 
  def __init__(self, success=None, ex=None,):
11040 
    self.success = success
11041 
    self.ex = ex
11042 
 
11043 
  def read(self, iprot):
11044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11046 
      return
11047 
    iprot.readStructBegin()
11048 
    while True:
11049 
      (fname, ftype, fid) = iprot.readFieldBegin()
11050 
      if ftype == TType.STOP:
11051 
        break
11052 
      if fid == 0:
3064 chandransh 11053 
        if ftype == TType.LIST:
11054 
          self.success = []
6188 rajveer 11055 
          (_etype186, _size183) = iprot.readListBegin()
11056 
          for _i187 in xrange(_size183):
11057 
            _elem188 = Order()
11058 
            _elem188.read(iprot)
11059 
            self.success.append(_elem188)
3064 chandransh 11060 
          iprot.readListEnd()
494 rajveer 11061 
        else:
11062 
          iprot.skip(ftype)
11063 
      elif fid == 1:
11064 
        if ftype == TType.STRUCT:
11065 
          self.ex = TransactionServiceException()
11066 
          self.ex.read(iprot)
11067 
        else:
11068 
          iprot.skip(ftype)
11069 
      else:
11070 
        iprot.skip(ftype)
11071 
      iprot.readFieldEnd()
11072 
    iprot.readStructEnd()
11073 
 
11074 
  def write(self, oprot):
11075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11077 
      return
3064 chandransh 11078 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11079 
    if self.success is not None:
3064 chandransh 11080 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11081 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11082 
      for iter189 in self.success:
11083 
        iter189.write(oprot)
3064 chandransh 11084 
      oprot.writeListEnd()
494 rajveer 11085 
      oprot.writeFieldEnd()
3431 rajveer 11086 
    if self.ex is not None:
494 rajveer 11087 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11088 
      self.ex.write(oprot)
11089 
      oprot.writeFieldEnd()
11090 
    oprot.writeFieldStop()
11091 
    oprot.writeStructEnd()
11092 
 
3431 rajveer 11093 
  def validate(self):
11094 
    return
11095 
 
11096 
 
494 rajveer 11097 
  def __repr__(self):
11098 
    L = ['%s=%r' % (key, value)
11099 
      for key, value in self.__dict__.iteritems()]
11100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11101 
 
11102 
  def __eq__(self, other):
11103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11104 
 
11105 
  def __ne__(self, other):
11106 
    return not (self == other)
11107 
 
3064 chandransh 11108 
class getOrdersForCustomer_args:
1149 chandransh 11109 
  """
11110 
  Attributes:
3064 chandransh 11111 
   - customerId
11112 
   - from_date
11113 
   - to_date
11114 
   - statuses
1149 chandransh 11115 
  """
11116 
 
11117 
  thrift_spec = (
11118 
    None, # 0
3064 chandransh 11119 
    (1, TType.I64, 'customerId', None, None, ), # 1
11120 
    (2, TType.I64, 'from_date', None, None, ), # 2
11121 
    (3, TType.I64, 'to_date', None, None, ), # 3
11122 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11123 
  )
11124 
 
3064 chandransh 11125 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11126 
    self.customerId = customerId
11127 
    self.from_date = from_date
11128 
    self.to_date = to_date
11129 
    self.statuses = statuses
1149 chandransh 11130 
 
11131 
  def read(self, iprot):
11132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11134 
      return
11135 
    iprot.readStructBegin()
11136 
    while True:
11137 
      (fname, ftype, fid) = iprot.readFieldBegin()
11138 
      if ftype == TType.STOP:
11139 
        break
11140 
      if fid == 1:
11141 
        if ftype == TType.I64:
3064 chandransh 11142 
          self.customerId = iprot.readI64();
1149 chandransh 11143 
        else:
11144 
          iprot.skip(ftype)
11145 
      elif fid == 2:
11146 
        if ftype == TType.I64:
3064 chandransh 11147 
          self.from_date = iprot.readI64();
1149 chandransh 11148 
        else:
11149 
          iprot.skip(ftype)
2783 chandransh 11150 
      elif fid == 3:
11151 
        if ftype == TType.I64:
3064 chandransh 11152 
          self.to_date = iprot.readI64();
2783 chandransh 11153 
        else:
11154 
          iprot.skip(ftype)
11155 
      elif fid == 4:
3064 chandransh 11156 
        if ftype == TType.LIST:
11157 
          self.statuses = []
6188 rajveer 11158 
          (_etype193, _size190) = iprot.readListBegin()
11159 
          for _i194 in xrange(_size190):
11160 
            _elem195 = iprot.readI32();
11161 
            self.statuses.append(_elem195)
3064 chandransh 11162 
          iprot.readListEnd()
2783 chandransh 11163 
        else:
11164 
          iprot.skip(ftype)
1149 chandransh 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_args')
3431 rajveer 11175 
    if self.customerId is not None:
3064 chandransh 11176 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11177 
      oprot.writeI64(self.customerId)
1149 chandransh 11178 
      oprot.writeFieldEnd()
3431 rajveer 11179 
    if self.from_date is not None:
3064 chandransh 11180 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11181 
      oprot.writeI64(self.from_date)
1149 chandransh 11182 
      oprot.writeFieldEnd()
3431 rajveer 11183 
    if self.to_date is not None:
3064 chandransh 11184 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11185 
      oprot.writeI64(self.to_date)
2783 chandransh 11186 
      oprot.writeFieldEnd()
3431 rajveer 11187 
    if self.statuses is not None:
3064 chandransh 11188 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11189 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11190 
      for iter196 in self.statuses:
11191 
        oprot.writeI32(iter196)
3064 chandransh 11192 
      oprot.writeListEnd()
2783 chandransh 11193 
      oprot.writeFieldEnd()
1149 chandransh 11194 
    oprot.writeFieldStop()
11195 
    oprot.writeStructEnd()
11196 
 
3431 rajveer 11197 
  def validate(self):
11198 
    return
11199 
 
11200 
 
1149 chandransh 11201 
  def __repr__(self):
11202 
    L = ['%s=%r' % (key, value)
11203 
      for key, value in self.__dict__.iteritems()]
11204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11205 
 
11206 
  def __eq__(self, other):
11207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11208 
 
11209 
  def __ne__(self, other):
11210 
    return not (self == other)
11211 
 
3064 chandransh 11212 
class getOrdersForCustomer_result:
1149 chandransh 11213 
  """
11214 
  Attributes:
11215 
   - success
11216 
   - ex
11217 
  """
11218 
 
11219 
  thrift_spec = (
3064 chandransh 11220 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11222 
  )
11223 
 
11224 
  def __init__(self, success=None, ex=None,):
11225 
    self.success = success
11226 
    self.ex = ex
11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
11237 
      if fid == 0:
3064 chandransh 11238 
        if ftype == TType.LIST:
11239 
          self.success = []
6188 rajveer 11240 
          (_etype200, _size197) = iprot.readListBegin()
11241 
          for _i201 in xrange(_size197):
11242 
            _elem202 = Order()
11243 
            _elem202.read(iprot)
11244 
            self.success.append(_elem202)
3064 chandransh 11245 
          iprot.readListEnd()
1149 chandransh 11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      elif fid == 1:
11249 
        if ftype == TType.STRUCT:
11250 
          self.ex = TransactionServiceException()
11251 
          self.ex.read(iprot)
11252 
        else:
11253 
          iprot.skip(ftype)
11254 
      else:
11255 
        iprot.skip(ftype)
11256 
      iprot.readFieldEnd()
11257 
    iprot.readStructEnd()
11258 
 
11259 
  def write(self, oprot):
11260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11262 
      return
3064 chandransh 11263 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11264 
    if self.success is not None:
3064 chandransh 11265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11267 
      for iter203 in self.success:
11268 
        iter203.write(oprot)
3064 chandransh 11269 
      oprot.writeListEnd()
1149 chandransh 11270 
      oprot.writeFieldEnd()
3431 rajveer 11271 
    if self.ex is not None:
1149 chandransh 11272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11273 
      self.ex.write(oprot)
11274 
      oprot.writeFieldEnd()
11275 
    oprot.writeFieldStop()
11276 
    oprot.writeStructEnd()
11277 
 
3431 rajveer 11278 
  def validate(self):
11279 
    return
11280 
 
11281 
 
1149 chandransh 11282 
  def __repr__(self):
11283 
    L = ['%s=%r' % (key, value)
11284 
      for key, value in self.__dict__.iteritems()]
11285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11286 
 
11287 
  def __eq__(self, other):
11288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11289 
 
11290 
  def __ne__(self, other):
11291 
    return not (self == other)
11292 
 
3064 chandransh 11293 
class createOrder_args:
921 rajveer 11294 
  """
11295 
  Attributes:
3064 chandransh 11296 
   - order
921 rajveer 11297 
  """
11298 
 
11299 
  thrift_spec = (
11300 
    None, # 0
3064 chandransh 11301 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11302 
  )
11303 
 
3064 chandransh 11304 
  def __init__(self, order=None,):
11305 
    self.order = order
921 rajveer 11306 
 
11307 
  def read(self, iprot):
11308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11310 
      return
11311 
    iprot.readStructBegin()
11312 
    while True:
11313 
      (fname, ftype, fid) = iprot.readFieldBegin()
11314 
      if ftype == TType.STOP:
11315 
        break
11316 
      if fid == 1:
3064 chandransh 11317 
        if ftype == TType.STRUCT:
11318 
          self.order = Order()
11319 
          self.order.read(iprot)
921 rajveer 11320 
        else:
11321 
          iprot.skip(ftype)
11322 
      else:
11323 
        iprot.skip(ftype)
11324 
      iprot.readFieldEnd()
11325 
    iprot.readStructEnd()
11326 
 
11327 
  def write(self, oprot):
11328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11330 
      return
3064 chandransh 11331 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11332 
    if self.order is not None:
3064 chandransh 11333 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11334 
      self.order.write(oprot)
921 rajveer 11335 
      oprot.writeFieldEnd()
11336 
    oprot.writeFieldStop()
11337 
    oprot.writeStructEnd()
11338 
 
3431 rajveer 11339 
  def validate(self):
11340 
    return
11341 
 
11342 
 
921 rajveer 11343 
  def __repr__(self):
11344 
    L = ['%s=%r' % (key, value)
11345 
      for key, value in self.__dict__.iteritems()]
11346 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11347 
 
11348 
  def __eq__(self, other):
11349 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11350 
 
11351 
  def __ne__(self, other):
11352 
    return not (self == other)
11353 
 
3064 chandransh 11354 
class createOrder_result:
921 rajveer 11355 
  """
11356 
  Attributes:
11357 
   - success
11358 
   - ex
11359 
  """
11360 
 
11361 
  thrift_spec = (
3064 chandransh 11362 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11363 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11364 
  )
11365 
 
11366 
  def __init__(self, success=None, ex=None,):
11367 
    self.success = success
11368 
    self.ex = ex
11369 
 
11370 
  def read(self, iprot):
11371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11373 
      return
11374 
    iprot.readStructBegin()
11375 
    while True:
11376 
      (fname, ftype, fid) = iprot.readFieldBegin()
11377 
      if ftype == TType.STOP:
11378 
        break
11379 
      if fid == 0:
3064 chandransh 11380 
        if ftype == TType.I64:
11381 
          self.success = iprot.readI64();
921 rajveer 11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      elif fid == 1:
11385 
        if ftype == TType.STRUCT:
11386 
          self.ex = TransactionServiceException()
11387 
          self.ex.read(iprot)
11388 
        else:
11389 
          iprot.skip(ftype)
11390 
      else:
11391 
        iprot.skip(ftype)
11392 
      iprot.readFieldEnd()
11393 
    iprot.readStructEnd()
11394 
 
11395 
  def write(self, oprot):
11396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11398 
      return
3064 chandransh 11399 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11400 
    if self.success is not None:
3064 chandransh 11401 
      oprot.writeFieldBegin('success', TType.I64, 0)
11402 
      oprot.writeI64(self.success)
921 rajveer 11403 
      oprot.writeFieldEnd()
3431 rajveer 11404 
    if self.ex is not None:
921 rajveer 11405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11406 
      self.ex.write(oprot)
11407 
      oprot.writeFieldEnd()
11408 
    oprot.writeFieldStop()
11409 
    oprot.writeStructEnd()
11410 
 
3431 rajveer 11411 
  def validate(self):
11412 
    return
11413 
 
11414 
 
921 rajveer 11415 
  def __repr__(self):
11416 
    L = ['%s=%r' % (key, value)
11417 
      for key, value in self.__dict__.iteritems()]
11418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11419 
 
11420 
  def __eq__(self, other):
11421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11422 
 
11423 
  def __ne__(self, other):
11424 
    return not (self == other)
11425 
 
3064 chandransh 11426 
class getOrder_args:
921 rajveer 11427 
  """
11428 
  Attributes:
3064 chandransh 11429 
   - id
921 rajveer 11430 
  """
11431 
 
11432 
  thrift_spec = (
11433 
    None, # 0
3064 chandransh 11434 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11435 
  )
11436 
 
3064 chandransh 11437 
  def __init__(self, id=None,):
11438 
    self.id = id
921 rajveer 11439 
 
11440 
  def read(self, iprot):
11441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11443 
      return
11444 
    iprot.readStructBegin()
11445 
    while True:
11446 
      (fname, ftype, fid) = iprot.readFieldBegin()
11447 
      if ftype == TType.STOP:
11448 
        break
11449 
      if fid == 1:
11450 
        if ftype == TType.I64:
3064 chandransh 11451 
          self.id = iprot.readI64();
921 rajveer 11452 
        else:
11453 
          iprot.skip(ftype)
11454 
      else:
11455 
        iprot.skip(ftype)
11456 
      iprot.readFieldEnd()
11457 
    iprot.readStructEnd()
11458 
 
11459 
  def write(self, oprot):
11460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11462 
      return
3064 chandransh 11463 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11464 
    if self.id is not None:
3064 chandransh 11465 
      oprot.writeFieldBegin('id', TType.I64, 1)
11466 
      oprot.writeI64(self.id)
921 rajveer 11467 
      oprot.writeFieldEnd()
11468 
    oprot.writeFieldStop()
11469 
    oprot.writeStructEnd()
11470 
 
3431 rajveer 11471 
  def validate(self):
11472 
    return
11473 
 
11474 
 
921 rajveer 11475 
  def __repr__(self):
11476 
    L = ['%s=%r' % (key, value)
11477 
      for key, value in self.__dict__.iteritems()]
11478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11479 
 
11480 
  def __eq__(self, other):
11481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11482 
 
11483 
  def __ne__(self, other):
11484 
    return not (self == other)
11485 
 
3064 chandransh 11486 
class getOrder_result:
921 rajveer 11487 
  """
11488 
  Attributes:
11489 
   - success
11490 
   - ex
11491 
  """
11492 
 
11493 
  thrift_spec = (
3064 chandransh 11494 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11496 
  )
11497 
 
11498 
  def __init__(self, success=None, ex=None,):
11499 
    self.success = success
11500 
    self.ex = ex
11501 
 
11502 
  def read(self, iprot):
11503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11505 
      return
11506 
    iprot.readStructBegin()
11507 
    while True:
11508 
      (fname, ftype, fid) = iprot.readFieldBegin()
11509 
      if ftype == TType.STOP:
11510 
        break
11511 
      if fid == 0:
3064 chandransh 11512 
        if ftype == TType.STRUCT:
11513 
          self.success = Order()
11514 
          self.success.read(iprot)
921 rajveer 11515 
        else:
11516 
          iprot.skip(ftype)
11517 
      elif fid == 1:
11518 
        if ftype == TType.STRUCT:
11519 
          self.ex = TransactionServiceException()
11520 
          self.ex.read(iprot)
11521 
        else:
11522 
          iprot.skip(ftype)
11523 
      else:
11524 
        iprot.skip(ftype)
11525 
      iprot.readFieldEnd()
11526 
    iprot.readStructEnd()
11527 
 
11528 
  def write(self, oprot):
11529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11531 
      return
3064 chandransh 11532 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11533 
    if self.success is not None:
3064 chandransh 11534 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11535 
      self.success.write(oprot)
921 rajveer 11536 
      oprot.writeFieldEnd()
3431 rajveer 11537 
    if self.ex is not None:
921 rajveer 11538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11539 
      self.ex.write(oprot)
11540 
      oprot.writeFieldEnd()
11541 
    oprot.writeFieldStop()
11542 
    oprot.writeStructEnd()
11543 
 
3431 rajveer 11544 
  def validate(self):
11545 
    return
11546 
 
11547 
 
921 rajveer 11548 
  def __repr__(self):
11549 
    L = ['%s=%r' % (key, value)
11550 
      for key, value in self.__dict__.iteritems()]
11551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11552 
 
11553 
  def __eq__(self, other):
11554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11555 
 
11556 
  def __ne__(self, other):
11557 
    return not (self == other)
11558 
 
3064 chandransh 11559 
class getLineItemsForOrder_args:
94 ashish 11560 
  """
11561 
  Attributes:
3064 chandransh 11562 
   - orderId
94 ashish 11563 
  """
11564 
 
11565 
  thrift_spec = (
11566 
    None, # 0
3064 chandransh 11567 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11568 
  )
11569 
 
3064 chandransh 11570 
  def __init__(self, orderId=None,):
11571 
    self.orderId = orderId
94 ashish 11572 
 
11573 
  def read(self, iprot):
11574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11576 
      return
11577 
    iprot.readStructBegin()
11578 
    while True:
11579 
      (fname, ftype, fid) = iprot.readFieldBegin()
11580 
      if ftype == TType.STOP:
11581 
        break
11582 
      if fid == 1:
11583 
        if ftype == TType.I64:
3064 chandransh 11584 
          self.orderId = iprot.readI64();
94 ashish 11585 
        else:
11586 
          iprot.skip(ftype)
11587 
      else:
11588 
        iprot.skip(ftype)
11589 
      iprot.readFieldEnd()
11590 
    iprot.readStructEnd()
11591 
 
11592 
  def write(self, oprot):
11593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11595 
      return
3064 chandransh 11596 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11597 
    if self.orderId is not None:
3064 chandransh 11598 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11599 
      oprot.writeI64(self.orderId)
94 ashish 11600 
      oprot.writeFieldEnd()
11601 
    oprot.writeFieldStop()
11602 
    oprot.writeStructEnd()
11603 
 
3431 rajveer 11604 
  def validate(self):
11605 
    return
11606 
 
11607 
 
94 ashish 11608 
  def __repr__(self):
11609 
    L = ['%s=%r' % (key, value)
11610 
      for key, value in self.__dict__.iteritems()]
11611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11612 
 
11613 
  def __eq__(self, other):
11614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11615 
 
11616 
  def __ne__(self, other):
11617 
    return not (self == other)
11618 
 
3064 chandransh 11619 
class getLineItemsForOrder_result:
94 ashish 11620 
  """
11621 
  Attributes:
11622 
   - success
11623 
   - ex
11624 
  """
11625 
 
11626 
  thrift_spec = (
3064 chandransh 11627 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11628 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11629 
  )
11630 
 
11631 
  def __init__(self, success=None, ex=None,):
11632 
    self.success = success
11633 
    self.ex = ex
11634 
 
11635 
  def read(self, iprot):
11636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11638 
      return
11639 
    iprot.readStructBegin()
11640 
    while True:
11641 
      (fname, ftype, fid) = iprot.readFieldBegin()
11642 
      if ftype == TType.STOP:
11643 
        break
11644 
      if fid == 0:
483 rajveer 11645 
        if ftype == TType.LIST:
11646 
          self.success = []
6188 rajveer 11647 
          (_etype207, _size204) = iprot.readListBegin()
11648 
          for _i208 in xrange(_size204):
11649 
            _elem209 = LineItem()
11650 
            _elem209.read(iprot)
11651 
            self.success.append(_elem209)
483 rajveer 11652 
          iprot.readListEnd()
94 ashish 11653 
        else:
11654 
          iprot.skip(ftype)
11655 
      elif fid == 1:
11656 
        if ftype == TType.STRUCT:
11657 
          self.ex = TransactionServiceException()
11658 
          self.ex.read(iprot)
11659 
        else:
11660 
          iprot.skip(ftype)
11661 
      else:
11662 
        iprot.skip(ftype)
11663 
      iprot.readFieldEnd()
11664 
    iprot.readStructEnd()
11665 
 
11666 
  def write(self, oprot):
11667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11669 
      return
3064 chandransh 11670 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11671 
    if self.success is not None:
483 rajveer 11672 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11673 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11674 
      for iter210 in self.success:
11675 
        iter210.write(oprot)
483 rajveer 11676 
      oprot.writeListEnd()
94 ashish 11677 
      oprot.writeFieldEnd()
3431 rajveer 11678 
    if self.ex is not None:
94 ashish 11679 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11680 
      self.ex.write(oprot)
11681 
      oprot.writeFieldEnd()
11682 
    oprot.writeFieldStop()
11683 
    oprot.writeStructEnd()
11684 
 
3431 rajveer 11685 
  def validate(self):
11686 
    return
11687 
 
11688 
 
94 ashish 11689 
  def __repr__(self):
11690 
    L = ['%s=%r' % (key, value)
11691 
      for key, value in self.__dict__.iteritems()]
11692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11693 
 
11694 
  def __eq__(self, other):
11695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11696 
 
11697 
  def __ne__(self, other):
11698 
    return not (self == other)
11699 
 
4999 phani.kuma 11700 
class getOrderList_args:
11701 
  """
11702 
  Attributes:
11703 
   - order_ids
11704 
  """
11705 
 
11706 
  thrift_spec = (
11707 
    None, # 0
11708 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11709 
  )
11710 
 
11711 
  def __init__(self, order_ids=None,):
11712 
    self.order_ids = order_ids
11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 1:
11724 
        if ftype == TType.LIST:
11725 
          self.order_ids = []
6188 rajveer 11726 
          (_etype214, _size211) = iprot.readListBegin()
11727 
          for _i215 in xrange(_size211):
11728 
            _elem216 = iprot.readI64();
11729 
            self.order_ids.append(_elem216)
4999 phani.kuma 11730 
          iprot.readListEnd()
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      else:
11734 
        iprot.skip(ftype)
11735 
      iprot.readFieldEnd()
11736 
    iprot.readStructEnd()
11737 
 
11738 
  def write(self, oprot):
11739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11741 
      return
11742 
    oprot.writeStructBegin('getOrderList_args')
11743 
    if self.order_ids is not None:
11744 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11745 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11746 
      for iter217 in self.order_ids:
11747 
        oprot.writeI64(iter217)
4999 phani.kuma 11748 
      oprot.writeListEnd()
11749 
      oprot.writeFieldEnd()
11750 
    oprot.writeFieldStop()
11751 
    oprot.writeStructEnd()
11752 
 
11753 
  def validate(self):
11754 
    return
11755 
 
11756 
 
11757 
  def __repr__(self):
11758 
    L = ['%s=%r' % (key, value)
11759 
      for key, value in self.__dict__.iteritems()]
11760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11761 
 
11762 
  def __eq__(self, other):
11763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11764 
 
11765 
  def __ne__(self, other):
11766 
    return not (self == other)
11767 
 
11768 
class getOrderList_result:
11769 
  """
11770 
  Attributes:
11771 
   - success
11772 
  """
11773 
 
11774 
  thrift_spec = (
11775 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11776 
  )
11777 
 
11778 
  def __init__(self, success=None,):
11779 
    self.success = success
11780 
 
11781 
  def read(self, iprot):
11782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11784 
      return
11785 
    iprot.readStructBegin()
11786 
    while True:
11787 
      (fname, ftype, fid) = iprot.readFieldBegin()
11788 
      if ftype == TType.STOP:
11789 
        break
11790 
      if fid == 0:
11791 
        if ftype == TType.LIST:
11792 
          self.success = []
6188 rajveer 11793 
          (_etype221, _size218) = iprot.readListBegin()
11794 
          for _i222 in xrange(_size218):
11795 
            _elem223 = Order()
11796 
            _elem223.read(iprot)
11797 
            self.success.append(_elem223)
4999 phani.kuma 11798 
          iprot.readListEnd()
11799 
        else:
11800 
          iprot.skip(ftype)
11801 
      else:
11802 
        iprot.skip(ftype)
11803 
      iprot.readFieldEnd()
11804 
    iprot.readStructEnd()
11805 
 
11806 
  def write(self, oprot):
11807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11809 
      return
11810 
    oprot.writeStructBegin('getOrderList_result')
11811 
    if self.success is not None:
11812 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11813 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11814 
      for iter224 in self.success:
11815 
        iter224.write(oprot)
4999 phani.kuma 11816 
      oprot.writeListEnd()
11817 
      oprot.writeFieldEnd()
11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
5386 phani.kuma 11836 
class getOrderListForVendor_args:
11837 
  """
11838 
  Attributes:
11839 
   - order_ids
11840 
   - vendorId
11841 
  """
11842 
 
11843 
  thrift_spec = (
11844 
    None, # 0
11845 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11846 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11847 
  )
11848 
 
11849 
  def __init__(self, order_ids=None, vendorId=None,):
11850 
    self.order_ids = order_ids
11851 
    self.vendorId = vendorId
11852 
 
11853 
  def read(self, iprot):
11854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11856 
      return
11857 
    iprot.readStructBegin()
11858 
    while True:
11859 
      (fname, ftype, fid) = iprot.readFieldBegin()
11860 
      if ftype == TType.STOP:
11861 
        break
11862 
      if fid == 1:
11863 
        if ftype == TType.LIST:
11864 
          self.order_ids = []
6188 rajveer 11865 
          (_etype228, _size225) = iprot.readListBegin()
11866 
          for _i229 in xrange(_size225):
11867 
            _elem230 = iprot.readI64();
11868 
            self.order_ids.append(_elem230)
5386 phani.kuma 11869 
          iprot.readListEnd()
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      elif fid == 2:
11873 
        if ftype == TType.I64:
11874 
          self.vendorId = iprot.readI64();
11875 
        else:
11876 
          iprot.skip(ftype)
11877 
      else:
11878 
        iprot.skip(ftype)
11879 
      iprot.readFieldEnd()
11880 
    iprot.readStructEnd()
11881 
 
11882 
  def write(self, oprot):
11883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11885 
      return
11886 
    oprot.writeStructBegin('getOrderListForVendor_args')
11887 
    if self.order_ids is not None:
11888 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11889 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11890 
      for iter231 in self.order_ids:
11891 
        oprot.writeI64(iter231)
5386 phani.kuma 11892 
      oprot.writeListEnd()
11893 
      oprot.writeFieldEnd()
11894 
    if self.vendorId is not None:
11895 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11896 
      oprot.writeI64(self.vendorId)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def validate(self):
11902 
    return
11903 
 
11904 
 
11905 
  def __repr__(self):
11906 
    L = ['%s=%r' % (key, value)
11907 
      for key, value in self.__dict__.iteritems()]
11908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11909 
 
11910 
  def __eq__(self, other):
11911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11912 
 
11913 
  def __ne__(self, other):
11914 
    return not (self == other)
11915 
 
11916 
class getOrderListForVendor_result:
11917 
  """
11918 
  Attributes:
11919 
   - success
11920 
  """
11921 
 
11922 
  thrift_spec = (
11923 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11924 
  )
11925 
 
11926 
  def __init__(self, success=None,):
11927 
    self.success = success
11928 
 
11929 
  def read(self, iprot):
11930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11932 
      return
11933 
    iprot.readStructBegin()
11934 
    while True:
11935 
      (fname, ftype, fid) = iprot.readFieldBegin()
11936 
      if ftype == TType.STOP:
11937 
        break
11938 
      if fid == 0:
11939 
        if ftype == TType.LIST:
11940 
          self.success = []
6188 rajveer 11941 
          (_etype235, _size232) = iprot.readListBegin()
11942 
          for _i236 in xrange(_size232):
11943 
            _elem237 = Order()
11944 
            _elem237.read(iprot)
11945 
            self.success.append(_elem237)
5386 phani.kuma 11946 
          iprot.readListEnd()
11947 
        else:
11948 
          iprot.skip(ftype)
11949 
      else:
11950 
        iprot.skip(ftype)
11951 
      iprot.readFieldEnd()
11952 
    iprot.readStructEnd()
11953 
 
11954 
  def write(self, oprot):
11955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11957 
      return
11958 
    oprot.writeStructBegin('getOrderListForVendor_result')
11959 
    if self.success is not None:
11960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11962 
      for iter238 in self.success:
11963 
        iter238.write(oprot)
5386 phani.kuma 11964 
      oprot.writeListEnd()
11965 
      oprot.writeFieldEnd()
11966 
    oprot.writeFieldStop()
11967 
    oprot.writeStructEnd()
11968 
 
11969 
  def validate(self):
11970 
    return
11971 
 
11972 
 
11973 
  def __repr__(self):
11974 
    L = ['%s=%r' % (key, value)
11975 
      for key, value in self.__dict__.iteritems()]
11976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11977 
 
11978 
  def __eq__(self, other):
11979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11980 
 
11981 
  def __ne__(self, other):
11982 
    return not (self == other)
11983 
 
3064 chandransh 11984 
class getOrderForCustomer_args:
94 ashish 11985 
  """
11986 
  Attributes:
3064 chandransh 11987 
   - orderId
483 rajveer 11988 
   - customerId
94 ashish 11989 
  """
11990 
 
11991 
  thrift_spec = (
11992 
    None, # 0
3064 chandransh 11993 
    (1, TType.I64, 'orderId', None, None, ), # 1
11994 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11995 
  )
11996 
 
3064 chandransh 11997 
  def __init__(self, orderId=None, customerId=None,):
11998 
    self.orderId = orderId
483 rajveer 11999 
    self.customerId = customerId
94 ashish 12000 
 
12001 
  def read(self, iprot):
12002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12004 
      return
12005 
    iprot.readStructBegin()
12006 
    while True:
12007 
      (fname, ftype, fid) = iprot.readFieldBegin()
12008 
      if ftype == TType.STOP:
12009 
        break
12010 
      if fid == 1:
12011 
        if ftype == TType.I64:
3064 chandransh 12012 
          self.orderId = iprot.readI64();
94 ashish 12013 
        else:
12014 
          iprot.skip(ftype)
12015 
      elif fid == 2:
12016 
        if ftype == TType.I64:
3064 chandransh 12017 
          self.customerId = iprot.readI64();
94 ashish 12018 
        else:
12019 
          iprot.skip(ftype)
12020 
      else:
12021 
        iprot.skip(ftype)
12022 
      iprot.readFieldEnd()
12023 
    iprot.readStructEnd()
12024 
 
12025 
  def write(self, oprot):
12026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12028 
      return
3064 chandransh 12029 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12030 
    if self.orderId is not None:
3064 chandransh 12031 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12032 
      oprot.writeI64(self.orderId)
12033 
      oprot.writeFieldEnd()
3431 rajveer 12034 
    if self.customerId is not None:
3064 chandransh 12035 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12036 
      oprot.writeI64(self.customerId)
94 ashish 12037 
      oprot.writeFieldEnd()
12038 
    oprot.writeFieldStop()
12039 
    oprot.writeStructEnd()
12040 
 
3431 rajveer 12041 
  def validate(self):
12042 
    return
12043 
 
12044 
 
94 ashish 12045 
  def __repr__(self):
12046 
    L = ['%s=%r' % (key, value)
12047 
      for key, value in self.__dict__.iteritems()]
12048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12049 
 
12050 
  def __eq__(self, other):
12051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12052 
 
12053 
  def __ne__(self, other):
12054 
    return not (self == other)
12055 
 
3064 chandransh 12056 
class getOrderForCustomer_result:
94 ashish 12057 
  """
12058 
  Attributes:
12059 
   - success
12060 
   - ex
12061 
  """
12062 
 
12063 
  thrift_spec = (
3064 chandransh 12064 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12066 
  )
12067 
 
12068 
  def __init__(self, success=None, ex=None,):
12069 
    self.success = success
12070 
    self.ex = ex
12071 
 
12072 
  def read(self, iprot):
12073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12075 
      return
12076 
    iprot.readStructBegin()
12077 
    while True:
12078 
      (fname, ftype, fid) = iprot.readFieldBegin()
12079 
      if ftype == TType.STOP:
12080 
        break
12081 
      if fid == 0:
3064 chandransh 12082 
        if ftype == TType.STRUCT:
12083 
          self.success = Order()
12084 
          self.success.read(iprot)
94 ashish 12085 
        else:
12086 
          iprot.skip(ftype)
12087 
      elif fid == 1:
12088 
        if ftype == TType.STRUCT:
12089 
          self.ex = TransactionServiceException()
12090 
          self.ex.read(iprot)
12091 
        else:
12092 
          iprot.skip(ftype)
12093 
      else:
12094 
        iprot.skip(ftype)
12095 
      iprot.readFieldEnd()
12096 
    iprot.readStructEnd()
12097 
 
12098 
  def write(self, oprot):
12099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12101 
      return
3064 chandransh 12102 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12103 
    if self.success is not None:
3064 chandransh 12104 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12105 
      self.success.write(oprot)
94 ashish 12106 
      oprot.writeFieldEnd()
3431 rajveer 12107 
    if self.ex is not None:
94 ashish 12108 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12109 
      self.ex.write(oprot)
12110 
      oprot.writeFieldEnd()
12111 
    oprot.writeFieldStop()
12112 
    oprot.writeStructEnd()
12113 
 
3431 rajveer 12114 
  def validate(self):
12115 
    return
12116 
 
12117 
 
94 ashish 12118 
  def __repr__(self):
12119 
    L = ['%s=%r' % (key, value)
12120 
      for key, value in self.__dict__.iteritems()]
12121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12122 
 
12123 
  def __eq__(self, other):
12124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12125 
 
12126 
  def __ne__(self, other):
12127 
    return not (self == other)
12128 
 
3064 chandransh 12129 
class getAlerts_args:
94 ashish 12130 
  """
12131 
  Attributes:
4394 rajveer 12132 
   - type
4444 rajveer 12133 
   - warehouseId
4394 rajveer 12134 
   - status
12135 
   - timestamp
94 ashish 12136 
  """
12137 
 
12138 
  thrift_spec = (
12139 
    None, # 0
4394 rajveer 12140 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12141 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12142 
    (3, TType.I64, 'status', None, None, ), # 3
12143 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12144 
  )
12145 
 
4444 rajveer 12146 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12147 
    self.type = type
4444 rajveer 12148 
    self.warehouseId = warehouseId
4394 rajveer 12149 
    self.status = status
12150 
    self.timestamp = timestamp
94 ashish 12151 
 
12152 
  def read(self, iprot):
12153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12155 
      return
12156 
    iprot.readStructBegin()
12157 
    while True:
12158 
      (fname, ftype, fid) = iprot.readFieldBegin()
12159 
      if ftype == TType.STOP:
12160 
        break
12161 
      if fid == 1:
3064 chandransh 12162 
        if ftype == TType.I64:
4394 rajveer 12163 
          self.type = iprot.readI64();
94 ashish 12164 
        else:
12165 
          iprot.skip(ftype)
3064 chandransh 12166 
      elif fid == 2:
4394 rajveer 12167 
        if ftype == TType.I64:
4444 rajveer 12168 
          self.warehouseId = iprot.readI64();
3064 chandransh 12169 
        else:
12170 
          iprot.skip(ftype)
4394 rajveer 12171 
      elif fid == 3:
12172 
        if ftype == TType.I64:
4444 rajveer 12173 
          self.status = iprot.readI64();
12174 
        else:
12175 
          iprot.skip(ftype)
12176 
      elif fid == 4:
12177 
        if ftype == TType.I64:
4394 rajveer 12178 
          self.timestamp = iprot.readI64();
12179 
        else:
12180 
          iprot.skip(ftype)
94 ashish 12181 
      else:
12182 
        iprot.skip(ftype)
12183 
      iprot.readFieldEnd()
12184 
    iprot.readStructEnd()
12185 
 
12186 
  def write(self, oprot):
12187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12189 
      return
3064 chandransh 12190 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12191 
    if self.type is not None:
12192 
      oprot.writeFieldBegin('type', TType.I64, 1)
12193 
      oprot.writeI64(self.type)
94 ashish 12194 
      oprot.writeFieldEnd()
4444 rajveer 12195 
    if self.warehouseId is not None:
12196 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12197 
      oprot.writeI64(self.warehouseId)
12198 
      oprot.writeFieldEnd()
4394 rajveer 12199 
    if self.status is not None:
4444 rajveer 12200 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12201 
      oprot.writeI64(self.status)
3064 chandransh 12202 
      oprot.writeFieldEnd()
4394 rajveer 12203 
    if self.timestamp is not None:
4444 rajveer 12204 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12205 
      oprot.writeI64(self.timestamp)
12206 
      oprot.writeFieldEnd()
94 ashish 12207 
    oprot.writeFieldStop()
12208 
    oprot.writeStructEnd()
12209 
 
3431 rajveer 12210 
  def validate(self):
12211 
    return
12212 
 
12213 
 
94 ashish 12214 
  def __repr__(self):
12215 
    L = ['%s=%r' % (key, value)
12216 
      for key, value in self.__dict__.iteritems()]
12217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12218 
 
12219 
  def __eq__(self, other):
12220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12221 
 
12222 
  def __ne__(self, other):
12223 
    return not (self == other)
12224 
 
3064 chandransh 12225 
class getAlerts_result:
94 ashish 12226 
  """
12227 
  Attributes:
12228 
   - success
12229 
  """
12230 
 
12231 
  thrift_spec = (
3064 chandransh 12232 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12233 
  )
12234 
 
3064 chandransh 12235 
  def __init__(self, success=None,):
94 ashish 12236 
    self.success = success
12237 
 
12238 
  def read(self, iprot):
12239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12241 
      return
12242 
    iprot.readStructBegin()
12243 
    while True:
12244 
      (fname, ftype, fid) = iprot.readFieldBegin()
12245 
      if ftype == TType.STOP:
12246 
        break
12247 
      if fid == 0:
3064 chandransh 12248 
        if ftype == TType.LIST:
12249 
          self.success = []
6188 rajveer 12250 
          (_etype242, _size239) = iprot.readListBegin()
12251 
          for _i243 in xrange(_size239):
12252 
            _elem244 = Alert()
12253 
            _elem244.read(iprot)
12254 
            self.success.append(_elem244)
3064 chandransh 12255 
          iprot.readListEnd()
94 ashish 12256 
        else:
12257 
          iprot.skip(ftype)
12258 
      else:
12259 
        iprot.skip(ftype)
12260 
      iprot.readFieldEnd()
12261 
    iprot.readStructEnd()
12262 
 
12263 
  def write(self, oprot):
12264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12266 
      return
3064 chandransh 12267 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12268 
    if self.success is not None:
3064 chandransh 12269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12271 
      for iter245 in self.success:
12272 
        iter245.write(oprot)
3064 chandransh 12273 
      oprot.writeListEnd()
94 ashish 12274 
      oprot.writeFieldEnd()
12275 
    oprot.writeFieldStop()
12276 
    oprot.writeStructEnd()
12277 
 
3431 rajveer 12278 
  def validate(self):
12279 
    return
12280 
 
12281 
 
94 ashish 12282 
  def __repr__(self):
12283 
    L = ['%s=%r' % (key, value)
12284 
      for key, value in self.__dict__.iteritems()]
12285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12286 
 
12287 
  def __eq__(self, other):
12288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12289 
 
12290 
  def __ne__(self, other):
12291 
    return not (self == other)
12292 
 
4394 rajveer 12293 
class addAlert_args:
94 ashish 12294 
  """
12295 
  Attributes:
3064 chandransh 12296 
   - type
4444 rajveer 12297 
   - warehouseId
4394 rajveer 12298 
   - description
94 ashish 12299 
  """
12300 
 
12301 
  thrift_spec = (
12302 
    None, # 0
4394 rajveer 12303 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12304 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12305 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12306 
  )
12307 
 
4444 rajveer 12308 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12309 
    self.type = type
4444 rajveer 12310 
    self.warehouseId = warehouseId
4394 rajveer 12311 
    self.description = description
94 ashish 12312 
 
12313 
  def read(self, iprot):
12314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12316 
      return
12317 
    iprot.readStructBegin()
12318 
    while True:
12319 
      (fname, ftype, fid) = iprot.readFieldBegin()
12320 
      if ftype == TType.STOP:
12321 
        break
12322 
      if fid == 1:
12323 
        if ftype == TType.I64:
4394 rajveer 12324 
          self.type = iprot.readI64();
94 ashish 12325 
        else:
12326 
          iprot.skip(ftype)
3064 chandransh 12327 
      elif fid == 2:
4444 rajveer 12328 
        if ftype == TType.I64:
12329 
          self.warehouseId = iprot.readI64();
12330 
        else:
12331 
          iprot.skip(ftype)
12332 
      elif fid == 3:
3064 chandransh 12333 
        if ftype == TType.STRING:
4394 rajveer 12334 
          self.description = iprot.readString();
3064 chandransh 12335 
        else:
12336 
          iprot.skip(ftype)
94 ashish 12337 
      else:
12338 
        iprot.skip(ftype)
12339 
      iprot.readFieldEnd()
12340 
    iprot.readStructEnd()
12341 
 
12342 
  def write(self, oprot):
12343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12345 
      return
4394 rajveer 12346 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12347 
    if self.type is not None:
4394 rajveer 12348 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12349 
      oprot.writeI64(self.type)
12350 
      oprot.writeFieldEnd()
4444 rajveer 12351 
    if self.warehouseId is not None:
12352 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12353 
      oprot.writeI64(self.warehouseId)
12354 
      oprot.writeFieldEnd()
4394 rajveer 12355 
    if self.description is not None:
4444 rajveer 12356 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12357 
      oprot.writeString(self.description)
3064 chandransh 12358 
      oprot.writeFieldEnd()
94 ashish 12359 
    oprot.writeFieldStop()
12360 
    oprot.writeStructEnd()
12361 
 
3431 rajveer 12362 
  def validate(self):
12363 
    return
12364 
 
12365 
 
94 ashish 12366 
  def __repr__(self):
12367 
    L = ['%s=%r' % (key, value)
12368 
      for key, value in self.__dict__.iteritems()]
12369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12370 
 
12371 
  def __eq__(self, other):
12372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12373 
 
12374 
  def __ne__(self, other):
12375 
    return not (self == other)
12376 
 
4394 rajveer 12377 
class addAlert_result:
3064 chandransh 12378 
 
12379 
  thrift_spec = (
12380 
  )
12381 
 
12382 
  def read(self, iprot):
12383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12385 
      return
12386 
    iprot.readStructBegin()
12387 
    while True:
12388 
      (fname, ftype, fid) = iprot.readFieldBegin()
12389 
      if ftype == TType.STOP:
12390 
        break
12391 
      else:
12392 
        iprot.skip(ftype)
12393 
      iprot.readFieldEnd()
12394 
    iprot.readStructEnd()
12395 
 
12396 
  def write(self, oprot):
12397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12399 
      return
4394 rajveer 12400 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12401 
    oprot.writeFieldStop()
12402 
    oprot.writeStructEnd()
12403 
 
3431 rajveer 12404 
  def validate(self):
12405 
    return
12406 
 
12407 
 
3064 chandransh 12408 
  def __repr__(self):
12409 
    L = ['%s=%r' % (key, value)
12410 
      for key, value in self.__dict__.iteritems()]
12411 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12412 
 
12413 
  def __eq__(self, other):
12414 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12415 
 
12416 
  def __ne__(self, other):
12417 
    return not (self == other)
12418 
 
4444 rajveer 12419 
class markAlertsAsSeen_args:
12420 
  """
12421 
  Attributes:
12422 
   - warehouseId
12423 
  """
12424 
 
12425 
  thrift_spec = (
12426 
    None, # 0
12427 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12428 
  )
12429 
 
12430 
  def __init__(self, warehouseId=None,):
12431 
    self.warehouseId = warehouseId
12432 
 
12433 
  def read(self, iprot):
12434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12436 
      return
12437 
    iprot.readStructBegin()
12438 
    while True:
12439 
      (fname, ftype, fid) = iprot.readFieldBegin()
12440 
      if ftype == TType.STOP:
12441 
        break
12442 
      if fid == 1:
12443 
        if ftype == TType.I64:
12444 
          self.warehouseId = iprot.readI64();
12445 
        else:
12446 
          iprot.skip(ftype)
12447 
      else:
12448 
        iprot.skip(ftype)
12449 
      iprot.readFieldEnd()
12450 
    iprot.readStructEnd()
12451 
 
12452 
  def write(self, oprot):
12453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12455 
      return
12456 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12457 
    if self.warehouseId is not None:
12458 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12459 
      oprot.writeI64(self.warehouseId)
12460 
      oprot.writeFieldEnd()
12461 
    oprot.writeFieldStop()
12462 
    oprot.writeStructEnd()
12463 
 
12464 
  def validate(self):
12465 
    return
12466 
 
12467 
 
12468 
  def __repr__(self):
12469 
    L = ['%s=%r' % (key, value)
12470 
      for key, value in self.__dict__.iteritems()]
12471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12472 
 
12473 
  def __eq__(self, other):
12474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12475 
 
12476 
  def __ne__(self, other):
12477 
    return not (self == other)
12478 
 
12479 
class markAlertsAsSeen_result:
12480 
 
12481 
  thrift_spec = (
12482 
  )
12483 
 
12484 
  def read(self, iprot):
12485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12487 
      return
12488 
    iprot.readStructBegin()
12489 
    while True:
12490 
      (fname, ftype, fid) = iprot.readFieldBegin()
12491 
      if ftype == TType.STOP:
12492 
        break
12493 
      else:
12494 
        iprot.skip(ftype)
12495 
      iprot.readFieldEnd()
12496 
    iprot.readStructEnd()
12497 
 
12498 
  def write(self, oprot):
12499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12501 
      return
12502 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12503 
    oprot.writeFieldStop()
12504 
    oprot.writeStructEnd()
12505 
 
12506 
  def validate(self):
12507 
    return
12508 
 
12509 
 
12510 
  def __repr__(self):
12511 
    L = ['%s=%r' % (key, value)
12512 
      for key, value in self.__dict__.iteritems()]
12513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12514 
 
12515 
  def __eq__(self, other):
12516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12517 
 
12518 
  def __ne__(self, other):
12519 
    return not (self == other)
12520 
 
3064 chandransh 12521 
class getValidOrderCount_args:
12522 
 
12523 
  thrift_spec = (
12524 
  )
12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      else:
12536 
        iprot.skip(ftype)
12537 
      iprot.readFieldEnd()
12538 
    iprot.readStructEnd()
12539 
 
12540 
  def write(self, oprot):
12541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12543 
      return
12544 
    oprot.writeStructBegin('getValidOrderCount_args')
12545 
    oprot.writeFieldStop()
12546 
    oprot.writeStructEnd()
12547 
 
3431 rajveer 12548 
  def validate(self):
12549 
    return
12550 
 
12551 
 
3064 chandransh 12552 
  def __repr__(self):
12553 
    L = ['%s=%r' % (key, value)
12554 
      for key, value in self.__dict__.iteritems()]
12555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12556 
 
12557 
  def __eq__(self, other):
12558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12559 
 
12560 
  def __ne__(self, other):
12561 
    return not (self == other)
12562 
 
12563 
class getValidOrderCount_result:
94 ashish 12564 
  """
12565 
  Attributes:
12566 
   - success
12567 
  """
12568 
 
12569 
  thrift_spec = (
3064 chandransh 12570 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12571 
  )
12572 
 
3064 chandransh 12573 
  def __init__(self, success=None,):
94 ashish 12574 
    self.success = success
12575 
 
12576 
  def read(self, iprot):
12577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12579 
      return
12580 
    iprot.readStructBegin()
12581 
    while True:
12582 
      (fname, ftype, fid) = iprot.readFieldBegin()
12583 
      if ftype == TType.STOP:
12584 
        break
12585 
      if fid == 0:
3064 chandransh 12586 
        if ftype == TType.I64:
12587 
          self.success = iprot.readI64();
94 ashish 12588 
        else:
12589 
          iprot.skip(ftype)
12590 
      else:
12591 
        iprot.skip(ftype)
12592 
      iprot.readFieldEnd()
12593 
    iprot.readStructEnd()
12594 
 
12595 
  def write(self, oprot):
12596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12598 
      return
3064 chandransh 12599 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12600 
    if self.success is not None:
3064 chandransh 12601 
      oprot.writeFieldBegin('success', TType.I64, 0)
12602 
      oprot.writeI64(self.success)
94 ashish 12603 
      oprot.writeFieldEnd()
12604 
    oprot.writeFieldStop()
12605 
    oprot.writeStructEnd()
12606 
 
3431 rajveer 12607 
  def validate(self):
12608 
    return
12609 
 
12610 
 
94 ashish 12611 
  def __repr__(self):
12612 
    L = ['%s=%r' % (key, value)
12613 
      for key, value in self.__dict__.iteritems()]
12614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12615 
 
12616 
  def __eq__(self, other):
12617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12618 
 
12619 
  def __ne__(self, other):
12620 
    return not (self == other)
12621 
 
3064 chandransh 12622 
class getNoOfCustomersWithSuccessfulTransaction_args:
12623 
 
12624 
  thrift_spec = (
12625 
  )
12626 
 
12627 
  def read(self, iprot):
12628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12630 
      return
12631 
    iprot.readStructBegin()
12632 
    while True:
12633 
      (fname, ftype, fid) = iprot.readFieldBegin()
12634 
      if ftype == TType.STOP:
12635 
        break
12636 
      else:
12637 
        iprot.skip(ftype)
12638 
      iprot.readFieldEnd()
12639 
    iprot.readStructEnd()
12640 
 
12641 
  def write(self, oprot):
12642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12644 
      return
12645 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12646 
    oprot.writeFieldStop()
12647 
    oprot.writeStructEnd()
12648 
 
3431 rajveer 12649 
  def validate(self):
12650 
    return
12651 
 
12652 
 
3064 chandransh 12653 
  def __repr__(self):
12654 
    L = ['%s=%r' % (key, value)
12655 
      for key, value in self.__dict__.iteritems()]
12656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12657 
 
12658 
  def __eq__(self, other):
12659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12660 
 
12661 
  def __ne__(self, other):
12662 
    return not (self == other)
12663 
 
12664 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12665 
  """
12666 
  Attributes:
3064 chandransh 12667 
   - success
94 ashish 12668 
  """
12669 
 
12670 
  thrift_spec = (
3064 chandransh 12671 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12672 
  )
12673 
 
3064 chandransh 12674 
  def __init__(self, success=None,):
12675 
    self.success = success
94 ashish 12676 
 
12677 
  def read(self, iprot):
12678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12680 
      return
12681 
    iprot.readStructBegin()
12682 
    while True:
12683 
      (fname, ftype, fid) = iprot.readFieldBegin()
12684 
      if ftype == TType.STOP:
12685 
        break
3064 chandransh 12686 
      if fid == 0:
94 ashish 12687 
        if ftype == TType.I64:
3064 chandransh 12688 
          self.success = iprot.readI64();
94 ashish 12689 
        else:
12690 
          iprot.skip(ftype)
12691 
      else:
12692 
        iprot.skip(ftype)
12693 
      iprot.readFieldEnd()
12694 
    iprot.readStructEnd()
12695 
 
12696 
  def write(self, oprot):
12697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12699 
      return
3064 chandransh 12700 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12701 
    if self.success is not None:
3064 chandransh 12702 
      oprot.writeFieldBegin('success', TType.I64, 0)
12703 
      oprot.writeI64(self.success)
94 ashish 12704 
      oprot.writeFieldEnd()
12705 
    oprot.writeFieldStop()
12706 
    oprot.writeStructEnd()
12707 
 
3431 rajveer 12708 
  def validate(self):
12709 
    return
12710 
 
12711 
 
94 ashish 12712 
  def __repr__(self):
12713 
    L = ['%s=%r' % (key, value)
12714 
      for key, value in self.__dict__.iteritems()]
12715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12716 
 
12717 
  def __eq__(self, other):
12718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12719 
 
12720 
  def __ne__(self, other):
12721 
    return not (self == other)
12722 
 
3064 chandransh 12723 
class getValidOrdersAmountRange_args:
12724 
 
12725 
  thrift_spec = (
12726 
  )
12727 
 
12728 
  def read(self, iprot):
12729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12731 
      return
12732 
    iprot.readStructBegin()
12733 
    while True:
12734 
      (fname, ftype, fid) = iprot.readFieldBegin()
12735 
      if ftype == TType.STOP:
12736 
        break
12737 
      else:
12738 
        iprot.skip(ftype)
12739 
      iprot.readFieldEnd()
12740 
    iprot.readStructEnd()
12741 
 
12742 
  def write(self, oprot):
12743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12745 
      return
12746 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12747 
    oprot.writeFieldStop()
12748 
    oprot.writeStructEnd()
12749 
 
3431 rajveer 12750 
  def validate(self):
12751 
    return
12752 
 
12753 
 
3064 chandransh 12754 
  def __repr__(self):
12755 
    L = ['%s=%r' % (key, value)
12756 
      for key, value in self.__dict__.iteritems()]
12757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12758 
 
12759 
  def __eq__(self, other):
12760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12761 
 
12762 
  def __ne__(self, other):
12763 
    return not (self == other)
12764 
 
12765 
class getValidOrdersAmountRange_result:
94 ashish 12766 
  """
12767 
  Attributes:
12768 
   - success
12769 
  """
12770 
 
12771 
  thrift_spec = (
3064 chandransh 12772 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12773 
  )
12774 
 
3064 chandransh 12775 
  def __init__(self, success=None,):
94 ashish 12776 
    self.success = success
12777 
 
12778 
  def read(self, iprot):
12779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12781 
      return
12782 
    iprot.readStructBegin()
12783 
    while True:
12784 
      (fname, ftype, fid) = iprot.readFieldBegin()
12785 
      if ftype == TType.STOP:
12786 
        break
12787 
      if fid == 0:
483 rajveer 12788 
        if ftype == TType.LIST:
12789 
          self.success = []
6188 rajveer 12790 
          (_etype249, _size246) = iprot.readListBegin()
12791 
          for _i250 in xrange(_size246):
12792 
            _elem251 = iprot.readDouble();
12793 
            self.success.append(_elem251)
483 rajveer 12794 
          iprot.readListEnd()
94 ashish 12795 
        else:
12796 
          iprot.skip(ftype)
12797 
      else:
12798 
        iprot.skip(ftype)
12799 
      iprot.readFieldEnd()
12800 
    iprot.readStructEnd()
12801 
 
12802 
  def write(self, oprot):
12803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12805 
      return
3064 chandransh 12806 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12807 
    if self.success is not None:
483 rajveer 12808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12809 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12810 
      for iter252 in self.success:
12811 
        oprot.writeDouble(iter252)
483 rajveer 12812 
      oprot.writeListEnd()
94 ashish 12813 
      oprot.writeFieldEnd()
12814 
    oprot.writeFieldStop()
12815 
    oprot.writeStructEnd()
12816 
 
3431 rajveer 12817 
  def validate(self):
12818 
    return
12819 
 
12820 
 
94 ashish 12821 
  def __repr__(self):
12822 
    L = ['%s=%r' % (key, value)
12823 
      for key, value in self.__dict__.iteritems()]
12824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12825 
 
12826 
  def __eq__(self, other):
12827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12828 
 
12829 
  def __ne__(self, other):
12830 
    return not (self == other)
12831 
 
3064 chandransh 12832 
class getValidOrders_args:
1528 ankur.sing 12833 
  """
12834 
  Attributes:
3064 chandransh 12835 
   - limit
5874 rajveer 12836 
   - onlyStore
1528 ankur.sing 12837 
  """
12838 
 
12839 
  thrift_spec = (
12840 
    None, # 0
3064 chandransh 12841 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12842 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12843 
  )
12844 
 
5874 rajveer 12845 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12846 
    self.limit = limit
5874 rajveer 12847 
    self.onlyStore = onlyStore
1528 ankur.sing 12848 
 
12849 
  def read(self, iprot):
12850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12852 
      return
12853 
    iprot.readStructBegin()
12854 
    while True:
12855 
      (fname, ftype, fid) = iprot.readFieldBegin()
12856 
      if ftype == TType.STOP:
12857 
        break
12858 
      if fid == 1:
12859 
        if ftype == TType.I64:
3064 chandransh 12860 
          self.limit = iprot.readI64();
1528 ankur.sing 12861 
        else:
12862 
          iprot.skip(ftype)
5874 rajveer 12863 
      elif fid == 2:
12864 
        if ftype == TType.BOOL:
12865 
          self.onlyStore = iprot.readBool();
12866 
        else:
12867 
          iprot.skip(ftype)
1528 ankur.sing 12868 
      else:
12869 
        iprot.skip(ftype)
12870 
      iprot.readFieldEnd()
12871 
    iprot.readStructEnd()
12872 
 
12873 
  def write(self, oprot):
12874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12876 
      return
3064 chandransh 12877 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12878 
    if self.limit is not None:
3064 chandransh 12879 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12880 
      oprot.writeI64(self.limit)
1528 ankur.sing 12881 
      oprot.writeFieldEnd()
5874 rajveer 12882 
    if self.onlyStore is not None:
12883 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12884 
      oprot.writeBool(self.onlyStore)
12885 
      oprot.writeFieldEnd()
1528 ankur.sing 12886 
    oprot.writeFieldStop()
12887 
    oprot.writeStructEnd()
12888 
 
3431 rajveer 12889 
  def validate(self):
12890 
    return
12891 
 
12892 
 
1528 ankur.sing 12893 
  def __repr__(self):
12894 
    L = ['%s=%r' % (key, value)
12895 
      for key, value in self.__dict__.iteritems()]
12896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12897 
 
12898 
  def __eq__(self, other):
12899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12900 
 
12901 
  def __ne__(self, other):
12902 
    return not (self == other)
12903 
 
3064 chandransh 12904 
class getValidOrders_result:
1528 ankur.sing 12905 
  """
12906 
  Attributes:
12907 
   - success
12908 
  """
12909 
 
12910 
  thrift_spec = (
3064 chandransh 12911 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12912 
  )
12913 
 
3064 chandransh 12914 
  def __init__(self, success=None,):
1528 ankur.sing 12915 
    self.success = success
12916 
 
12917 
  def read(self, iprot):
12918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12920 
      return
12921 
    iprot.readStructBegin()
12922 
    while True:
12923 
      (fname, ftype, fid) = iprot.readFieldBegin()
12924 
      if ftype == TType.STOP:
12925 
        break
12926 
      if fid == 0:
3064 chandransh 12927 
        if ftype == TType.LIST:
12928 
          self.success = []
6188 rajveer 12929 
          (_etype256, _size253) = iprot.readListBegin()
12930 
          for _i257 in xrange(_size253):
12931 
            _elem258 = Order()
12932 
            _elem258.read(iprot)
12933 
            self.success.append(_elem258)
3064 chandransh 12934 
          iprot.readListEnd()
1528 ankur.sing 12935 
        else:
12936 
          iprot.skip(ftype)
12937 
      else:
12938 
        iprot.skip(ftype)
12939 
      iprot.readFieldEnd()
12940 
    iprot.readStructEnd()
12941 
 
12942 
  def write(self, oprot):
12943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12945 
      return
3064 chandransh 12946 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12947 
    if self.success is not None:
3064 chandransh 12948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12949 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12950 
      for iter259 in self.success:
12951 
        iter259.write(oprot)
3064 chandransh 12952 
      oprot.writeListEnd()
1528 ankur.sing 12953 
      oprot.writeFieldEnd()
12954 
    oprot.writeFieldStop()
12955 
    oprot.writeStructEnd()
12956 
 
3431 rajveer 12957 
  def validate(self):
12958 
    return
12959 
 
12960 
 
1528 ankur.sing 12961 
  def __repr__(self):
12962 
    L = ['%s=%r' % (key, value)
12963 
      for key, value in self.__dict__.iteritems()]
12964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12965 
 
12966 
  def __eq__(self, other):
12967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12968 
 
12969 
  def __ne__(self, other):
12970 
    return not (self == other)
12971 
 
1220 chandransh 12972 
class batchOrders_args:
12973 
  """
12974 
  Attributes:
12975 
   - warehouseId
12976 
  """
12977 
 
12978 
  thrift_spec = (
12979 
    None, # 0
12980 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12981 
  )
12982 
 
12983 
  def __init__(self, warehouseId=None,):
12984 
    self.warehouseId = warehouseId
12985 
 
12986 
  def read(self, iprot):
12987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12989 
      return
12990 
    iprot.readStructBegin()
12991 
    while True:
12992 
      (fname, ftype, fid) = iprot.readFieldBegin()
12993 
      if ftype == TType.STOP:
12994 
        break
12995 
      if fid == 1:
12996 
        if ftype == TType.I64:
12997 
          self.warehouseId = iprot.readI64();
12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
13009 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13010 
    if self.warehouseId is not None:
1220 chandransh 13011 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13012 
      oprot.writeI64(self.warehouseId)
13013 
      oprot.writeFieldEnd()
13014 
    oprot.writeFieldStop()
13015 
    oprot.writeStructEnd()
13016 
 
3431 rajveer 13017 
  def validate(self):
13018 
    return
13019 
 
13020 
 
1220 chandransh 13021 
  def __repr__(self):
13022 
    L = ['%s=%r' % (key, value)
13023 
      for key, value in self.__dict__.iteritems()]
13024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13025 
 
13026 
  def __eq__(self, other):
13027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13028 
 
13029 
  def __ne__(self, other):
13030 
    return not (self == other)
13031 
 
13032 
class batchOrders_result:
13033 
  """
13034 
  Attributes:
13035 
   - success
13036 
   - ex
13037 
  """
13038 
 
13039 
  thrift_spec = (
13040 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13042 
  )
13043 
 
13044 
  def __init__(self, success=None, ex=None,):
13045 
    self.success = success
13046 
    self.ex = ex
13047 
 
13048 
  def read(self, iprot):
13049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13051 
      return
13052 
    iprot.readStructBegin()
13053 
    while True:
13054 
      (fname, ftype, fid) = iprot.readFieldBegin()
13055 
      if ftype == TType.STOP:
13056 
        break
13057 
      if fid == 0:
13058 
        if ftype == TType.LIST:
13059 
          self.success = []
6188 rajveer 13060 
          (_etype263, _size260) = iprot.readListBegin()
13061 
          for _i264 in xrange(_size260):
13062 
            _elem265 = Order()
13063 
            _elem265.read(iprot)
13064 
            self.success.append(_elem265)
1220 chandransh 13065 
          iprot.readListEnd()
13066 
        else:
13067 
          iprot.skip(ftype)
13068 
      elif fid == 1:
13069 
        if ftype == TType.STRUCT:
13070 
          self.ex = TransactionServiceException()
13071 
          self.ex.read(iprot)
13072 
        else:
13073 
          iprot.skip(ftype)
13074 
      else:
13075 
        iprot.skip(ftype)
13076 
      iprot.readFieldEnd()
13077 
    iprot.readStructEnd()
13078 
 
13079 
  def write(self, oprot):
13080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13082 
      return
13083 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13084 
    if self.success is not None:
1220 chandransh 13085 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13086 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13087 
      for iter266 in self.success:
13088 
        iter266.write(oprot)
1220 chandransh 13089 
      oprot.writeListEnd()
13090 
      oprot.writeFieldEnd()
3431 rajveer 13091 
    if self.ex is not None:
1220 chandransh 13092 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13093 
      self.ex.write(oprot)
13094 
      oprot.writeFieldEnd()
13095 
    oprot.writeFieldStop()
13096 
    oprot.writeStructEnd()
13097 
 
3431 rajveer 13098 
  def validate(self):
13099 
    return
13100 
 
13101 
 
1220 chandransh 13102 
  def __repr__(self):
13103 
    L = ['%s=%r' % (key, value)
13104 
      for key, value in self.__dict__.iteritems()]
13105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13106 
 
13107 
  def __eq__(self, other):
13108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13109 
 
13110 
  def __ne__(self, other):
13111 
    return not (self == other)
13112 
 
1208 chandransh 13113 
class markOrderAsOutOfStock_args:
13114 
  """
13115 
  Attributes:
13116 
   - orderId
13117 
  """
13118 
 
13119 
  thrift_spec = (
13120 
    None, # 0
13121 
    (1, TType.I64, 'orderId', None, None, ), # 1
13122 
  )
13123 
 
13124 
  def __init__(self, orderId=None,):
13125 
    self.orderId = orderId
13126 
 
13127 
  def read(self, iprot):
13128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13130 
      return
13131 
    iprot.readStructBegin()
13132 
    while True:
13133 
      (fname, ftype, fid) = iprot.readFieldBegin()
13134 
      if ftype == TType.STOP:
13135 
        break
13136 
      if fid == 1:
13137 
        if ftype == TType.I64:
13138 
          self.orderId = iprot.readI64();
13139 
        else:
13140 
          iprot.skip(ftype)
13141 
      else:
13142 
        iprot.skip(ftype)
13143 
      iprot.readFieldEnd()
13144 
    iprot.readStructEnd()
13145 
 
13146 
  def write(self, oprot):
13147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13149 
      return
13150 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13151 
    if self.orderId is not None:
1208 chandransh 13152 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13153 
      oprot.writeI64(self.orderId)
13154 
      oprot.writeFieldEnd()
13155 
    oprot.writeFieldStop()
13156 
    oprot.writeStructEnd()
13157 
 
3431 rajveer 13158 
  def validate(self):
13159 
    return
13160 
 
13161 
 
1208 chandransh 13162 
  def __repr__(self):
13163 
    L = ['%s=%r' % (key, value)
13164 
      for key, value in self.__dict__.iteritems()]
13165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13166 
 
13167 
  def __eq__(self, other):
13168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13169 
 
13170 
  def __ne__(self, other):
13171 
    return not (self == other)
13172 
 
13173 
class markOrderAsOutOfStock_result:
13174 
  """
13175 
  Attributes:
13176 
   - success
13177 
   - ex
13178 
  """
13179 
 
13180 
  thrift_spec = (
13181 
    (0, TType.BOOL, 'success', None, None, ), # 0
13182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13183 
  )
13184 
 
13185 
  def __init__(self, success=None, ex=None,):
13186 
    self.success = success
13187 
    self.ex = ex
13188 
 
13189 
  def read(self, iprot):
13190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13192 
      return
13193 
    iprot.readStructBegin()
13194 
    while True:
13195 
      (fname, ftype, fid) = iprot.readFieldBegin()
13196 
      if ftype == TType.STOP:
13197 
        break
13198 
      if fid == 0:
13199 
        if ftype == TType.BOOL:
13200 
          self.success = iprot.readBool();
13201 
        else:
13202 
          iprot.skip(ftype)
13203 
      elif fid == 1:
13204 
        if ftype == TType.STRUCT:
13205 
          self.ex = TransactionServiceException()
13206 
          self.ex.read(iprot)
13207 
        else:
13208 
          iprot.skip(ftype)
13209 
      else:
13210 
        iprot.skip(ftype)
13211 
      iprot.readFieldEnd()
13212 
    iprot.readStructEnd()
13213 
 
13214 
  def write(self, oprot):
13215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13217 
      return
13218 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13219 
    if self.success is not None:
1208 chandransh 13220 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13221 
      oprot.writeBool(self.success)
13222 
      oprot.writeFieldEnd()
3431 rajveer 13223 
    if self.ex is not None:
1208 chandransh 13224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13225 
      self.ex.write(oprot)
13226 
      oprot.writeFieldEnd()
13227 
    oprot.writeFieldStop()
13228 
    oprot.writeStructEnd()
13229 
 
3431 rajveer 13230 
  def validate(self):
13231 
    return
13232 
 
13233 
 
1208 chandransh 13234 
  def __repr__(self):
13235 
    L = ['%s=%r' % (key, value)
13236 
      for key, value in self.__dict__.iteritems()]
13237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13238 
 
13239 
  def __eq__(self, other):
13240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13241 
 
13242 
  def __ne__(self, other):
13243 
    return not (self == other)
13244 
 
3064 chandransh 13245 
class verifyOrder_args:
759 chandransh 13246 
  """
13247 
  Attributes:
3064 chandransh 13248 
   - orderId
759 chandransh 13249 
  """
13250 
 
13251 
  thrift_spec = (
13252 
    None, # 0
3064 chandransh 13253 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13254 
  )
13255 
 
3064 chandransh 13256 
  def __init__(self, orderId=None,):
13257 
    self.orderId = orderId
759 chandransh 13258 
 
13259 
  def read(self, iprot):
13260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13262 
      return
13263 
    iprot.readStructBegin()
13264 
    while True:
13265 
      (fname, ftype, fid) = iprot.readFieldBegin()
13266 
      if ftype == TType.STOP:
13267 
        break
13268 
      if fid == 1:
13269 
        if ftype == TType.I64:
3064 chandransh 13270 
          self.orderId = iprot.readI64();
759 chandransh 13271 
        else:
13272 
          iprot.skip(ftype)
13273 
      else:
13274 
        iprot.skip(ftype)
13275 
      iprot.readFieldEnd()
13276 
    iprot.readStructEnd()
13277 
 
13278 
  def write(self, oprot):
13279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13281 
      return
3064 chandransh 13282 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13283 
    if self.orderId is not None:
3064 chandransh 13284 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13285 
      oprot.writeI64(self.orderId)
759 chandransh 13286 
      oprot.writeFieldEnd()
13287 
    oprot.writeFieldStop()
13288 
    oprot.writeStructEnd()
13289 
 
3431 rajveer 13290 
  def validate(self):
13291 
    return
13292 
 
13293 
 
759 chandransh 13294 
  def __repr__(self):
13295 
    L = ['%s=%r' % (key, value)
13296 
      for key, value in self.__dict__.iteritems()]
13297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13298 
 
13299 
  def __eq__(self, other):
13300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13301 
 
13302 
  def __ne__(self, other):
13303 
    return not (self == other)
13304 
 
3064 chandransh 13305 
class verifyOrder_result:
759 chandransh 13306 
  """
13307 
  Attributes:
13308 
   - success
13309 
   - ex
13310 
  """
13311 
 
13312 
  thrift_spec = (
13313 
    (0, TType.BOOL, 'success', None, None, ), # 0
13314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13315 
  )
13316 
 
13317 
  def __init__(self, success=None, ex=None,):
13318 
    self.success = success
13319 
    self.ex = ex
13320 
 
13321 
  def read(self, iprot):
13322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13324 
      return
13325 
    iprot.readStructBegin()
13326 
    while True:
13327 
      (fname, ftype, fid) = iprot.readFieldBegin()
13328 
      if ftype == TType.STOP:
13329 
        break
13330 
      if fid == 0:
13331 
        if ftype == TType.BOOL:
13332 
          self.success = iprot.readBool();
13333 
        else:
13334 
          iprot.skip(ftype)
13335 
      elif fid == 1:
13336 
        if ftype == TType.STRUCT:
13337 
          self.ex = TransactionServiceException()
13338 
          self.ex.read(iprot)
13339 
        else:
13340 
          iprot.skip(ftype)
13341 
      else:
13342 
        iprot.skip(ftype)
13343 
      iprot.readFieldEnd()
13344 
    iprot.readStructEnd()
13345 
 
13346 
  def write(self, oprot):
13347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13349 
      return
3064 chandransh 13350 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13351 
    if self.success is not None:
759 chandransh 13352 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13353 
      oprot.writeBool(self.success)
13354 
      oprot.writeFieldEnd()
3431 rajveer 13355 
    if self.ex is not None:
759 chandransh 13356 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13357 
      self.ex.write(oprot)
13358 
      oprot.writeFieldEnd()
13359 
    oprot.writeFieldStop()
13360 
    oprot.writeStructEnd()
13361 
 
3431 rajveer 13362 
  def validate(self):
13363 
    return
13364 
 
13365 
 
759 chandransh 13366 
  def __repr__(self):
13367 
    L = ['%s=%r' % (key, value)
13368 
      for key, value in self.__dict__.iteritems()]
13369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13370 
 
13371 
  def __eq__(self, other):
13372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13373 
 
13374 
  def __ne__(self, other):
13375 
    return not (self == other)
13376 
 
3064 chandransh 13377 
class acceptOrder_args:
1113 chandransh 13378 
  """
13379 
  Attributes:
3064 chandransh 13380 
   - orderId
1113 chandransh 13381 
  """
13382 
 
13383 
  thrift_spec = (
13384 
    None, # 0
3064 chandransh 13385 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13386 
  )
13387 
 
3064 chandransh 13388 
  def __init__(self, orderId=None,):
13389 
    self.orderId = orderId
1113 chandransh 13390 
 
13391 
  def read(self, iprot):
13392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13394 
      return
13395 
    iprot.readStructBegin()
13396 
    while True:
13397 
      (fname, ftype, fid) = iprot.readFieldBegin()
13398 
      if ftype == TType.STOP:
13399 
        break
13400 
      if fid == 1:
13401 
        if ftype == TType.I64:
3064 chandransh 13402 
          self.orderId = iprot.readI64();
1113 chandransh 13403 
        else:
13404 
          iprot.skip(ftype)
13405 
      else:
13406 
        iprot.skip(ftype)
13407 
      iprot.readFieldEnd()
13408 
    iprot.readStructEnd()
13409 
 
13410 
  def write(self, oprot):
13411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13413 
      return
3064 chandransh 13414 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13415 
    if self.orderId is not None:
3064 chandransh 13416 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13417 
      oprot.writeI64(self.orderId)
1113 chandransh 13418 
      oprot.writeFieldEnd()
13419 
    oprot.writeFieldStop()
13420 
    oprot.writeStructEnd()
13421 
 
3431 rajveer 13422 
  def validate(self):
13423 
    return
13424 
 
13425 
 
1113 chandransh 13426 
  def __repr__(self):
13427 
    L = ['%s=%r' % (key, value)
13428 
      for key, value in self.__dict__.iteritems()]
13429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13430 
 
13431 
  def __eq__(self, other):
13432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13433 
 
13434 
  def __ne__(self, other):
13435 
    return not (self == other)
13436 
 
3064 chandransh 13437 
class acceptOrder_result:
1113 chandransh 13438 
  """
13439 
  Attributes:
13440 
   - success
13441 
   - ex
13442 
  """
13443 
 
13444 
  thrift_spec = (
3064 chandransh 13445 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13446 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13447 
  )
13448 
 
13449 
  def __init__(self, success=None, ex=None,):
13450 
    self.success = success
13451 
    self.ex = ex
13452 
 
13453 
  def read(self, iprot):
13454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13456 
      return
13457 
    iprot.readStructBegin()
13458 
    while True:
13459 
      (fname, ftype, fid) = iprot.readFieldBegin()
13460 
      if ftype == TType.STOP:
13461 
        break
13462 
      if fid == 0:
3064 chandransh 13463 
        if ftype == TType.BOOL:
13464 
          self.success = iprot.readBool();
1113 chandransh 13465 
        else:
13466 
          iprot.skip(ftype)
13467 
      elif fid == 1:
13468 
        if ftype == TType.STRUCT:
13469 
          self.ex = TransactionServiceException()
13470 
          self.ex.read(iprot)
13471 
        else:
13472 
          iprot.skip(ftype)
13473 
      else:
13474 
        iprot.skip(ftype)
13475 
      iprot.readFieldEnd()
13476 
    iprot.readStructEnd()
13477 
 
13478 
  def write(self, oprot):
13479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13481 
      return
3064 chandransh 13482 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13483 
    if self.success is not None:
3064 chandransh 13484 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13485 
      oprot.writeBool(self.success)
1113 chandransh 13486 
      oprot.writeFieldEnd()
3431 rajveer 13487 
    if self.ex is not None:
1113 chandransh 13488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13489 
      self.ex.write(oprot)
13490 
      oprot.writeFieldEnd()
13491 
    oprot.writeFieldStop()
13492 
    oprot.writeStructEnd()
13493 
 
3431 rajveer 13494 
  def validate(self):
13495 
    return
13496 
 
13497 
 
1113 chandransh 13498 
  def __repr__(self):
13499 
    L = ['%s=%r' % (key, value)
13500 
      for key, value in self.__dict__.iteritems()]
13501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13502 
 
13503 
  def __eq__(self, other):
13504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13505 
 
13506 
  def __ne__(self, other):
13507 
    return not (self == other)
13508 
 
3064 chandransh 13509 
class addBillingDetails_args:
1135 chandransh 13510 
  """
13511 
  Attributes:
3064 chandransh 13512 
   - orderId
13513 
   - invoice_number
4658 mandeep.dh 13514 
   - serialNumber
4283 anupam.sin 13515 
   - itemNumber
3064 chandransh 13516 
   - billed_by
4264 rajveer 13517 
   - jacketNumber
4283 anupam.sin 13518 
   - billingType
5110 mandeep.dh 13519 
   - fulfilmentWarehouseId
4763 rajveer 13520 
   - authorize
1135 chandransh 13521 
  """
13522 
 
13523 
  thrift_spec = (
13524 
    None, # 0
3064 chandransh 13525 
    (1, TType.I64, 'orderId', None, None, ), # 1
13526 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13527 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13528 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13529 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13530 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13531 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13532 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13533 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13534 
  )
13535 
 
5110 mandeep.dh 13536 
  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 13537 
    self.orderId = orderId
13538 
    self.invoice_number = invoice_number
4658 mandeep.dh 13539 
    self.serialNumber = serialNumber
4283 anupam.sin 13540 
    self.itemNumber = itemNumber
3064 chandransh 13541 
    self.billed_by = billed_by
4264 rajveer 13542 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13543 
    self.billingType = billingType
5110 mandeep.dh 13544 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13545 
    self.authorize = authorize
1135 chandransh 13546 
 
13547 
  def read(self, iprot):
13548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13550 
      return
13551 
    iprot.readStructBegin()
13552 
    while True:
13553 
      (fname, ftype, fid) = iprot.readFieldBegin()
13554 
      if ftype == TType.STOP:
13555 
        break
13556 
      if fid == 1:
13557 
        if ftype == TType.I64:
3064 chandransh 13558 
          self.orderId = iprot.readI64();
1135 chandransh 13559 
        else:
13560 
          iprot.skip(ftype)
13561 
      elif fid == 2:
3064 chandransh 13562 
        if ftype == TType.STRING:
13563 
          self.invoice_number = iprot.readString();
1135 chandransh 13564 
        else:
13565 
          iprot.skip(ftype)
3064 chandransh 13566 
      elif fid == 3:
5411 rajveer 13567 
        if ftype == TType.LIST:
13568 
          self.serialNumber = []
6188 rajveer 13569 
          (_etype270, _size267) = iprot.readListBegin()
13570 
          for _i271 in xrange(_size267):
13571 
            _elem272 = iprot.readString();
13572 
            self.serialNumber.append(_elem272)
5411 rajveer 13573 
          iprot.readListEnd()
3064 chandransh 13574 
        else:
13575 
          iprot.skip(ftype)
13576 
      elif fid == 4:
5411 rajveer 13577 
        if ftype == TType.LIST:
13578 
          self.itemNumber = []
6188 rajveer 13579 
          (_etype276, _size273) = iprot.readListBegin()
13580 
          for _i277 in xrange(_size273):
13581 
            _elem278 = iprot.readString();
13582 
            self.itemNumber.append(_elem278)
5411 rajveer 13583 
          iprot.readListEnd()
3064 chandransh 13584 
        else:
13585 
          iprot.skip(ftype)
13586 
      elif fid == 5:
13587 
        if ftype == TType.STRING:
4283 anupam.sin 13588 
          self.billed_by = iprot.readString();
3064 chandransh 13589 
        else:
13590 
          iprot.skip(ftype)
13591 
      elif fid == 6:
13592 
        if ftype == TType.I64:
4283 anupam.sin 13593 
          self.jacketNumber = iprot.readI64();
13594 
        else:
13595 
          iprot.skip(ftype)
13596 
      elif fid == 7:
13597 
        if ftype == TType.I64:
3064 chandransh 13598 
          self.billingType = iprot.readI64();
13599 
        else:
13600 
          iprot.skip(ftype)
4283 anupam.sin 13601 
      elif fid == 8:
13602 
        if ftype == TType.I64:
5110 mandeep.dh 13603 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13604 
        else:
13605 
          iprot.skip(ftype)
4763 rajveer 13606 
      elif fid == 9:
13607 
        if ftype == TType.BOOL:
13608 
          self.authorize = iprot.readBool();
13609 
        else:
13610 
          iprot.skip(ftype)
1246 chandransh 13611 
      else:
13612 
        iprot.skip(ftype)
13613 
      iprot.readFieldEnd()
13614 
    iprot.readStructEnd()
13615 
 
13616 
  def write(self, oprot):
13617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13619 
      return
4283 anupam.sin 13620 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13621 
    if self.orderId is not None:
3064 chandransh 13622 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13623 
      oprot.writeI64(self.orderId)
1246 chandransh 13624 
      oprot.writeFieldEnd()
4283 anupam.sin 13625 
    if self.invoice_number is not None:
13626 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13627 
      oprot.writeString(self.invoice_number)
1246 chandransh 13628 
      oprot.writeFieldEnd()
4658 mandeep.dh 13629 
    if self.serialNumber is not None:
5411 rajveer 13630 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13631 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13632 
      for iter279 in self.serialNumber:
13633 
        oprot.writeString(iter279)
5411 rajveer 13634 
      oprot.writeListEnd()
3064 chandransh 13635 
      oprot.writeFieldEnd()
3431 rajveer 13636 
    if self.itemNumber is not None:
5411 rajveer 13637 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13638 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13639 
      for iter280 in self.itemNumber:
13640 
        oprot.writeString(iter280)
5411 rajveer 13641 
      oprot.writeListEnd()
3064 chandransh 13642 
      oprot.writeFieldEnd()
4283 anupam.sin 13643 
    if self.billed_by is not None:
13644 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13645 
      oprot.writeString(self.billed_by)
3064 chandransh 13646 
      oprot.writeFieldEnd()
4283 anupam.sin 13647 
    if self.jacketNumber is not None:
13648 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13649 
      oprot.writeI64(self.jacketNumber)
13650 
      oprot.writeFieldEnd()
3431 rajveer 13651 
    if self.billingType is not None:
4283 anupam.sin 13652 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13653 
      oprot.writeI64(self.billingType)
13654 
      oprot.writeFieldEnd()
5110 mandeep.dh 13655 
    if self.fulfilmentWarehouseId is not None:
13656 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13657 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13658 
      oprot.writeFieldEnd()
4763 rajveer 13659 
    if self.authorize is not None:
13660 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13661 
      oprot.writeBool(self.authorize)
13662 
      oprot.writeFieldEnd()
1246 chandransh 13663 
    oprot.writeFieldStop()
13664 
    oprot.writeStructEnd()
13665 
 
3431 rajveer 13666 
  def validate(self):
13667 
    return
13668 
 
13669 
 
1246 chandransh 13670 
  def __repr__(self):
13671 
    L = ['%s=%r' % (key, value)
13672 
      for key, value in self.__dict__.iteritems()]
13673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13674 
 
13675 
  def __eq__(self, other):
13676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13677 
 
13678 
  def __ne__(self, other):
13679 
    return not (self == other)
13680 
 
4283 anupam.sin 13681 
class addBillingDetails_result:
1246 chandransh 13682 
  """
13683 
  Attributes:
3064 chandransh 13684 
   - success
1246 chandransh 13685 
   - ex
13686 
  """
13687 
 
13688 
  thrift_spec = (
3064 chandransh 13689 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13691 
  )
13692 
 
3064 chandransh 13693 
  def __init__(self, success=None, ex=None,):
13694 
    self.success = success
1246 chandransh 13695 
    self.ex = ex
13696 
 
13697 
  def read(self, iprot):
13698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13700 
      return
13701 
    iprot.readStructBegin()
13702 
    while True:
13703 
      (fname, ftype, fid) = iprot.readFieldBegin()
13704 
      if ftype == TType.STOP:
13705 
        break
3064 chandransh 13706 
      if fid == 0:
13707 
        if ftype == TType.BOOL:
13708 
          self.success = iprot.readBool();
13709 
        else:
13710 
          iprot.skip(ftype)
13711 
      elif fid == 1:
1246 chandransh 13712 
        if ftype == TType.STRUCT:
13713 
          self.ex = TransactionServiceException()
13714 
          self.ex.read(iprot)
13715 
        else:
13716 
          iprot.skip(ftype)
13717 
      else:
13718 
        iprot.skip(ftype)
13719 
      iprot.readFieldEnd()
13720 
    iprot.readStructEnd()
13721 
 
13722 
  def write(self, oprot):
13723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13725 
      return
4283 anupam.sin 13726 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13727 
    if self.success is not None:
3064 chandransh 13728 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13729 
      oprot.writeBool(self.success)
13730 
      oprot.writeFieldEnd()
3431 rajveer 13731 
    if self.ex is not None:
1246 chandransh 13732 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13733 
      self.ex.write(oprot)
13734 
      oprot.writeFieldEnd()
13735 
    oprot.writeFieldStop()
13736 
    oprot.writeStructEnd()
13737 
 
3431 rajveer 13738 
  def validate(self):
13739 
    return
13740 
 
13741 
 
1246 chandransh 13742 
  def __repr__(self):
13743 
    L = ['%s=%r' % (key, value)
13744 
      for key, value in self.__dict__.iteritems()]
13745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13746 
 
13747 
  def __eq__(self, other):
13748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13749 
 
13750 
  def __ne__(self, other):
13751 
    return not (self == other)
13752 
 
4579 rajveer 13753 
class addInvoiceNumber_args:
13754 
  """
13755 
  Attributes:
13756 
   - orderId
13757 
   - invoiceNumber
4763 rajveer 13758 
   - color
4579 rajveer 13759 
  """
13760 
 
13761 
  thrift_spec = (
13762 
    None, # 0
13763 
    (1, TType.I64, 'orderId', None, None, ), # 1
13764 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13765 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13766 
  )
13767 
 
4763 rajveer 13768 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13769 
    self.orderId = orderId
13770 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13771 
    self.color = color
4579 rajveer 13772 
 
13773 
  def read(self, iprot):
13774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13776 
      return
13777 
    iprot.readStructBegin()
13778 
    while True:
13779 
      (fname, ftype, fid) = iprot.readFieldBegin()
13780 
      if ftype == TType.STOP:
13781 
        break
13782 
      if fid == 1:
13783 
        if ftype == TType.I64:
13784 
          self.orderId = iprot.readI64();
13785 
        else:
13786 
          iprot.skip(ftype)
13787 
      elif fid == 2:
13788 
        if ftype == TType.STRING:
13789 
          self.invoiceNumber = iprot.readString();
13790 
        else:
13791 
          iprot.skip(ftype)
4763 rajveer 13792 
      elif fid == 3:
13793 
        if ftype == TType.STRING:
13794 
          self.color = iprot.readString();
13795 
        else:
13796 
          iprot.skip(ftype)
4579 rajveer 13797 
      else:
13798 
        iprot.skip(ftype)
13799 
      iprot.readFieldEnd()
13800 
    iprot.readStructEnd()
13801 
 
13802 
  def write(self, oprot):
13803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13805 
      return
13806 
    oprot.writeStructBegin('addInvoiceNumber_args')
13807 
    if self.orderId is not None:
13808 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13809 
      oprot.writeI64(self.orderId)
13810 
      oprot.writeFieldEnd()
13811 
    if self.invoiceNumber is not None:
13812 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13813 
      oprot.writeString(self.invoiceNumber)
13814 
      oprot.writeFieldEnd()
4763 rajveer 13815 
    if self.color is not None:
13816 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13817 
      oprot.writeString(self.color)
13818 
      oprot.writeFieldEnd()
4579 rajveer 13819 
    oprot.writeFieldStop()
13820 
    oprot.writeStructEnd()
13821 
 
13822 
  def validate(self):
13823 
    return
13824 
 
13825 
 
13826 
  def __repr__(self):
13827 
    L = ['%s=%r' % (key, value)
13828 
      for key, value in self.__dict__.iteritems()]
13829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13830 
 
13831 
  def __eq__(self, other):
13832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13833 
 
13834 
  def __ne__(self, other):
13835 
    return not (self == other)
13836 
 
13837 
class addInvoiceNumber_result:
13838 
  """
13839 
  Attributes:
13840 
   - ex
13841 
  """
13842 
 
13843 
  thrift_spec = (
13844 
    None, # 0
13845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13846 
  )
13847 
 
13848 
  def __init__(self, ex=None,):
13849 
    self.ex = ex
13850 
 
13851 
  def read(self, iprot):
13852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13854 
      return
13855 
    iprot.readStructBegin()
13856 
    while True:
13857 
      (fname, ftype, fid) = iprot.readFieldBegin()
13858 
      if ftype == TType.STOP:
13859 
        break
13860 
      if fid == 1:
13861 
        if ftype == TType.STRUCT:
13862 
          self.ex = TransactionServiceException()
13863 
          self.ex.read(iprot)
13864 
        else:
13865 
          iprot.skip(ftype)
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
13875 
    oprot.writeStructBegin('addInvoiceNumber_result')
13876 
    if self.ex is not None:
13877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13878 
      self.ex.write(oprot)
13879 
      oprot.writeFieldEnd()
13880 
    oprot.writeFieldStop()
13881 
    oprot.writeStructEnd()
13882 
 
13883 
  def validate(self):
13884 
    return
13885 
 
13886 
 
13887 
  def __repr__(self):
13888 
    L = ['%s=%r' % (key, value)
13889 
      for key, value in self.__dict__.iteritems()]
13890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13891 
 
13892 
  def __eq__(self, other):
13893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13894 
 
13895 
  def __ne__(self, other):
13896 
    return not (self == other)
13897 
 
4910 phani.kuma 13898 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13899 
  """
13900 
  Attributes:
3064 chandransh 13901 
   - warehouseId
1408 ankur.sing 13902 
   - providerId
3064 chandransh 13903 
   - cod
4910 phani.kuma 13904 
   - orderIds
1408 ankur.sing 13905 
  """
13906 
 
13907 
  thrift_spec = (
13908 
    None, # 0
3064 chandransh 13909 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13910 
    (2, TType.I64, 'providerId', None, None, ), # 2
13911 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13912 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13913 
  )
13914 
 
4910 phani.kuma 13915 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13916 
    self.warehouseId = warehouseId
1408 ankur.sing 13917 
    self.providerId = providerId
3064 chandransh 13918 
    self.cod = cod
4910 phani.kuma 13919 
    self.orderIds = orderIds
1408 ankur.sing 13920 
 
13921 
  def read(self, iprot):
13922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13924 
      return
13925 
    iprot.readStructBegin()
13926 
    while True:
13927 
      (fname, ftype, fid) = iprot.readFieldBegin()
13928 
      if ftype == TType.STOP:
13929 
        break
13930 
      if fid == 1:
13931 
        if ftype == TType.I64:
3064 chandransh 13932 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13933 
        else:
13934 
          iprot.skip(ftype)
13935 
      elif fid == 2:
13936 
        if ftype == TType.I64:
3064 chandransh 13937 
          self.providerId = iprot.readI64();
1408 ankur.sing 13938 
        else:
13939 
          iprot.skip(ftype)
3064 chandransh 13940 
      elif fid == 3:
13941 
        if ftype == TType.BOOL:
13942 
          self.cod = iprot.readBool();
13943 
        else:
13944 
          iprot.skip(ftype)
4910 phani.kuma 13945 
      elif fid == 4:
13946 
        if ftype == TType.LIST:
13947 
          self.orderIds = []
6188 rajveer 13948 
          (_etype284, _size281) = iprot.readListBegin()
13949 
          for _i285 in xrange(_size281):
13950 
            _elem286 = iprot.readI64();
13951 
            self.orderIds.append(_elem286)
4910 phani.kuma 13952 
          iprot.readListEnd()
13953 
        else:
13954 
          iprot.skip(ftype)
1408 ankur.sing 13955 
      else:
13956 
        iprot.skip(ftype)
13957 
      iprot.readFieldEnd()
13958 
    iprot.readStructEnd()
13959 
 
13960 
  def write(self, oprot):
13961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13963 
      return
4910 phani.kuma 13964 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13965 
    if self.warehouseId is not None:
3064 chandransh 13966 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13967 
      oprot.writeI64(self.warehouseId)
13968 
      oprot.writeFieldEnd()
3431 rajveer 13969 
    if self.providerId is not None:
3064 chandransh 13970 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13971 
      oprot.writeI64(self.providerId)
13972 
      oprot.writeFieldEnd()
3431 rajveer 13973 
    if self.cod is not None:
3064 chandransh 13974 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13975 
      oprot.writeBool(self.cod)
1408 ankur.sing 13976 
      oprot.writeFieldEnd()
4910 phani.kuma 13977 
    if self.orderIds is not None:
13978 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13979 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13980 
      for iter287 in self.orderIds:
13981 
        oprot.writeI64(iter287)
4910 phani.kuma 13982 
      oprot.writeListEnd()
13983 
      oprot.writeFieldEnd()
1408 ankur.sing 13984 
    oprot.writeFieldStop()
13985 
    oprot.writeStructEnd()
13986 
 
3431 rajveer 13987 
  def validate(self):
13988 
    return
13989 
 
13990 
 
1408 ankur.sing 13991 
  def __repr__(self):
13992 
    L = ['%s=%r' % (key, value)
13993 
      for key, value in self.__dict__.iteritems()]
13994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13995 
 
13996 
  def __eq__(self, other):
13997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13998 
 
13999 
  def __ne__(self, other):
14000 
    return not (self == other)
14001 
 
4910 phani.kuma 14002 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14003 
  """
14004 
  Attributes:
14005 
   - success
3064 chandransh 14006 
   - ex
1408 ankur.sing 14007 
  """
14008 
 
14009 
  thrift_spec = (
3064 chandransh 14010 
    (0, TType.BOOL, 'success', None, None, ), # 0
14011 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14012 
  )
14013 
 
3064 chandransh 14014 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14015 
    self.success = success
3064 chandransh 14016 
    self.ex = ex
1408 ankur.sing 14017 
 
14018 
  def read(self, iprot):
14019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14021 
      return
14022 
    iprot.readStructBegin()
14023 
    while True:
14024 
      (fname, ftype, fid) = iprot.readFieldBegin()
14025 
      if ftype == TType.STOP:
14026 
        break
14027 
      if fid == 0:
3064 chandransh 14028 
        if ftype == TType.BOOL:
14029 
          self.success = iprot.readBool();
1408 ankur.sing 14030 
        else:
14031 
          iprot.skip(ftype)
3064 chandransh 14032 
      elif fid == 1:
14033 
        if ftype == TType.STRUCT:
14034 
          self.ex = TransactionServiceException()
14035 
          self.ex.read(iprot)
14036 
        else:
14037 
          iprot.skip(ftype)
1408 ankur.sing 14038 
      else:
14039 
        iprot.skip(ftype)
14040 
      iprot.readFieldEnd()
14041 
    iprot.readStructEnd()
14042 
 
14043 
  def write(self, oprot):
14044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14046 
      return
4910 phani.kuma 14047 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14048 
    if self.success is not None:
3064 chandransh 14049 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14050 
      oprot.writeBool(self.success)
1408 ankur.sing 14051 
      oprot.writeFieldEnd()
3431 rajveer 14052 
    if self.ex is not None:
3064 chandransh 14053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14054 
      self.ex.write(oprot)
14055 
      oprot.writeFieldEnd()
1408 ankur.sing 14056 
    oprot.writeFieldStop()
14057 
    oprot.writeStructEnd()
14058 
 
3431 rajveer 14059 
  def validate(self):
14060 
    return
14061 
 
14062 
 
1408 ankur.sing 14063 
  def __repr__(self):
14064 
    L = ['%s=%r' % (key, value)
14065 
      for key, value in self.__dict__.iteritems()]
14066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14067 
 
14068 
  def __eq__(self, other):
14069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14070 
 
14071 
  def __ne__(self, other):
14072 
    return not (self == other)
14073 
 
5676 rajveer 14074 
class markOrdersAsReturnedFromStore_args:
14075 
  """
14076 
  Attributes:
14077 
   - providerId
14078 
   - orderIds
5713 rajveer 14079 
   - awbs
5676 rajveer 14080 
  """
14081 
 
14082 
  thrift_spec = (
14083 
    None, # 0
14084 
    (1, TType.I64, 'providerId', None, None, ), # 1
14085 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14086 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14087 
  )
14088 
 
5713 rajveer 14089 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14090 
    self.providerId = providerId
14091 
    self.orderIds = orderIds
5713 rajveer 14092 
    self.awbs = awbs
5676 rajveer 14093 
 
14094 
  def read(self, iprot):
14095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14097 
      return
14098 
    iprot.readStructBegin()
14099 
    while True:
14100 
      (fname, ftype, fid) = iprot.readFieldBegin()
14101 
      if ftype == TType.STOP:
14102 
        break
14103 
      if fid == 1:
14104 
        if ftype == TType.I64:
14105 
          self.providerId = iprot.readI64();
14106 
        else:
14107 
          iprot.skip(ftype)
14108 
      elif fid == 2:
14109 
        if ftype == TType.LIST:
14110 
          self.orderIds = []
6188 rajveer 14111 
          (_etype291, _size288) = iprot.readListBegin()
14112 
          for _i292 in xrange(_size288):
14113 
            _elem293 = iprot.readI64();
14114 
            self.orderIds.append(_elem293)
5676 rajveer 14115 
          iprot.readListEnd()
14116 
        else:
14117 
          iprot.skip(ftype)
5713 rajveer 14118 
      elif fid == 3:
14119 
        if ftype == TType.LIST:
14120 
          self.awbs = []
6188 rajveer 14121 
          (_etype297, _size294) = iprot.readListBegin()
14122 
          for _i298 in xrange(_size294):
14123 
            _elem299 = iprot.readString();
14124 
            self.awbs.append(_elem299)
5713 rajveer 14125 
          iprot.readListEnd()
14126 
        else:
14127 
          iprot.skip(ftype)
5676 rajveer 14128 
      else:
14129 
        iprot.skip(ftype)
14130 
      iprot.readFieldEnd()
14131 
    iprot.readStructEnd()
14132 
 
14133 
  def write(self, oprot):
14134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14136 
      return
14137 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14138 
    if self.providerId is not None:
14139 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14140 
      oprot.writeI64(self.providerId)
14141 
      oprot.writeFieldEnd()
14142 
    if self.orderIds is not None:
14143 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14144 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14145 
      for iter300 in self.orderIds:
14146 
        oprot.writeI64(iter300)
5676 rajveer 14147 
      oprot.writeListEnd()
14148 
      oprot.writeFieldEnd()
5713 rajveer 14149 
    if self.awbs is not None:
14150 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14151 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14152 
      for iter301 in self.awbs:
14153 
        oprot.writeString(iter301)
5713 rajveer 14154 
      oprot.writeListEnd()
14155 
      oprot.writeFieldEnd()
5676 rajveer 14156 
    oprot.writeFieldStop()
14157 
    oprot.writeStructEnd()
14158 
 
14159 
  def validate(self):
14160 
    return
14161 
 
14162 
 
14163 
  def __repr__(self):
14164 
    L = ['%s=%r' % (key, value)
14165 
      for key, value in self.__dict__.iteritems()]
14166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14167 
 
14168 
  def __eq__(self, other):
14169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14170 
 
14171 
  def __ne__(self, other):
14172 
    return not (self == other)
14173 
 
14174 
class markOrdersAsReturnedFromStore_result:
14175 
  """
14176 
  Attributes:
14177 
   - success
14178 
   - ex
14179 
  """
14180 
 
14181 
  thrift_spec = (
14182 
    (0, TType.BOOL, 'success', None, None, ), # 0
14183 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14184 
  )
14185 
 
14186 
  def __init__(self, success=None, ex=None,):
14187 
    self.success = success
14188 
    self.ex = ex
14189 
 
14190 
  def read(self, iprot):
14191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14193 
      return
14194 
    iprot.readStructBegin()
14195 
    while True:
14196 
      (fname, ftype, fid) = iprot.readFieldBegin()
14197 
      if ftype == TType.STOP:
14198 
        break
14199 
      if fid == 0:
14200 
        if ftype == TType.BOOL:
14201 
          self.success = iprot.readBool();
14202 
        else:
14203 
          iprot.skip(ftype)
14204 
      elif fid == 1:
14205 
        if ftype == TType.STRUCT:
14206 
          self.ex = TransactionServiceException()
14207 
          self.ex.read(iprot)
14208 
        else:
14209 
          iprot.skip(ftype)
14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
14219 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14220 
    if self.success is not None:
14221 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14222 
      oprot.writeBool(self.success)
14223 
      oprot.writeFieldEnd()
14224 
    if self.ex is not None:
14225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14226 
      self.ex.write(oprot)
14227 
      oprot.writeFieldEnd()
14228 
    oprot.writeFieldStop()
14229 
    oprot.writeStructEnd()
14230 
 
14231 
  def validate(self):
14232 
    return
14233 
 
14234 
 
14235 
  def __repr__(self):
14236 
    L = ['%s=%r' % (key, value)
14237 
      for key, value in self.__dict__.iteritems()]
14238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14239 
 
14240 
  def __eq__(self, other):
14241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14242 
 
14243 
  def __ne__(self, other):
14244 
    return not (self == other)
14245 
 
4910 phani.kuma 14246 
class markOrdersAsPickedUp_args:
4410 rajveer 14247 
  """
14248 
  Attributes:
14249 
   - providerId
4910 phani.kuma 14250 
   - pickupDetails
4410 rajveer 14251 
  """
14252 
 
14253 
  thrift_spec = (
14254 
    None, # 0
4910 phani.kuma 14255 
    (1, TType.I64, 'providerId', None, None, ), # 1
14256 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14257 
  )
14258 
 
4910 phani.kuma 14259 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14260 
    self.providerId = providerId
4910 phani.kuma 14261 
    self.pickupDetails = pickupDetails
4410 rajveer 14262 
 
14263 
  def read(self, iprot):
14264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14266 
      return
14267 
    iprot.readStructBegin()
14268 
    while True:
14269 
      (fname, ftype, fid) = iprot.readFieldBegin()
14270 
      if ftype == TType.STOP:
14271 
        break
14272 
      if fid == 1:
14273 
        if ftype == TType.I64:
4910 phani.kuma 14274 
          self.providerId = iprot.readI64();
4410 rajveer 14275 
        else:
14276 
          iprot.skip(ftype)
14277 
      elif fid == 2:
4910 phani.kuma 14278 
        if ftype == TType.MAP:
14279 
          self.pickupDetails = {}
6188 rajveer 14280 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14281 
          for _i306 in xrange(_size302):
14282 
            _key307 = iprot.readString();
14283 
            _val308 = iprot.readString();
14284 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14285 
          iprot.readMapEnd()
4410 rajveer 14286 
        else:
14287 
          iprot.skip(ftype)
14288 
      else:
14289 
        iprot.skip(ftype)
14290 
      iprot.readFieldEnd()
14291 
    iprot.readStructEnd()
14292 
 
14293 
  def write(self, oprot):
14294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14296 
      return
4910 phani.kuma 14297 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14298 
    if self.providerId is not None:
4910 phani.kuma 14299 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14300 
      oprot.writeI64(self.providerId)
14301 
      oprot.writeFieldEnd()
4910 phani.kuma 14302 
    if self.pickupDetails is not None:
14303 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14304 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14305 
      for kiter309,viter310 in self.pickupDetails.items():
14306 
        oprot.writeString(kiter309)
14307 
        oprot.writeString(viter310)
4910 phani.kuma 14308 
      oprot.writeMapEnd()
4410 rajveer 14309 
      oprot.writeFieldEnd()
14310 
    oprot.writeFieldStop()
14311 
    oprot.writeStructEnd()
14312 
 
14313 
  def validate(self):
14314 
    return
14315 
 
14316 
 
14317 
  def __repr__(self):
14318 
    L = ['%s=%r' % (key, value)
14319 
      for key, value in self.__dict__.iteritems()]
14320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14321 
 
14322 
  def __eq__(self, other):
14323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14324 
 
14325 
  def __ne__(self, other):
14326 
    return not (self == other)
14327 
 
4910 phani.kuma 14328 
class markOrdersAsPickedUp_result:
4410 rajveer 14329 
  """
14330 
  Attributes:
14331 
   - ex
14332 
  """
14333 
 
14334 
  thrift_spec = (
4910 phani.kuma 14335 
    None, # 0
4410 rajveer 14336 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14337 
  )
14338 
 
4910 phani.kuma 14339 
  def __init__(self, ex=None,):
4410 rajveer 14340 
    self.ex = ex
14341 
 
14342 
  def read(self, iprot):
14343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14345 
      return
14346 
    iprot.readStructBegin()
14347 
    while True:
14348 
      (fname, ftype, fid) = iprot.readFieldBegin()
14349 
      if ftype == TType.STOP:
14350 
        break
4910 phani.kuma 14351 
      if fid == 1:
4410 rajveer 14352 
        if ftype == TType.STRUCT:
14353 
          self.ex = TransactionServiceException()
14354 
          self.ex.read(iprot)
14355 
        else:
14356 
          iprot.skip(ftype)
14357 
      else:
14358 
        iprot.skip(ftype)
14359 
      iprot.readFieldEnd()
14360 
    iprot.readStructEnd()
14361 
 
14362 
  def write(self, oprot):
14363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14365 
      return
4910 phani.kuma 14366 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14367 
    if self.ex is not None:
14368 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14369 
      self.ex.write(oprot)
14370 
      oprot.writeFieldEnd()
14371 
    oprot.writeFieldStop()
14372 
    oprot.writeStructEnd()
14373 
 
14374 
  def validate(self):
14375 
    return
14376 
 
14377 
 
14378 
  def __repr__(self):
14379 
    L = ['%s=%r' % (key, value)
14380 
      for key, value in self.__dict__.iteritems()]
14381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14382 
 
14383 
  def __eq__(self, other):
14384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14385 
 
14386 
  def __ne__(self, other):
14387 
    return not (self == other)
14388 
 
4910 phani.kuma 14389 
class getOrdersNotPickedUp_args:
304 ashish 14390 
  """
14391 
  Attributes:
3064 chandransh 14392 
   - providerId
304 ashish 14393 
  """
94 ashish 14394 
 
304 ashish 14395 
  thrift_spec = (
14396 
    None, # 0
3064 chandransh 14397 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14398 
  )
14399 
 
4910 phani.kuma 14400 
  def __init__(self, providerId=None,):
3064 chandransh 14401 
    self.providerId = providerId
304 ashish 14402 
 
14403 
  def read(self, iprot):
14404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14406 
      return
14407 
    iprot.readStructBegin()
14408 
    while True:
14409 
      (fname, ftype, fid) = iprot.readFieldBegin()
14410 
      if ftype == TType.STOP:
14411 
        break
14412 
      if fid == 1:
14413 
        if ftype == TType.I64:
3064 chandransh 14414 
          self.providerId = iprot.readI64();
304 ashish 14415 
        else:
14416 
          iprot.skip(ftype)
14417 
      else:
14418 
        iprot.skip(ftype)
14419 
      iprot.readFieldEnd()
14420 
    iprot.readStructEnd()
14421 
 
14422 
  def write(self, oprot):
14423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14425 
      return
4910 phani.kuma 14426 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14427 
    if self.providerId is not None:
3064 chandransh 14428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14429 
      oprot.writeI64(self.providerId)
304 ashish 14430 
      oprot.writeFieldEnd()
14431 
    oprot.writeFieldStop()
14432 
    oprot.writeStructEnd()
14433 
 
3431 rajveer 14434 
  def validate(self):
14435 
    return
14436 
 
14437 
 
304 ashish 14438 
  def __repr__(self):
14439 
    L = ['%s=%r' % (key, value)
14440 
      for key, value in self.__dict__.iteritems()]
14441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14442 
 
14443 
  def __eq__(self, other):
14444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14445 
 
14446 
  def __ne__(self, other):
14447 
    return not (self == other)
14448 
 
4910 phani.kuma 14449 
class getOrdersNotPickedUp_result:
304 ashish 14450 
  """
14451 
  Attributes:
14452 
   - success
14453 
  """
14454 
 
14455 
  thrift_spec = (
3064 chandransh 14456 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14457 
  )
14458 
 
4910 phani.kuma 14459 
  def __init__(self, success=None,):
304 ashish 14460 
    self.success = success
14461 
 
14462 
  def read(self, iprot):
14463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14465 
      return
14466 
    iprot.readStructBegin()
14467 
    while True:
14468 
      (fname, ftype, fid) = iprot.readFieldBegin()
14469 
      if ftype == TType.STOP:
14470 
        break
14471 
      if fid == 0:
14472 
        if ftype == TType.LIST:
14473 
          self.success = []
6188 rajveer 14474 
          (_etype314, _size311) = iprot.readListBegin()
14475 
          for _i315 in xrange(_size311):
14476 
            _elem316 = Order()
14477 
            _elem316.read(iprot)
14478 
            self.success.append(_elem316)
304 ashish 14479 
          iprot.readListEnd()
14480 
        else:
14481 
          iprot.skip(ftype)
14482 
      else:
14483 
        iprot.skip(ftype)
14484 
      iprot.readFieldEnd()
14485 
    iprot.readStructEnd()
14486 
 
14487 
  def write(self, oprot):
14488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14490 
      return
4910 phani.kuma 14491 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14492 
    if self.success is not None:
304 ashish 14493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14495 
      for iter317 in self.success:
14496 
        iter317.write(oprot)
304 ashish 14497 
      oprot.writeListEnd()
14498 
      oprot.writeFieldEnd()
14499 
    oprot.writeFieldStop()
14500 
    oprot.writeStructEnd()
14501 
 
3431 rajveer 14502 
  def validate(self):
14503 
    return
14504 
 
14505 
 
304 ashish 14506 
  def __repr__(self):
14507 
    L = ['%s=%r' % (key, value)
14508 
      for key, value in self.__dict__.iteritems()]
14509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14510 
 
14511 
  def __eq__(self, other):
14512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14513 
 
14514 
  def __ne__(self, other):
14515 
    return not (self == other)
14516 
 
3064 chandransh 14517 
class markOrdersAsDelivered_args:
304 ashish 14518 
  """
14519 
  Attributes:
3064 chandransh 14520 
   - providerId
14521 
   - deliveredOrders
304 ashish 14522 
  """
14523 
 
14524 
  thrift_spec = (
14525 
    None, # 0
3064 chandransh 14526 
    (1, TType.I64, 'providerId', None, None, ), # 1
14527 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14528 
  )
14529 
 
3064 chandransh 14530 
  def __init__(self, providerId=None, deliveredOrders=None,):
14531 
    self.providerId = providerId
14532 
    self.deliveredOrders = deliveredOrders
304 ashish 14533 
 
14534 
  def read(self, iprot):
14535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14537 
      return
14538 
    iprot.readStructBegin()
14539 
    while True:
14540 
      (fname, ftype, fid) = iprot.readFieldBegin()
14541 
      if ftype == TType.STOP:
14542 
        break
14543 
      if fid == 1:
14544 
        if ftype == TType.I64:
3064 chandransh 14545 
          self.providerId = iprot.readI64();
304 ashish 14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      elif fid == 2:
3064 chandransh 14549 
        if ftype == TType.MAP:
14550 
          self.deliveredOrders = {}
6188 rajveer 14551 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14552 
          for _i322 in xrange(_size318):
14553 
            _key323 = iprot.readString();
14554 
            _val324 = iprot.readString();
14555 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14556 
          iprot.readMapEnd()
304 ashish 14557 
        else:
14558 
          iprot.skip(ftype)
14559 
      else:
14560 
        iprot.skip(ftype)
14561 
      iprot.readFieldEnd()
14562 
    iprot.readStructEnd()
14563 
 
14564 
  def write(self, oprot):
14565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14567 
      return
3064 chandransh 14568 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14569 
    if self.providerId is not None:
3064 chandransh 14570 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14571 
      oprot.writeI64(self.providerId)
304 ashish 14572 
      oprot.writeFieldEnd()
3431 rajveer 14573 
    if self.deliveredOrders is not None:
3064 chandransh 14574 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14575 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14576 
      for kiter325,viter326 in self.deliveredOrders.items():
14577 
        oprot.writeString(kiter325)
14578 
        oprot.writeString(viter326)
3064 chandransh 14579 
      oprot.writeMapEnd()
304 ashish 14580 
      oprot.writeFieldEnd()
14581 
    oprot.writeFieldStop()
14582 
    oprot.writeStructEnd()
14583 
 
3431 rajveer 14584 
  def validate(self):
14585 
    return
14586 
 
14587 
 
304 ashish 14588 
  def __repr__(self):
14589 
    L = ['%s=%r' % (key, value)
14590 
      for key, value in self.__dict__.iteritems()]
14591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14592 
 
14593 
  def __eq__(self, other):
14594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14595 
 
14596 
  def __ne__(self, other):
14597 
    return not (self == other)
14598 
 
3064 chandransh 14599 
class markOrdersAsDelivered_result:
14600 
  """
14601 
  Attributes:
14602 
   - ex
14603 
  """
304 ashish 14604 
 
14605 
  thrift_spec = (
3064 chandransh 14606 
    None, # 0
14607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14608 
  )
14609 
 
3064 chandransh 14610 
  def __init__(self, ex=None,):
14611 
    self.ex = ex
304 ashish 14612 
 
1596 ankur.sing 14613 
  def read(self, iprot):
14614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14616 
      return
14617 
    iprot.readStructBegin()
14618 
    while True:
14619 
      (fname, ftype, fid) = iprot.readFieldBegin()
14620 
      if ftype == TType.STOP:
14621 
        break
3064 chandransh 14622 
      if fid == 1:
14623 
        if ftype == TType.STRUCT:
14624 
          self.ex = TransactionServiceException()
14625 
          self.ex.read(iprot)
14626 
        else:
14627 
          iprot.skip(ftype)
1596 ankur.sing 14628 
      else:
14629 
        iprot.skip(ftype)
14630 
      iprot.readFieldEnd()
14631 
    iprot.readStructEnd()
14632 
 
14633 
  def write(self, oprot):
14634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14636 
      return
3064 chandransh 14637 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14638 
    if self.ex is not None:
3064 chandransh 14639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14640 
      self.ex.write(oprot)
14641 
      oprot.writeFieldEnd()
1596 ankur.sing 14642 
    oprot.writeFieldStop()
14643 
    oprot.writeStructEnd()
14644 
 
3431 rajveer 14645 
  def validate(self):
14646 
    return
14647 
 
14648 
 
1596 ankur.sing 14649 
  def __repr__(self):
14650 
    L = ['%s=%r' % (key, value)
14651 
      for key, value in self.__dict__.iteritems()]
14652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14653 
 
14654 
  def __eq__(self, other):
14655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14656 
 
14657 
  def __ne__(self, other):
14658 
    return not (self == other)
14659 
 
4910 phani.kuma 14660 
class markAsRTOrders_args:
1596 ankur.sing 14661 
  """
14662 
  Attributes:
3064 chandransh 14663 
   - providerId
14664 
   - returnedOrders
1596 ankur.sing 14665 
  """
14666 
 
14667 
  thrift_spec = (
3064 chandransh 14668 
    None, # 0
14669 
    (1, TType.I64, 'providerId', None, None, ), # 1
14670 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14671 
  )
14672 
 
3064 chandransh 14673 
  def __init__(self, providerId=None, returnedOrders=None,):
14674 
    self.providerId = providerId
14675 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14676 
 
14677 
  def read(self, iprot):
14678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14680 
      return
14681 
    iprot.readStructBegin()
14682 
    while True:
14683 
      (fname, ftype, fid) = iprot.readFieldBegin()
14684 
      if ftype == TType.STOP:
14685 
        break
3064 chandransh 14686 
      if fid == 1:
1596 ankur.sing 14687 
        if ftype == TType.I64:
3064 chandransh 14688 
          self.providerId = iprot.readI64();
1596 ankur.sing 14689 
        else:
14690 
          iprot.skip(ftype)
3064 chandransh 14691 
      elif fid == 2:
14692 
        if ftype == TType.MAP:
14693 
          self.returnedOrders = {}
6188 rajveer 14694 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14695 
          for _i331 in xrange(_size327):
14696 
            _key332 = iprot.readString();
14697 
            _val333 = iprot.readString();
14698 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14699 
          iprot.readMapEnd()
14700 
        else:
14701 
          iprot.skip(ftype)
1596 ankur.sing 14702 
      else:
14703 
        iprot.skip(ftype)
14704 
      iprot.readFieldEnd()
14705 
    iprot.readStructEnd()
14706 
 
14707 
  def write(self, oprot):
14708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14710 
      return
4910 phani.kuma 14711 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14712 
    if self.providerId is not None:
3064 chandransh 14713 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14714 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14715 
      oprot.writeFieldEnd()
3431 rajveer 14716 
    if self.returnedOrders is not None:
3064 chandransh 14717 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14718 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14719 
      for kiter334,viter335 in self.returnedOrders.items():
14720 
        oprot.writeString(kiter334)
14721 
        oprot.writeString(viter335)
3064 chandransh 14722 
      oprot.writeMapEnd()
14723 
      oprot.writeFieldEnd()
1596 ankur.sing 14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
3431 rajveer 14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
1596 ankur.sing 14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
4910 phani.kuma 14742 
class markAsRTOrders_result:
3064 chandransh 14743 
  """
14744 
  Attributes:
14745 
   - ex
14746 
  """
1596 ankur.sing 14747 
 
1627 ankur.sing 14748 
  thrift_spec = (
3064 chandransh 14749 
    None, # 0
14750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14751 
  )
14752 
 
3064 chandransh 14753 
  def __init__(self, ex=None,):
14754 
    self.ex = ex
14755 
 
1627 ankur.sing 14756 
  def read(self, iprot):
14757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14759 
      return
14760 
    iprot.readStructBegin()
14761 
    while True:
14762 
      (fname, ftype, fid) = iprot.readFieldBegin()
14763 
      if ftype == TType.STOP:
14764 
        break
3064 chandransh 14765 
      if fid == 1:
14766 
        if ftype == TType.STRUCT:
14767 
          self.ex = TransactionServiceException()
14768 
          self.ex.read(iprot)
14769 
        else:
14770 
          iprot.skip(ftype)
1627 ankur.sing 14771 
      else:
14772 
        iprot.skip(ftype)
14773 
      iprot.readFieldEnd()
14774 
    iprot.readStructEnd()
14775 
 
14776 
  def write(self, oprot):
14777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14779 
      return
4910 phani.kuma 14780 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14781 
    if self.ex is not None:
3064 chandransh 14782 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14783 
      self.ex.write(oprot)
14784 
      oprot.writeFieldEnd()
1627 ankur.sing 14785 
    oprot.writeFieldStop()
14786 
    oprot.writeStructEnd()
14787 
 
3431 rajveer 14788 
  def validate(self):
14789 
    return
14790 
 
14791 
 
1627 ankur.sing 14792 
  def __repr__(self):
14793 
    L = ['%s=%r' % (key, value)
14794 
      for key, value in self.__dict__.iteritems()]
14795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14796 
 
14797 
  def __eq__(self, other):
14798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14799 
 
14800 
  def __ne__(self, other):
14801 
    return not (self == other)
14802 
 
4910 phani.kuma 14803 
class getRTOrders_args:
14804 
  """
14805 
  Attributes:
14806 
   - providerId
14807 
  """
14808 
 
14809 
  thrift_spec = (
14810 
    None, # 0
14811 
    (1, TType.I64, 'providerId', None, None, ), # 1
14812 
  )
14813 
 
14814 
  def __init__(self, providerId=None,):
14815 
    self.providerId = providerId
14816 
 
14817 
  def read(self, iprot):
14818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14820 
      return
14821 
    iprot.readStructBegin()
14822 
    while True:
14823 
      (fname, ftype, fid) = iprot.readFieldBegin()
14824 
      if ftype == TType.STOP:
14825 
        break
14826 
      if fid == 1:
14827 
        if ftype == TType.I64:
14828 
          self.providerId = iprot.readI64();
14829 
        else:
14830 
          iprot.skip(ftype)
14831 
      else:
14832 
        iprot.skip(ftype)
14833 
      iprot.readFieldEnd()
14834 
    iprot.readStructEnd()
14835 
 
14836 
  def write(self, oprot):
14837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14839 
      return
14840 
    oprot.writeStructBegin('getRTOrders_args')
14841 
    if self.providerId is not None:
14842 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14843 
      oprot.writeI64(self.providerId)
14844 
      oprot.writeFieldEnd()
14845 
    oprot.writeFieldStop()
14846 
    oprot.writeStructEnd()
14847 
 
14848 
  def validate(self):
14849 
    return
14850 
 
14851 
 
14852 
  def __repr__(self):
14853 
    L = ['%s=%r' % (key, value)
14854 
      for key, value in self.__dict__.iteritems()]
14855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14856 
 
14857 
  def __eq__(self, other):
14858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14859 
 
14860 
  def __ne__(self, other):
14861 
    return not (self == other)
14862 
 
14863 
class getRTOrders_result:
14864 
  """
14865 
  Attributes:
14866 
   - success
14867 
  """
14868 
 
14869 
  thrift_spec = (
14870 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14871 
  )
14872 
 
14873 
  def __init__(self, success=None,):
14874 
    self.success = success
14875 
 
14876 
  def read(self, iprot):
14877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14879 
      return
14880 
    iprot.readStructBegin()
14881 
    while True:
14882 
      (fname, ftype, fid) = iprot.readFieldBegin()
14883 
      if ftype == TType.STOP:
14884 
        break
14885 
      if fid == 0:
14886 
        if ftype == TType.LIST:
14887 
          self.success = []
6188 rajveer 14888 
          (_etype339, _size336) = iprot.readListBegin()
14889 
          for _i340 in xrange(_size336):
14890 
            _elem341 = Order()
14891 
            _elem341.read(iprot)
14892 
            self.success.append(_elem341)
4910 phani.kuma 14893 
          iprot.readListEnd()
14894 
        else:
14895 
          iprot.skip(ftype)
14896 
      else:
14897 
        iprot.skip(ftype)
14898 
      iprot.readFieldEnd()
14899 
    iprot.readStructEnd()
14900 
 
14901 
  def write(self, oprot):
14902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14904 
      return
14905 
    oprot.writeStructBegin('getRTOrders_result')
14906 
    if self.success is not None:
14907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14908 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14909 
      for iter342 in self.success:
14910 
        iter342.write(oprot)
4910 phani.kuma 14911 
      oprot.writeListEnd()
14912 
      oprot.writeFieldEnd()
14913 
    oprot.writeFieldStop()
14914 
    oprot.writeStructEnd()
14915 
 
14916 
  def validate(self):
14917 
    return
14918 
 
14919 
 
14920 
  def __repr__(self):
14921 
    L = ['%s=%r' % (key, value)
14922 
      for key, value in self.__dict__.iteritems()]
14923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14924 
 
14925 
  def __eq__(self, other):
14926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14927 
 
14928 
  def __ne__(self, other):
14929 
    return not (self == other)
14930 
 
3064 chandransh 14931 
class updateNonDeliveryReason_args:
1627 ankur.sing 14932 
  """
14933 
  Attributes:
3064 chandransh 14934 
   - providerId
14935 
   - undeliveredOrders
1627 ankur.sing 14936 
  """
14937 
 
14938 
  thrift_spec = (
3064 chandransh 14939 
    None, # 0
14940 
    (1, TType.I64, 'providerId', None, None, ), # 1
14941 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14942 
  )
14943 
 
3064 chandransh 14944 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14945 
    self.providerId = providerId
14946 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14947 
 
14948 
  def read(self, iprot):
14949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14951 
      return
14952 
    iprot.readStructBegin()
14953 
    while True:
14954 
      (fname, ftype, fid) = iprot.readFieldBegin()
14955 
      if ftype == TType.STOP:
14956 
        break
3064 chandransh 14957 
      if fid == 1:
1627 ankur.sing 14958 
        if ftype == TType.I64:
3064 chandransh 14959 
          self.providerId = iprot.readI64();
1627 ankur.sing 14960 
        else:
14961 
          iprot.skip(ftype)
3064 chandransh 14962 
      elif fid == 2:
14963 
        if ftype == TType.MAP:
14964 
          self.undeliveredOrders = {}
6188 rajveer 14965 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14966 
          for _i347 in xrange(_size343):
14967 
            _key348 = iprot.readString();
14968 
            _val349 = iprot.readString();
14969 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14970 
          iprot.readMapEnd()
14971 
        else:
14972 
          iprot.skip(ftype)
1627 ankur.sing 14973 
      else:
14974 
        iprot.skip(ftype)
14975 
      iprot.readFieldEnd()
14976 
    iprot.readStructEnd()
14977 
 
14978 
  def write(self, oprot):
14979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14981 
      return
3064 chandransh 14982 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14983 
    if self.providerId is not None:
3064 chandransh 14984 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14985 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14986 
      oprot.writeFieldEnd()
3431 rajveer 14987 
    if self.undeliveredOrders is not None:
3064 chandransh 14988 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14989 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14990 
      for kiter350,viter351 in self.undeliveredOrders.items():
14991 
        oprot.writeString(kiter350)
14992 
        oprot.writeString(viter351)
3064 chandransh 14993 
      oprot.writeMapEnd()
14994 
      oprot.writeFieldEnd()
1627 ankur.sing 14995 
    oprot.writeFieldStop()
14996 
    oprot.writeStructEnd()
14997 
 
3431 rajveer 14998 
  def validate(self):
14999 
    return
15000 
 
15001 
 
1627 ankur.sing 15002 
  def __repr__(self):
15003 
    L = ['%s=%r' % (key, value)
15004 
      for key, value in self.__dict__.iteritems()]
15005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15006 
 
15007 
  def __eq__(self, other):
15008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15009 
 
15010 
  def __ne__(self, other):
15011 
    return not (self == other)
15012 
 
3064 chandransh 15013 
class updateNonDeliveryReason_result:
1627 ankur.sing 15014 
  """
15015 
  Attributes:
3064 chandransh 15016 
   - ex
1627 ankur.sing 15017 
  """
15018 
 
15019 
  thrift_spec = (
4910 phani.kuma 15020 
    None, # 0
3064 chandransh 15021 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15022 
  )
15023 
 
4910 phani.kuma 15024 
  def __init__(self, ex=None,):
3064 chandransh 15025 
    self.ex = ex
1627 ankur.sing 15026 
 
15027 
  def read(self, iprot):
15028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15030 
      return
15031 
    iprot.readStructBegin()
15032 
    while True:
15033 
      (fname, ftype, fid) = iprot.readFieldBegin()
15034 
      if ftype == TType.STOP:
15035 
        break
4910 phani.kuma 15036 
      if fid == 1:
15037 
        if ftype == TType.STRUCT:
15038 
          self.ex = TransactionServiceException()
15039 
          self.ex.read(iprot)
15040 
        else:
15041 
          iprot.skip(ftype)
15042 
      else:
15043 
        iprot.skip(ftype)
15044 
      iprot.readFieldEnd()
15045 
    iprot.readStructEnd()
15046 
 
15047 
  def write(self, oprot):
15048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15050 
      return
15051 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15052 
    if self.ex is not None:
15053 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15054 
      self.ex.write(oprot)
15055 
      oprot.writeFieldEnd()
15056 
    oprot.writeFieldStop()
15057 
    oprot.writeStructEnd()
15058 
 
15059 
  def validate(self):
15060 
    return
15061 
 
15062 
 
15063 
  def __repr__(self):
15064 
    L = ['%s=%r' % (key, value)
15065 
      for key, value in self.__dict__.iteritems()]
15066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15067 
 
15068 
  def __eq__(self, other):
15069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15070 
 
15071 
  def __ne__(self, other):
15072 
    return not (self == other)
15073 
 
15074 
class getNonDeliveredOrdersbyCourier_args:
15075 
  """
15076 
  Attributes:
15077 
   - providerId
15078 
  """
15079 
 
15080 
  thrift_spec = (
15081 
    None, # 0
15082 
    (1, TType.I64, 'providerId', None, None, ), # 1
15083 
  )
15084 
 
15085 
  def __init__(self, providerId=None,):
15086 
    self.providerId = providerId
15087 
 
15088 
  def read(self, iprot):
15089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15091 
      return
15092 
    iprot.readStructBegin()
15093 
    while True:
15094 
      (fname, ftype, fid) = iprot.readFieldBegin()
15095 
      if ftype == TType.STOP:
15096 
        break
15097 
      if fid == 1:
15098 
        if ftype == TType.I64:
15099 
          self.providerId = iprot.readI64();
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      else:
15103 
        iprot.skip(ftype)
15104 
      iprot.readFieldEnd()
15105 
    iprot.readStructEnd()
15106 
 
15107 
  def write(self, oprot):
15108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15110 
      return
15111 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15112 
    if self.providerId is not None:
15113 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15114 
      oprot.writeI64(self.providerId)
15115 
      oprot.writeFieldEnd()
15116 
    oprot.writeFieldStop()
15117 
    oprot.writeStructEnd()
15118 
 
15119 
  def validate(self):
15120 
    return
15121 
 
15122 
 
15123 
  def __repr__(self):
15124 
    L = ['%s=%r' % (key, value)
15125 
      for key, value in self.__dict__.iteritems()]
15126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15127 
 
15128 
  def __eq__(self, other):
15129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15130 
 
15131 
  def __ne__(self, other):
15132 
    return not (self == other)
15133 
 
15134 
class getNonDeliveredOrdersbyCourier_result:
15135 
  """
15136 
  Attributes:
15137 
   - success
15138 
  """
15139 
 
15140 
  thrift_spec = (
15141 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15142 
  )
15143 
 
15144 
  def __init__(self, success=None,):
15145 
    self.success = success
15146 
 
15147 
  def read(self, iprot):
15148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15150 
      return
15151 
    iprot.readStructBegin()
15152 
    while True:
15153 
      (fname, ftype, fid) = iprot.readFieldBegin()
15154 
      if ftype == TType.STOP:
15155 
        break
4581 phani.kuma 15156 
      if fid == 0:
15157 
        if ftype == TType.LIST:
15158 
          self.success = []
6188 rajveer 15159 
          (_etype355, _size352) = iprot.readListBegin()
15160 
          for _i356 in xrange(_size352):
15161 
            _elem357 = Order()
15162 
            _elem357.read(iprot)
15163 
            self.success.append(_elem357)
4581 phani.kuma 15164 
          iprot.readListEnd()
15165 
        else:
15166 
          iprot.skip(ftype)
4910 phani.kuma 15167 
      else:
15168 
        iprot.skip(ftype)
15169 
      iprot.readFieldEnd()
15170 
    iprot.readStructEnd()
15171 
 
15172 
  def write(self, oprot):
15173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15175 
      return
15176 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15177 
    if self.success is not None:
15178 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15179 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15180 
      for iter358 in self.success:
15181 
        iter358.write(oprot)
4910 phani.kuma 15182 
      oprot.writeListEnd()
15183 
      oprot.writeFieldEnd()
15184 
    oprot.writeFieldStop()
15185 
    oprot.writeStructEnd()
15186 
 
15187 
  def validate(self):
15188 
    return
15189 
 
15190 
 
15191 
  def __repr__(self):
15192 
    L = ['%s=%r' % (key, value)
15193 
      for key, value in self.__dict__.iteritems()]
15194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15195 
 
15196 
  def __eq__(self, other):
15197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15198 
 
15199 
  def __ne__(self, other):
15200 
    return not (self == other)
15201 
 
15202 
class markOrdersAsLocalConnected_args:
15203 
  """
15204 
  Attributes:
15205 
   - providerId
15206 
   - local_connected_orders
15207 
  """
15208 
 
15209 
  thrift_spec = (
15210 
    None, # 0
15211 
    (1, TType.I64, 'providerId', None, None, ), # 1
15212 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15213 
  )
15214 
 
15215 
  def __init__(self, providerId=None, local_connected_orders=None,):
15216 
    self.providerId = providerId
15217 
    self.local_connected_orders = local_connected_orders
15218 
 
15219 
  def read(self, iprot):
15220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15222 
      return
15223 
    iprot.readStructBegin()
15224 
    while True:
15225 
      (fname, ftype, fid) = iprot.readFieldBegin()
15226 
      if ftype == TType.STOP:
15227 
        break
15228 
      if fid == 1:
15229 
        if ftype == TType.I64:
15230 
          self.providerId = iprot.readI64();
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      elif fid == 2:
15234 
        if ftype == TType.MAP:
15235 
          self.local_connected_orders = {}
6188 rajveer 15236 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15237 
          for _i363 in xrange(_size359):
15238 
            _key364 = iprot.readString();
15239 
            _val365 = iprot.readString();
15240 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15241 
          iprot.readMapEnd()
15242 
        else:
15243 
          iprot.skip(ftype)
15244 
      else:
15245 
        iprot.skip(ftype)
15246 
      iprot.readFieldEnd()
15247 
    iprot.readStructEnd()
15248 
 
15249 
  def write(self, oprot):
15250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15252 
      return
15253 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15254 
    if self.providerId is not None:
15255 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15256 
      oprot.writeI64(self.providerId)
15257 
      oprot.writeFieldEnd()
15258 
    if self.local_connected_orders is not None:
15259 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15260 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15261 
      for kiter366,viter367 in self.local_connected_orders.items():
15262 
        oprot.writeString(kiter366)
15263 
        oprot.writeString(viter367)
4910 phani.kuma 15264 
      oprot.writeMapEnd()
15265 
      oprot.writeFieldEnd()
15266 
    oprot.writeFieldStop()
15267 
    oprot.writeStructEnd()
15268 
 
15269 
  def validate(self):
15270 
    return
15271 
 
15272 
 
15273 
  def __repr__(self):
15274 
    L = ['%s=%r' % (key, value)
15275 
      for key, value in self.__dict__.iteritems()]
15276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15277 
 
15278 
  def __eq__(self, other):
15279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15280 
 
15281 
  def __ne__(self, other):
15282 
    return not (self == other)
15283 
 
15284 
class markOrdersAsLocalConnected_result:
15285 
  """
15286 
  Attributes:
15287 
   - ex
15288 
  """
15289 
 
15290 
  thrift_spec = (
15291 
    None, # 0
15292 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15293 
  )
15294 
 
15295 
  def __init__(self, ex=None,):
15296 
    self.ex = ex
15297 
 
15298 
  def read(self, iprot):
15299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15301 
      return
15302 
    iprot.readStructBegin()
15303 
    while True:
15304 
      (fname, ftype, fid) = iprot.readFieldBegin()
15305 
      if ftype == TType.STOP:
15306 
        break
15307 
      if fid == 1:
3064 chandransh 15308 
        if ftype == TType.STRUCT:
15309 
          self.ex = TransactionServiceException()
15310 
          self.ex.read(iprot)
1627 ankur.sing 15311 
        else:
15312 
          iprot.skip(ftype)
15313 
      else:
15314 
        iprot.skip(ftype)
15315 
      iprot.readFieldEnd()
15316 
    iprot.readStructEnd()
15317 
 
15318 
  def write(self, oprot):
15319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15321 
      return
4910 phani.kuma 15322 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15323 
    if self.ex is not None:
15324 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15325 
      self.ex.write(oprot)
15326 
      oprot.writeFieldEnd()
15327 
    oprot.writeFieldStop()
15328 
    oprot.writeStructEnd()
15329 
 
15330 
  def validate(self):
15331 
    return
15332 
 
15333 
 
15334 
  def __repr__(self):
15335 
    L = ['%s=%r' % (key, value)
15336 
      for key, value in self.__dict__.iteritems()]
15337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15338 
 
15339 
  def __eq__(self, other):
15340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15341 
 
15342 
  def __ne__(self, other):
15343 
    return not (self == other)
15344 
 
15345 
class getOrdersNotLocalConnected_args:
15346 
  """
15347 
  Attributes:
15348 
   - providerId
15349 
  """
15350 
 
15351 
  thrift_spec = (
15352 
    None, # 0
15353 
    (1, TType.I64, 'providerId', None, None, ), # 1
15354 
  )
15355 
 
15356 
  def __init__(self, providerId=None,):
15357 
    self.providerId = providerId
15358 
 
15359 
  def read(self, iprot):
15360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15362 
      return
15363 
    iprot.readStructBegin()
15364 
    while True:
15365 
      (fname, ftype, fid) = iprot.readFieldBegin()
15366 
      if ftype == TType.STOP:
15367 
        break
15368 
      if fid == 1:
15369 
        if ftype == TType.I64:
15370 
          self.providerId = iprot.readI64();
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      else:
15374 
        iprot.skip(ftype)
15375 
      iprot.readFieldEnd()
15376 
    iprot.readStructEnd()
15377 
 
15378 
  def write(self, oprot):
15379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15381 
      return
15382 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15383 
    if self.providerId is not None:
15384 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15385 
      oprot.writeI64(self.providerId)
15386 
      oprot.writeFieldEnd()
15387 
    oprot.writeFieldStop()
15388 
    oprot.writeStructEnd()
15389 
 
15390 
  def validate(self):
15391 
    return
15392 
 
15393 
 
15394 
  def __repr__(self):
15395 
    L = ['%s=%r' % (key, value)
15396 
      for key, value in self.__dict__.iteritems()]
15397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15398 
 
15399 
  def __eq__(self, other):
15400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15401 
 
15402 
  def __ne__(self, other):
15403 
    return not (self == other)
15404 
 
15405 
class getOrdersNotLocalConnected_result:
15406 
  """
15407 
  Attributes:
15408 
   - success
15409 
  """
15410 
 
15411 
  thrift_spec = (
15412 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15413 
  )
15414 
 
15415 
  def __init__(self, success=None,):
15416 
    self.success = success
15417 
 
15418 
  def read(self, iprot):
15419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15421 
      return
15422 
    iprot.readStructBegin()
15423 
    while True:
15424 
      (fname, ftype, fid) = iprot.readFieldBegin()
15425 
      if ftype == TType.STOP:
15426 
        break
15427 
      if fid == 0:
15428 
        if ftype == TType.LIST:
15429 
          self.success = []
6188 rajveer 15430 
          (_etype371, _size368) = iprot.readListBegin()
15431 
          for _i372 in xrange(_size368):
15432 
            _elem373 = Order()
15433 
            _elem373.read(iprot)
15434 
            self.success.append(_elem373)
4910 phani.kuma 15435 
          iprot.readListEnd()
15436 
        else:
15437 
          iprot.skip(ftype)
15438 
      else:
15439 
        iprot.skip(ftype)
15440 
      iprot.readFieldEnd()
15441 
    iprot.readStructEnd()
15442 
 
15443 
  def write(self, oprot):
15444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15446 
      return
15447 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15448 
    if self.success is not None:
15449 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15450 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15451 
      for iter374 in self.success:
15452 
        iter374.write(oprot)
4581 phani.kuma 15453 
      oprot.writeListEnd()
15454 
      oprot.writeFieldEnd()
4910 phani.kuma 15455 
    oprot.writeFieldStop()
15456 
    oprot.writeStructEnd()
15457 
 
15458 
  def validate(self):
15459 
    return
15460 
 
15461 
 
15462 
  def __repr__(self):
15463 
    L = ['%s=%r' % (key, value)
15464 
      for key, value in self.__dict__.iteritems()]
15465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15466 
 
15467 
  def __eq__(self, other):
15468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15469 
 
15470 
  def __ne__(self, other):
15471 
    return not (self == other)
15472 
 
15473 
class markOrdersAsDestinationCityReached_args:
15474 
  """
15475 
  Attributes:
15476 
   - providerId
15477 
   - destination_city_reached_orders
15478 
  """
15479 
 
15480 
  thrift_spec = (
15481 
    None, # 0
15482 
    (1, TType.I64, 'providerId', None, None, ), # 1
15483 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15484 
  )
15485 
 
15486 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15487 
    self.providerId = providerId
15488 
    self.destination_city_reached_orders = destination_city_reached_orders
15489 
 
15490 
  def read(self, iprot):
15491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15493 
      return
15494 
    iprot.readStructBegin()
15495 
    while True:
15496 
      (fname, ftype, fid) = iprot.readFieldBegin()
15497 
      if ftype == TType.STOP:
15498 
        break
15499 
      if fid == 1:
15500 
        if ftype == TType.I64:
15501 
          self.providerId = iprot.readI64();
15502 
        else:
15503 
          iprot.skip(ftype)
15504 
      elif fid == 2:
15505 
        if ftype == TType.MAP:
15506 
          self.destination_city_reached_orders = {}
6188 rajveer 15507 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15508 
          for _i379 in xrange(_size375):
15509 
            _key380 = iprot.readString();
15510 
            _val381 = iprot.readString();
15511 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15512 
          iprot.readMapEnd()
15513 
        else:
15514 
          iprot.skip(ftype)
15515 
      else:
15516 
        iprot.skip(ftype)
15517 
      iprot.readFieldEnd()
15518 
    iprot.readStructEnd()
15519 
 
15520 
  def write(self, oprot):
15521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15523 
      return
15524 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15525 
    if self.providerId is not None:
15526 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15527 
      oprot.writeI64(self.providerId)
15528 
      oprot.writeFieldEnd()
15529 
    if self.destination_city_reached_orders is not None:
15530 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15531 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15532 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15533 
        oprot.writeString(kiter382)
15534 
        oprot.writeString(viter383)
4910 phani.kuma 15535 
      oprot.writeMapEnd()
15536 
      oprot.writeFieldEnd()
15537 
    oprot.writeFieldStop()
15538 
    oprot.writeStructEnd()
15539 
 
15540 
  def validate(self):
15541 
    return
15542 
 
15543 
 
15544 
  def __repr__(self):
15545 
    L = ['%s=%r' % (key, value)
15546 
      for key, value in self.__dict__.iteritems()]
15547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15548 
 
15549 
  def __eq__(self, other):
15550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15551 
 
15552 
  def __ne__(self, other):
15553 
    return not (self == other)
15554 
 
15555 
class markOrdersAsDestinationCityReached_result:
15556 
  """
15557 
  Attributes:
15558 
   - ex
15559 
  """
15560 
 
15561 
  thrift_spec = (
15562 
    None, # 0
15563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15564 
  )
15565 
 
15566 
  def __init__(self, ex=None,):
15567 
    self.ex = ex
15568 
 
15569 
  def read(self, iprot):
15570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15572 
      return
15573 
    iprot.readStructBegin()
15574 
    while True:
15575 
      (fname, ftype, fid) = iprot.readFieldBegin()
15576 
      if ftype == TType.STOP:
15577 
        break
15578 
      if fid == 1:
15579 
        if ftype == TType.STRUCT:
15580 
          self.ex = TransactionServiceException()
15581 
          self.ex.read(iprot)
15582 
        else:
15583 
          iprot.skip(ftype)
15584 
      else:
15585 
        iprot.skip(ftype)
15586 
      iprot.readFieldEnd()
15587 
    iprot.readStructEnd()
15588 
 
15589 
  def write(self, oprot):
15590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15592 
      return
15593 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15594 
    if self.ex is not None:
3064 chandransh 15595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15596 
      self.ex.write(oprot)
1627 ankur.sing 15597 
      oprot.writeFieldEnd()
15598 
    oprot.writeFieldStop()
15599 
    oprot.writeStructEnd()
15600 
 
3431 rajveer 15601 
  def validate(self):
15602 
    return
15603 
 
15604 
 
1627 ankur.sing 15605 
  def __repr__(self):
15606 
    L = ['%s=%r' % (key, value)
15607 
      for key, value in self.__dict__.iteritems()]
15608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15609 
 
15610 
  def __eq__(self, other):
15611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15612 
 
15613 
  def __ne__(self, other):
15614 
    return not (self == other)
15615 
 
4910 phani.kuma 15616 
class markOrdersAsFirstDeliveryAttempted_args:
15617 
  """
15618 
  Attributes:
15619 
   - providerId
15620 
   - first_atdl_orders
15621 
  """
15622 
 
15623 
  thrift_spec = (
15624 
    None, # 0
15625 
    (1, TType.I64, 'providerId', None, None, ), # 1
15626 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15627 
  )
15628 
 
15629 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15630 
    self.providerId = providerId
15631 
    self.first_atdl_orders = first_atdl_orders
15632 
 
15633 
  def read(self, iprot):
15634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15636 
      return
15637 
    iprot.readStructBegin()
15638 
    while True:
15639 
      (fname, ftype, fid) = iprot.readFieldBegin()
15640 
      if ftype == TType.STOP:
15641 
        break
15642 
      if fid == 1:
15643 
        if ftype == TType.I64:
15644 
          self.providerId = iprot.readI64();
15645 
        else:
15646 
          iprot.skip(ftype)
15647 
      elif fid == 2:
15648 
        if ftype == TType.MAP:
15649 
          self.first_atdl_orders = {}
6188 rajveer 15650 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15651 
          for _i388 in xrange(_size384):
15652 
            _key389 = iprot.readString();
15653 
            _val390 = iprot.readString();
15654 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15655 
          iprot.readMapEnd()
15656 
        else:
15657 
          iprot.skip(ftype)
15658 
      else:
15659 
        iprot.skip(ftype)
15660 
      iprot.readFieldEnd()
15661 
    iprot.readStructEnd()
15662 
 
15663 
  def write(self, oprot):
15664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15666 
      return
15667 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15668 
    if self.providerId is not None:
15669 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15670 
      oprot.writeI64(self.providerId)
15671 
      oprot.writeFieldEnd()
15672 
    if self.first_atdl_orders is not None:
15673 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15674 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15675 
      for kiter391,viter392 in self.first_atdl_orders.items():
15676 
        oprot.writeString(kiter391)
15677 
        oprot.writeString(viter392)
4910 phani.kuma 15678 
      oprot.writeMapEnd()
15679 
      oprot.writeFieldEnd()
15680 
    oprot.writeFieldStop()
15681 
    oprot.writeStructEnd()
15682 
 
15683 
  def validate(self):
15684 
    return
15685 
 
15686 
 
15687 
  def __repr__(self):
15688 
    L = ['%s=%r' % (key, value)
15689 
      for key, value in self.__dict__.iteritems()]
15690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15691 
 
15692 
  def __eq__(self, other):
15693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15694 
 
15695 
  def __ne__(self, other):
15696 
    return not (self == other)
15697 
 
15698 
class markOrdersAsFirstDeliveryAttempted_result:
15699 
  """
15700 
  Attributes:
15701 
   - ex
15702 
  """
15703 
 
15704 
  thrift_spec = (
15705 
    None, # 0
15706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15707 
  )
15708 
 
15709 
  def __init__(self, ex=None,):
15710 
    self.ex = ex
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      if fid == 1:
15722 
        if ftype == TType.STRUCT:
15723 
          self.ex = TransactionServiceException()
15724 
          self.ex.read(iprot)
15725 
        else:
15726 
          iprot.skip(ftype)
15727 
      else:
15728 
        iprot.skip(ftype)
15729 
      iprot.readFieldEnd()
15730 
    iprot.readStructEnd()
15731 
 
15732 
  def write(self, oprot):
15733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15735 
      return
15736 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15737 
    if self.ex is not None:
15738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15739 
      self.ex.write(oprot)
15740 
      oprot.writeFieldEnd()
15741 
    oprot.writeFieldStop()
15742 
    oprot.writeStructEnd()
15743 
 
15744 
  def validate(self):
15745 
    return
15746 
 
15747 
 
15748 
  def __repr__(self):
15749 
    L = ['%s=%r' % (key, value)
15750 
      for key, value in self.__dict__.iteritems()]
15751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15752 
 
15753 
  def __eq__(self, other):
15754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15755 
 
15756 
  def __ne__(self, other):
15757 
    return not (self == other)
15758 
 
3064 chandransh 15759 
class getUndeliveredOrders_args:
1886 ankur.sing 15760 
  """
15761 
  Attributes:
3064 chandransh 15762 
   - providerId
15763 
   - warehouseId
1886 ankur.sing 15764 
  """
1627 ankur.sing 15765 
 
1886 ankur.sing 15766 
  thrift_spec = (
15767 
    None, # 0
3064 chandransh 15768 
    (1, TType.I64, 'providerId', None, None, ), # 1
15769 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15770 
  )
15771 
 
3064 chandransh 15772 
  def __init__(self, providerId=None, warehouseId=None,):
15773 
    self.providerId = providerId
15774 
    self.warehouseId = warehouseId
1886 ankur.sing 15775 
 
15776 
  def read(self, iprot):
15777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15779 
      return
15780 
    iprot.readStructBegin()
15781 
    while True:
15782 
      (fname, ftype, fid) = iprot.readFieldBegin()
15783 
      if ftype == TType.STOP:
15784 
        break
15785 
      if fid == 1:
15786 
        if ftype == TType.I64:
3064 chandransh 15787 
          self.providerId = iprot.readI64();
1886 ankur.sing 15788 
        else:
15789 
          iprot.skip(ftype)
3064 chandransh 15790 
      elif fid == 2:
15791 
        if ftype == TType.I64:
15792 
          self.warehouseId = iprot.readI64();
15793 
        else:
15794 
          iprot.skip(ftype)
1886 ankur.sing 15795 
      else:
15796 
        iprot.skip(ftype)
15797 
      iprot.readFieldEnd()
15798 
    iprot.readStructEnd()
15799 
 
15800 
  def write(self, oprot):
15801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15803 
      return
3064 chandransh 15804 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15805 
    if self.providerId is not None:
3064 chandransh 15806 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15807 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15808 
      oprot.writeFieldEnd()
3431 rajveer 15809 
    if self.warehouseId is not None:
3064 chandransh 15810 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15811 
      oprot.writeI64(self.warehouseId)
15812 
      oprot.writeFieldEnd()
1886 ankur.sing 15813 
    oprot.writeFieldStop()
15814 
    oprot.writeStructEnd()
15815 
 
3431 rajveer 15816 
  def validate(self):
15817 
    return
15818 
 
15819 
 
1886 ankur.sing 15820 
  def __repr__(self):
15821 
    L = ['%s=%r' % (key, value)
15822 
      for key, value in self.__dict__.iteritems()]
15823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15824 
 
15825 
  def __eq__(self, other):
15826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15827 
 
15828 
  def __ne__(self, other):
15829 
    return not (self == other)
15830 
 
3064 chandransh 15831 
class getUndeliveredOrders_result:
1886 ankur.sing 15832 
  """
15833 
  Attributes:
15834 
   - success
15835 
  """
15836 
 
15837 
  thrift_spec = (
15838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15839 
  )
15840 
 
15841 
  def __init__(self, success=None,):
15842 
    self.success = success
15843 
 
15844 
  def read(self, iprot):
15845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15847 
      return
15848 
    iprot.readStructBegin()
15849 
    while True:
15850 
      (fname, ftype, fid) = iprot.readFieldBegin()
15851 
      if ftype == TType.STOP:
15852 
        break
15853 
      if fid == 0:
15854 
        if ftype == TType.LIST:
15855 
          self.success = []
6188 rajveer 15856 
          (_etype396, _size393) = iprot.readListBegin()
15857 
          for _i397 in xrange(_size393):
15858 
            _elem398 = Order()
15859 
            _elem398.read(iprot)
15860 
            self.success.append(_elem398)
1886 ankur.sing 15861 
          iprot.readListEnd()
15862 
        else:
15863 
          iprot.skip(ftype)
15864 
      else:
15865 
        iprot.skip(ftype)
15866 
      iprot.readFieldEnd()
15867 
    iprot.readStructEnd()
15868 
 
15869 
  def write(self, oprot):
15870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15872 
      return
3064 chandransh 15873 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15874 
    if self.success is not None:
1886 ankur.sing 15875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15877 
      for iter399 in self.success:
15878 
        iter399.write(oprot)
1886 ankur.sing 15879 
      oprot.writeListEnd()
15880 
      oprot.writeFieldEnd()
15881 
    oprot.writeFieldStop()
15882 
    oprot.writeStructEnd()
15883 
 
3431 rajveer 15884 
  def validate(self):
15885 
    return
15886 
 
15887 
 
1886 ankur.sing 15888 
  def __repr__(self):
15889 
    L = ['%s=%r' % (key, value)
15890 
      for key, value in self.__dict__.iteritems()]
15891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15892 
 
15893 
  def __eq__(self, other):
15894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15895 
 
15896 
  def __ne__(self, other):
15897 
    return not (self == other)
15898 
 
4783 phani.kuma 15899 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15900 
 
15901 
  thrift_spec = (
15902 
  )
15903 
 
15904 
  def read(self, iprot):
15905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15907 
      return
15908 
    iprot.readStructBegin()
15909 
    while True:
15910 
      (fname, ftype, fid) = iprot.readFieldBegin()
15911 
      if ftype == TType.STOP:
15912 
        break
15913 
      else:
15914 
        iprot.skip(ftype)
15915 
      iprot.readFieldEnd()
15916 
    iprot.readStructEnd()
15917 
 
15918 
  def write(self, oprot):
15919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15921 
      return
15922 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15923 
    oprot.writeFieldStop()
15924 
    oprot.writeStructEnd()
15925 
 
15926 
  def validate(self):
15927 
    return
15928 
 
15929 
 
15930 
  def __repr__(self):
15931 
    L = ['%s=%r' % (key, value)
15932 
      for key, value in self.__dict__.iteritems()]
15933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15934 
 
15935 
  def __eq__(self, other):
15936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15937 
 
15938 
  def __ne__(self, other):
15939 
    return not (self == other)
15940 
 
15941 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15942 
  """
15943 
  Attributes:
15944 
   - success
15945 
  """
15946 
 
15947 
  thrift_spec = (
15948 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15949 
  )
15950 
 
15951 
  def __init__(self, success=None,):
15952 
    self.success = success
15953 
 
15954 
  def read(self, iprot):
15955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15957 
      return
15958 
    iprot.readStructBegin()
15959 
    while True:
15960 
      (fname, ftype, fid) = iprot.readFieldBegin()
15961 
      if ftype == TType.STOP:
15962 
        break
15963 
      if fid == 0:
15964 
        if ftype == TType.LIST:
15965 
          self.success = []
6188 rajveer 15966 
          (_etype403, _size400) = iprot.readListBegin()
15967 
          for _i404 in xrange(_size400):
15968 
            _elem405 = Order()
15969 
            _elem405.read(iprot)
15970 
            self.success.append(_elem405)
4783 phani.kuma 15971 
          iprot.readListEnd()
15972 
        else:
15973 
          iprot.skip(ftype)
15974 
      else:
15975 
        iprot.skip(ftype)
15976 
      iprot.readFieldEnd()
15977 
    iprot.readStructEnd()
15978 
 
15979 
  def write(self, oprot):
15980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15982 
      return
15983 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15984 
    if self.success is not None:
15985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15987 
      for iter406 in self.success:
15988 
        iter406.write(oprot)
4783 phani.kuma 15989 
      oprot.writeListEnd()
15990 
      oprot.writeFieldEnd()
15991 
    oprot.writeFieldStop()
15992 
    oprot.writeStructEnd()
15993 
 
15994 
  def validate(self):
15995 
    return
15996 
 
15997 
 
15998 
  def __repr__(self):
15999 
    L = ['%s=%r' % (key, value)
16000 
      for key, value in self.__dict__.iteritems()]
16001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16002 
 
16003 
  def __eq__(self, other):
16004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16005 
 
16006 
  def __ne__(self, other):
16007 
    return not (self == other)
16008 
 
2536 chandransh 16009 
class toggleDOAFlag_args:
16010 
  """
16011 
  Attributes:
16012 
   - orderId
16013 
  """
1886 ankur.sing 16014 
 
2536 chandransh 16015 
  thrift_spec = (
16016 
    None, # 0
16017 
    (1, TType.I64, 'orderId', None, None, ), # 1
16018 
  )
16019 
 
16020 
  def __init__(self, orderId=None,):
16021 
    self.orderId = orderId
16022 
 
16023 
  def read(self, iprot):
16024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16026 
      return
16027 
    iprot.readStructBegin()
16028 
    while True:
16029 
      (fname, ftype, fid) = iprot.readFieldBegin()
16030 
      if ftype == TType.STOP:
16031 
        break
16032 
      if fid == 1:
16033 
        if ftype == TType.I64:
16034 
          self.orderId = iprot.readI64();
16035 
        else:
16036 
          iprot.skip(ftype)
16037 
      else:
16038 
        iprot.skip(ftype)
16039 
      iprot.readFieldEnd()
16040 
    iprot.readStructEnd()
16041 
 
16042 
  def write(self, oprot):
16043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16045 
      return
16046 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16047 
    if self.orderId is not None:
2536 chandransh 16048 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16049 
      oprot.writeI64(self.orderId)
16050 
      oprot.writeFieldEnd()
16051 
    oprot.writeFieldStop()
16052 
    oprot.writeStructEnd()
16053 
 
3431 rajveer 16054 
  def validate(self):
16055 
    return
16056 
 
16057 
 
2536 chandransh 16058 
  def __repr__(self):
16059 
    L = ['%s=%r' % (key, value)
16060 
      for key, value in self.__dict__.iteritems()]
16061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16062 
 
16063 
  def __eq__(self, other):
16064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16065 
 
16066 
  def __ne__(self, other):
16067 
    return not (self == other)
16068 
 
16069 
class toggleDOAFlag_result:
16070 
  """
16071 
  Attributes:
16072 
   - success
16073 
   - ex
16074 
  """
16075 
 
16076 
  thrift_spec = (
16077 
    (0, TType.BOOL, 'success', None, None, ), # 0
16078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16079 
  )
16080 
 
16081 
  def __init__(self, success=None, ex=None,):
16082 
    self.success = success
16083 
    self.ex = ex
16084 
 
16085 
  def read(self, iprot):
16086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16088 
      return
16089 
    iprot.readStructBegin()
16090 
    while True:
16091 
      (fname, ftype, fid) = iprot.readFieldBegin()
16092 
      if ftype == TType.STOP:
16093 
        break
16094 
      if fid == 0:
16095 
        if ftype == TType.BOOL:
16096 
          self.success = iprot.readBool();
16097 
        else:
16098 
          iprot.skip(ftype)
16099 
      elif fid == 1:
16100 
        if ftype == TType.STRUCT:
16101 
          self.ex = TransactionServiceException()
16102 
          self.ex.read(iprot)
16103 
        else:
16104 
          iprot.skip(ftype)
16105 
      else:
16106 
        iprot.skip(ftype)
16107 
      iprot.readFieldEnd()
16108 
    iprot.readStructEnd()
16109 
 
16110 
  def write(self, oprot):
16111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16113 
      return
16114 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16115 
    if self.success is not None:
2536 chandransh 16116 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16117 
      oprot.writeBool(self.success)
16118 
      oprot.writeFieldEnd()
3431 rajveer 16119 
    if self.ex is not None:
2536 chandransh 16120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16121 
      self.ex.write(oprot)
16122 
      oprot.writeFieldEnd()
16123 
    oprot.writeFieldStop()
16124 
    oprot.writeStructEnd()
16125 
 
3431 rajveer 16126 
  def validate(self):
16127 
    return
16128 
 
16129 
 
2536 chandransh 16130 
  def __repr__(self):
16131 
    L = ['%s=%r' % (key, value)
16132 
      for key, value in self.__dict__.iteritems()]
16133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16134 
 
16135 
  def __eq__(self, other):
16136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16137 
 
16138 
  def __ne__(self, other):
16139 
    return not (self == other)
16140 
 
4712 rajveer 16141 
class markOrderAsDelivered_args:
16142 
  """
16143 
  Attributes:
16144 
   - orderId
16145 
   - deliveryTimestamp
16146 
   - receiver
16147 
  """
16148 
 
16149 
  thrift_spec = None
16150 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16151 
    self.orderId = orderId
16152 
    self.deliveryTimestamp = deliveryTimestamp
16153 
    self.receiver = receiver
16154 
 
16155 
  def read(self, iprot):
16156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16158 
      return
16159 
    iprot.readStructBegin()
16160 
    while True:
16161 
      (fname, ftype, fid) = iprot.readFieldBegin()
16162 
      if ftype == TType.STOP:
16163 
        break
16164 
      if fid == 1:
16165 
        if ftype == TType.I64:
16166 
          self.orderId = iprot.readI64();
16167 
        else:
16168 
          iprot.skip(ftype)
16169 
      elif fid == 2:
16170 
        if ftype == TType.I64:
16171 
          self.deliveryTimestamp = iprot.readI64();
16172 
        else:
16173 
          iprot.skip(ftype)
16174 
      elif fid == -1:
16175 
        if ftype == TType.STRING:
16176 
          self.receiver = iprot.readString();
16177 
        else:
16178 
          iprot.skip(ftype)
16179 
      else:
16180 
        iprot.skip(ftype)
16181 
      iprot.readFieldEnd()
16182 
    iprot.readStructEnd()
16183 
 
16184 
  def write(self, oprot):
16185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16187 
      return
16188 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16189 
    if self.receiver is not None:
16190 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16191 
      oprot.writeString(self.receiver)
16192 
      oprot.writeFieldEnd()
16193 
    if self.orderId is not None:
16194 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16195 
      oprot.writeI64(self.orderId)
16196 
      oprot.writeFieldEnd()
16197 
    if self.deliveryTimestamp is not None:
16198 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16199 
      oprot.writeI64(self.deliveryTimestamp)
16200 
      oprot.writeFieldEnd()
16201 
    oprot.writeFieldStop()
16202 
    oprot.writeStructEnd()
16203 
 
16204 
  def validate(self):
16205 
    return
16206 
 
16207 
 
16208 
  def __repr__(self):
16209 
    L = ['%s=%r' % (key, value)
16210 
      for key, value in self.__dict__.iteritems()]
16211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16212 
 
16213 
  def __eq__(self, other):
16214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16215 
 
16216 
  def __ne__(self, other):
16217 
    return not (self == other)
16218 
 
16219 
class markOrderAsDelivered_result:
16220 
  """
16221 
  Attributes:
16222 
   - ex
16223 
  """
16224 
 
16225 
  thrift_spec = (
16226 
    None, # 0
16227 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16228 
  )
16229 
 
16230 
  def __init__(self, ex=None,):
16231 
    self.ex = ex
16232 
 
16233 
  def read(self, iprot):
16234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16236 
      return
16237 
    iprot.readStructBegin()
16238 
    while True:
16239 
      (fname, ftype, fid) = iprot.readFieldBegin()
16240 
      if ftype == TType.STOP:
16241 
        break
16242 
      if fid == 1:
16243 
        if ftype == TType.STRUCT:
16244 
          self.ex = TransactionServiceException()
16245 
          self.ex.read(iprot)
16246 
        else:
16247 
          iprot.skip(ftype)
16248 
      else:
16249 
        iprot.skip(ftype)
16250 
      iprot.readFieldEnd()
16251 
    iprot.readStructEnd()
16252 
 
16253 
  def write(self, oprot):
16254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16256 
      return
16257 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16258 
    if self.ex is not None:
16259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16260 
      self.ex.write(oprot)
16261 
      oprot.writeFieldEnd()
16262 
    oprot.writeFieldStop()
16263 
    oprot.writeStructEnd()
16264 
 
16265 
  def validate(self):
16266 
    return
16267 
 
16268 
 
16269 
  def __repr__(self):
16270 
    L = ['%s=%r' % (key, value)
16271 
      for key, value in self.__dict__.iteritems()]
16272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16273 
 
16274 
  def __eq__(self, other):
16275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16276 
 
16277 
  def __ne__(self, other):
16278 
    return not (self == other)
16279 
 
5553 rajveer 16280 
class markOrderAsReceivedAtStore_args:
16281 
  """
16282 
  Attributes:
16283 
   - orderId
16284 
   - deliveryTimestamp
16285 
  """
16286 
 
16287 
  thrift_spec = (
16288 
    None, # 0
16289 
    (1, TType.I64, 'orderId', None, None, ), # 1
16290 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16291 
  )
16292 
 
16293 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16294 
    self.orderId = orderId
16295 
    self.deliveryTimestamp = deliveryTimestamp
16296 
 
16297 
  def read(self, iprot):
16298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16300 
      return
16301 
    iprot.readStructBegin()
16302 
    while True:
16303 
      (fname, ftype, fid) = iprot.readFieldBegin()
16304 
      if ftype == TType.STOP:
16305 
        break
16306 
      if fid == 1:
16307 
        if ftype == TType.I64:
16308 
          self.orderId = iprot.readI64();
16309 
        else:
16310 
          iprot.skip(ftype)
16311 
      elif fid == 2:
16312 
        if ftype == TType.I64:
16313 
          self.deliveryTimestamp = iprot.readI64();
16314 
        else:
16315 
          iprot.skip(ftype)
16316 
      else:
16317 
        iprot.skip(ftype)
16318 
      iprot.readFieldEnd()
16319 
    iprot.readStructEnd()
16320 
 
16321 
  def write(self, oprot):
16322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16324 
      return
16325 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16326 
    if self.orderId is not None:
16327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16328 
      oprot.writeI64(self.orderId)
16329 
      oprot.writeFieldEnd()
16330 
    if self.deliveryTimestamp is not None:
16331 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16332 
      oprot.writeI64(self.deliveryTimestamp)
16333 
      oprot.writeFieldEnd()
16334 
    oprot.writeFieldStop()
16335 
    oprot.writeStructEnd()
16336 
 
16337 
  def validate(self):
16338 
    return
16339 
 
16340 
 
16341 
  def __repr__(self):
16342 
    L = ['%s=%r' % (key, value)
16343 
      for key, value in self.__dict__.iteritems()]
16344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16345 
 
16346 
  def __eq__(self, other):
16347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16348 
 
16349 
  def __ne__(self, other):
16350 
    return not (self == other)
16351 
 
16352 
class markOrderAsReceivedAtStore_result:
16353 
  """
16354 
  Attributes:
16355 
   - ex
16356 
  """
16357 
 
16358 
  thrift_spec = (
16359 
    None, # 0
16360 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16361 
  )
16362 
 
16363 
  def __init__(self, ex=None,):
16364 
    self.ex = ex
16365 
 
16366 
  def read(self, iprot):
16367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16369 
      return
16370 
    iprot.readStructBegin()
16371 
    while True:
16372 
      (fname, ftype, fid) = iprot.readFieldBegin()
16373 
      if ftype == TType.STOP:
16374 
        break
16375 
      if fid == 1:
16376 
        if ftype == TType.STRUCT:
16377 
          self.ex = TransactionServiceException()
16378 
          self.ex.read(iprot)
16379 
        else:
16380 
          iprot.skip(ftype)
16381 
      else:
16382 
        iprot.skip(ftype)
16383 
      iprot.readFieldEnd()
16384 
    iprot.readStructEnd()
16385 
 
16386 
  def write(self, oprot):
16387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16389 
      return
16390 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16391 
    if self.ex is not None:
16392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16393 
      self.ex.write(oprot)
16394 
      oprot.writeFieldEnd()
16395 
    oprot.writeFieldStop()
16396 
    oprot.writeStructEnd()
16397 
 
16398 
  def validate(self):
16399 
    return
16400 
 
16401 
 
16402 
  def __repr__(self):
16403 
    L = ['%s=%r' % (key, value)
16404 
      for key, value in self.__dict__.iteritems()]
16405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16406 
 
16407 
  def __eq__(self, other):
16408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16409 
 
16410 
  def __ne__(self, other):
16411 
    return not (self == other)
16412 
 
4454 rajveer 16413 
class markOrderDoaRequestReceived_args:
16414 
  """
16415 
  Attributes:
16416 
   - orderId
16417 
  """
16418 
 
16419 
  thrift_spec = (
16420 
    None, # 0
16421 
    (1, TType.I64, 'orderId', None, None, ), # 1
16422 
  )
16423 
 
16424 
  def __init__(self, orderId=None,):
16425 
    self.orderId = orderId
16426 
 
16427 
  def read(self, iprot):
16428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16430 
      return
16431 
    iprot.readStructBegin()
16432 
    while True:
16433 
      (fname, ftype, fid) = iprot.readFieldBegin()
16434 
      if ftype == TType.STOP:
16435 
        break
16436 
      if fid == 1:
16437 
        if ftype == TType.I64:
16438 
          self.orderId = iprot.readI64();
16439 
        else:
16440 
          iprot.skip(ftype)
16441 
      else:
16442 
        iprot.skip(ftype)
16443 
      iprot.readFieldEnd()
16444 
    iprot.readStructEnd()
16445 
 
16446 
  def write(self, oprot):
16447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16449 
      return
16450 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16451 
    if self.orderId is not None:
16452 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16453 
      oprot.writeI64(self.orderId)
16454 
      oprot.writeFieldEnd()
16455 
    oprot.writeFieldStop()
16456 
    oprot.writeStructEnd()
16457 
 
16458 
  def validate(self):
16459 
    return
16460 
 
16461 
 
16462 
  def __repr__(self):
16463 
    L = ['%s=%r' % (key, value)
16464 
      for key, value in self.__dict__.iteritems()]
16465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16466 
 
16467 
  def __eq__(self, other):
16468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16469 
 
16470 
  def __ne__(self, other):
16471 
    return not (self == other)
16472 
 
16473 
class markOrderDoaRequestReceived_result:
16474 
  """
16475 
  Attributes:
16476 
   - success
16477 
   - ex
16478 
  """
16479 
 
16480 
  thrift_spec = (
16481 
    (0, TType.BOOL, 'success', None, None, ), # 0
16482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16483 
  )
16484 
 
16485 
  def __init__(self, success=None, ex=None,):
16486 
    self.success = success
16487 
    self.ex = ex
16488 
 
16489 
  def read(self, iprot):
16490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16492 
      return
16493 
    iprot.readStructBegin()
16494 
    while True:
16495 
      (fname, ftype, fid) = iprot.readFieldBegin()
16496 
      if ftype == TType.STOP:
16497 
        break
16498 
      if fid == 0:
16499 
        if ftype == TType.BOOL:
16500 
          self.success = iprot.readBool();
16501 
        else:
16502 
          iprot.skip(ftype)
16503 
      elif fid == 1:
16504 
        if ftype == TType.STRUCT:
16505 
          self.ex = TransactionServiceException()
16506 
          self.ex.read(iprot)
16507 
        else:
16508 
          iprot.skip(ftype)
16509 
      else:
16510 
        iprot.skip(ftype)
16511 
      iprot.readFieldEnd()
16512 
    iprot.readStructEnd()
16513 
 
16514 
  def write(self, oprot):
16515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16517 
      return
16518 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16519 
    if self.success is not None:
16520 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16521 
      oprot.writeBool(self.success)
16522 
      oprot.writeFieldEnd()
16523 
    if self.ex is not None:
16524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16525 
      self.ex.write(oprot)
16526 
      oprot.writeFieldEnd()
16527 
    oprot.writeFieldStop()
16528 
    oprot.writeStructEnd()
16529 
 
16530 
  def validate(self):
16531 
    return
16532 
 
16533 
 
16534 
  def __repr__(self):
16535 
    L = ['%s=%r' % (key, value)
16536 
      for key, value in self.__dict__.iteritems()]
16537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16538 
 
16539 
  def __eq__(self, other):
16540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16541 
 
16542 
  def __ne__(self, other):
16543 
    return not (self == other)
16544 
 
16545 
class markOrderDoaRequestAuthorized_args:
16546 
  """
16547 
  Attributes:
16548 
   - orderId
16549 
   - isAuthorized
16550 
  """
16551 
 
16552 
  thrift_spec = (
16553 
    None, # 0
16554 
    (1, TType.I64, 'orderId', None, None, ), # 1
16555 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16556 
  )
16557 
 
16558 
  def __init__(self, orderId=None, isAuthorized=None,):
16559 
    self.orderId = orderId
16560 
    self.isAuthorized = isAuthorized
16561 
 
16562 
  def read(self, iprot):
16563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16565 
      return
16566 
    iprot.readStructBegin()
16567 
    while True:
16568 
      (fname, ftype, fid) = iprot.readFieldBegin()
16569 
      if ftype == TType.STOP:
16570 
        break
16571 
      if fid == 1:
16572 
        if ftype == TType.I64:
16573 
          self.orderId = iprot.readI64();
16574 
        else:
16575 
          iprot.skip(ftype)
16576 
      elif fid == 2:
16577 
        if ftype == TType.BOOL:
16578 
          self.isAuthorized = iprot.readBool();
16579 
        else:
16580 
          iprot.skip(ftype)
16581 
      else:
16582 
        iprot.skip(ftype)
16583 
      iprot.readFieldEnd()
16584 
    iprot.readStructEnd()
16585 
 
16586 
  def write(self, oprot):
16587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16589 
      return
16590 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16591 
    if self.orderId is not None:
16592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16593 
      oprot.writeI64(self.orderId)
16594 
      oprot.writeFieldEnd()
16595 
    if self.isAuthorized is not None:
16596 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16597 
      oprot.writeBool(self.isAuthorized)
16598 
      oprot.writeFieldEnd()
16599 
    oprot.writeFieldStop()
16600 
    oprot.writeStructEnd()
16601 
 
16602 
  def validate(self):
16603 
    return
16604 
 
16605 
 
16606 
  def __repr__(self):
16607 
    L = ['%s=%r' % (key, value)
16608 
      for key, value in self.__dict__.iteritems()]
16609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16610 
 
16611 
  def __eq__(self, other):
16612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16613 
 
16614 
  def __ne__(self, other):
16615 
    return not (self == other)
16616 
 
16617 
class markOrderDoaRequestAuthorized_result:
16618 
  """
16619 
  Attributes:
16620 
   - success
16621 
   - ex
16622 
  """
16623 
 
16624 
  thrift_spec = (
16625 
    (0, TType.BOOL, 'success', None, None, ), # 0
16626 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16627 
  )
16628 
 
16629 
  def __init__(self, success=None, ex=None,):
16630 
    self.success = success
16631 
    self.ex = ex
16632 
 
16633 
  def read(self, iprot):
16634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16636 
      return
16637 
    iprot.readStructBegin()
16638 
    while True:
16639 
      (fname, ftype, fid) = iprot.readFieldBegin()
16640 
      if ftype == TType.STOP:
16641 
        break
16642 
      if fid == 0:
16643 
        if ftype == TType.BOOL:
16644 
          self.success = iprot.readBool();
16645 
        else:
16646 
          iprot.skip(ftype)
16647 
      elif fid == 1:
16648 
        if ftype == TType.STRUCT:
16649 
          self.ex = TransactionServiceException()
16650 
          self.ex.read(iprot)
16651 
        else:
16652 
          iprot.skip(ftype)
16653 
      else:
16654 
        iprot.skip(ftype)
16655 
      iprot.readFieldEnd()
16656 
    iprot.readStructEnd()
16657 
 
16658 
  def write(self, oprot):
16659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16661 
      return
16662 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16663 
    if self.success is not None:
16664 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16665 
      oprot.writeBool(self.success)
16666 
      oprot.writeFieldEnd()
16667 
    if self.ex is not None:
16668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16669 
      self.ex.write(oprot)
16670 
      oprot.writeFieldEnd()
16671 
    oprot.writeFieldStop()
16672 
    oprot.writeStructEnd()
16673 
 
16674 
  def validate(self):
16675 
    return
16676 
 
16677 
 
16678 
  def __repr__(self):
16679 
    L = ['%s=%r' % (key, value)
16680 
      for key, value in self.__dict__.iteritems()]
16681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16682 
 
16683 
  def __eq__(self, other):
16684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16685 
 
16686 
  def __ne__(self, other):
16687 
    return not (self == other)
16688 
 
4488 rajveer 16689 
class markOrderReturnRequestReceived_args:
16690 
  """
16691 
  Attributes:
16692 
   - orderId
16693 
  """
16694 
 
16695 
  thrift_spec = (
16696 
    None, # 0
16697 
    (1, TType.I64, 'orderId', None, None, ), # 1
16698 
  )
16699 
 
16700 
  def __init__(self, orderId=None,):
16701 
    self.orderId = orderId
16702 
 
16703 
  def read(self, iprot):
16704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16706 
      return
16707 
    iprot.readStructBegin()
16708 
    while True:
16709 
      (fname, ftype, fid) = iprot.readFieldBegin()
16710 
      if ftype == TType.STOP:
16711 
        break
16712 
      if fid == 1:
16713 
        if ftype == TType.I64:
16714 
          self.orderId = iprot.readI64();
16715 
        else:
16716 
          iprot.skip(ftype)
16717 
      else:
16718 
        iprot.skip(ftype)
16719 
      iprot.readFieldEnd()
16720 
    iprot.readStructEnd()
16721 
 
16722 
  def write(self, oprot):
16723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16725 
      return
16726 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16727 
    if self.orderId is not None:
16728 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16729 
      oprot.writeI64(self.orderId)
16730 
      oprot.writeFieldEnd()
16731 
    oprot.writeFieldStop()
16732 
    oprot.writeStructEnd()
16733 
 
16734 
  def validate(self):
16735 
    return
16736 
 
16737 
 
16738 
  def __repr__(self):
16739 
    L = ['%s=%r' % (key, value)
16740 
      for key, value in self.__dict__.iteritems()]
16741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16742 
 
16743 
  def __eq__(self, other):
16744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16745 
 
16746 
  def __ne__(self, other):
16747 
    return not (self == other)
16748 
 
16749 
class markOrderReturnRequestReceived_result:
16750 
  """
16751 
  Attributes:
16752 
   - success
16753 
   - ex
16754 
  """
16755 
 
16756 
  thrift_spec = (
16757 
    (0, TType.BOOL, 'success', None, None, ), # 0
16758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16759 
  )
16760 
 
16761 
  def __init__(self, success=None, ex=None,):
16762 
    self.success = success
16763 
    self.ex = ex
16764 
 
16765 
  def read(self, iprot):
16766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16768 
      return
16769 
    iprot.readStructBegin()
16770 
    while True:
16771 
      (fname, ftype, fid) = iprot.readFieldBegin()
16772 
      if ftype == TType.STOP:
16773 
        break
16774 
      if fid == 0:
16775 
        if ftype == TType.BOOL:
16776 
          self.success = iprot.readBool();
16777 
        else:
16778 
          iprot.skip(ftype)
16779 
      elif fid == 1:
16780 
        if ftype == TType.STRUCT:
16781 
          self.ex = TransactionServiceException()
16782 
          self.ex.read(iprot)
16783 
        else:
16784 
          iprot.skip(ftype)
16785 
      else:
16786 
        iprot.skip(ftype)
16787 
      iprot.readFieldEnd()
16788 
    iprot.readStructEnd()
16789 
 
16790 
  def write(self, oprot):
16791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16793 
      return
16794 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16795 
    if self.success is not None:
16796 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16797 
      oprot.writeBool(self.success)
16798 
      oprot.writeFieldEnd()
16799 
    if self.ex is not None:
16800 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16801 
      self.ex.write(oprot)
16802 
      oprot.writeFieldEnd()
16803 
    oprot.writeFieldStop()
16804 
    oprot.writeStructEnd()
16805 
 
16806 
  def validate(self):
16807 
    return
16808 
 
16809 
 
16810 
  def __repr__(self):
16811 
    L = ['%s=%r' % (key, value)
16812 
      for key, value in self.__dict__.iteritems()]
16813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16814 
 
16815 
  def __eq__(self, other):
16816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16817 
 
16818 
  def __ne__(self, other):
16819 
    return not (self == other)
16820 
 
16821 
class markOrderReturnRequestAuthorized_args:
16822 
  """
16823 
  Attributes:
16824 
   - orderId
16825 
   - isAuthorized
16826 
  """
16827 
 
16828 
  thrift_spec = (
16829 
    None, # 0
16830 
    (1, TType.I64, 'orderId', None, None, ), # 1
16831 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16832 
  )
16833 
 
16834 
  def __init__(self, orderId=None, isAuthorized=None,):
16835 
    self.orderId = orderId
16836 
    self.isAuthorized = isAuthorized
16837 
 
16838 
  def read(self, iprot):
16839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16841 
      return
16842 
    iprot.readStructBegin()
16843 
    while True:
16844 
      (fname, ftype, fid) = iprot.readFieldBegin()
16845 
      if ftype == TType.STOP:
16846 
        break
16847 
      if fid == 1:
16848 
        if ftype == TType.I64:
16849 
          self.orderId = iprot.readI64();
16850 
        else:
16851 
          iprot.skip(ftype)
16852 
      elif fid == 2:
16853 
        if ftype == TType.BOOL:
16854 
          self.isAuthorized = iprot.readBool();
16855 
        else:
16856 
          iprot.skip(ftype)
16857 
      else:
16858 
        iprot.skip(ftype)
16859 
      iprot.readFieldEnd()
16860 
    iprot.readStructEnd()
16861 
 
16862 
  def write(self, oprot):
16863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16865 
      return
16866 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16867 
    if self.orderId is not None:
16868 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16869 
      oprot.writeI64(self.orderId)
16870 
      oprot.writeFieldEnd()
16871 
    if self.isAuthorized is not None:
16872 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16873 
      oprot.writeBool(self.isAuthorized)
16874 
      oprot.writeFieldEnd()
16875 
    oprot.writeFieldStop()
16876 
    oprot.writeStructEnd()
16877 
 
16878 
  def validate(self):
16879 
    return
16880 
 
16881 
 
16882 
  def __repr__(self):
16883 
    L = ['%s=%r' % (key, value)
16884 
      for key, value in self.__dict__.iteritems()]
16885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16886 
 
16887 
  def __eq__(self, other):
16888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16889 
 
16890 
  def __ne__(self, other):
16891 
    return not (self == other)
16892 
 
16893 
class markOrderReturnRequestAuthorized_result:
16894 
  """
16895 
  Attributes:
16896 
   - success
16897 
   - ex
16898 
  """
16899 
 
16900 
  thrift_spec = (
16901 
    (0, TType.BOOL, 'success', None, None, ), # 0
16902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16903 
  )
16904 
 
16905 
  def __init__(self, success=None, ex=None,):
16906 
    self.success = success
16907 
    self.ex = ex
16908 
 
16909 
  def read(self, iprot):
16910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16912 
      return
16913 
    iprot.readStructBegin()
16914 
    while True:
16915 
      (fname, ftype, fid) = iprot.readFieldBegin()
16916 
      if ftype == TType.STOP:
16917 
        break
16918 
      if fid == 0:
16919 
        if ftype == TType.BOOL:
16920 
          self.success = iprot.readBool();
16921 
        else:
16922 
          iprot.skip(ftype)
16923 
      elif fid == 1:
16924 
        if ftype == TType.STRUCT:
16925 
          self.ex = TransactionServiceException()
16926 
          self.ex.read(iprot)
16927 
        else:
16928 
          iprot.skip(ftype)
16929 
      else:
16930 
        iprot.skip(ftype)
16931 
      iprot.readFieldEnd()
16932 
    iprot.readStructEnd()
16933 
 
16934 
  def write(self, oprot):
16935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16937 
      return
16938 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16939 
    if self.success is not None:
16940 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16941 
      oprot.writeBool(self.success)
16942 
      oprot.writeFieldEnd()
16943 
    if self.ex is not None:
16944 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16945 
      self.ex.write(oprot)
16946 
      oprot.writeFieldEnd()
16947 
    oprot.writeFieldStop()
16948 
    oprot.writeStructEnd()
16949 
 
16950 
  def validate(self):
16951 
    return
16952 
 
16953 
 
16954 
  def __repr__(self):
16955 
    L = ['%s=%r' % (key, value)
16956 
      for key, value in self.__dict__.iteritems()]
16957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16958 
 
16959 
  def __eq__(self, other):
16960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16961 
 
16962 
  def __ne__(self, other):
16963 
    return not (self == other)
16964 
 
2536 chandransh 16965 
class requestPickupNumber_args:
16966 
  """
16967 
  Attributes:
16968 
   - orderId
4579 rajveer 16969 
   - providerId
2536 chandransh 16970 
  """
16971 
 
16972 
  thrift_spec = (
16973 
    None, # 0
16974 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16975 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16976 
  )
16977 
 
4579 rajveer 16978 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16979 
    self.orderId = orderId
4579 rajveer 16980 
    self.providerId = providerId
2536 chandransh 16981 
 
16982 
  def read(self, iprot):
16983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16985 
      return
16986 
    iprot.readStructBegin()
16987 
    while True:
16988 
      (fname, ftype, fid) = iprot.readFieldBegin()
16989 
      if ftype == TType.STOP:
16990 
        break
16991 
      if fid == 1:
16992 
        if ftype == TType.I64:
16993 
          self.orderId = iprot.readI64();
16994 
        else:
16995 
          iprot.skip(ftype)
4579 rajveer 16996 
      elif fid == 2:
16997 
        if ftype == TType.I64:
16998 
          self.providerId = iprot.readI64();
16999 
        else:
17000 
          iprot.skip(ftype)
2536 chandransh 17001 
      else:
17002 
        iprot.skip(ftype)
17003 
      iprot.readFieldEnd()
17004 
    iprot.readStructEnd()
17005 
 
17006 
  def write(self, oprot):
17007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17009 
      return
17010 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17011 
    if self.orderId is not None:
2536 chandransh 17012 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17013 
      oprot.writeI64(self.orderId)
17014 
      oprot.writeFieldEnd()
4579 rajveer 17015 
    if self.providerId is not None:
17016 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17017 
      oprot.writeI64(self.providerId)
17018 
      oprot.writeFieldEnd()
2536 chandransh 17019 
    oprot.writeFieldStop()
17020 
    oprot.writeStructEnd()
17021 
 
3431 rajveer 17022 
  def validate(self):
17023 
    return
17024 
 
17025 
 
2536 chandransh 17026 
  def __repr__(self):
17027 
    L = ['%s=%r' % (key, value)
17028 
      for key, value in self.__dict__.iteritems()]
17029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17030 
 
17031 
  def __eq__(self, other):
17032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17033 
 
17034 
  def __ne__(self, other):
17035 
    return not (self == other)
17036 
 
17037 
class requestPickupNumber_result:
17038 
  """
17039 
  Attributes:
17040 
   - success
17041 
   - ex
17042 
  """
17043 
 
17044 
  thrift_spec = (
17045 
    (0, TType.BOOL, 'success', None, None, ), # 0
17046 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17047 
  )
17048 
 
17049 
  def __init__(self, success=None, ex=None,):
17050 
    self.success = success
17051 
    self.ex = ex
17052 
 
17053 
  def read(self, iprot):
17054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17056 
      return
17057 
    iprot.readStructBegin()
17058 
    while True:
17059 
      (fname, ftype, fid) = iprot.readFieldBegin()
17060 
      if ftype == TType.STOP:
17061 
        break
17062 
      if fid == 0:
17063 
        if ftype == TType.BOOL:
17064 
          self.success = iprot.readBool();
17065 
        else:
17066 
          iprot.skip(ftype)
17067 
      elif fid == 1:
17068 
        if ftype == TType.STRUCT:
17069 
          self.ex = TransactionServiceException()
17070 
          self.ex.read(iprot)
17071 
        else:
17072 
          iprot.skip(ftype)
17073 
      else:
17074 
        iprot.skip(ftype)
17075 
      iprot.readFieldEnd()
17076 
    iprot.readStructEnd()
17077 
 
17078 
  def write(self, oprot):
17079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17081 
      return
17082 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17083 
    if self.success is not None:
2536 chandransh 17084 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17085 
      oprot.writeBool(self.success)
17086 
      oprot.writeFieldEnd()
3431 rajveer 17087 
    if self.ex is not None:
2536 chandransh 17088 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17089 
      self.ex.write(oprot)
17090 
      oprot.writeFieldEnd()
17091 
    oprot.writeFieldStop()
17092 
    oprot.writeStructEnd()
17093 
 
3431 rajveer 17094 
  def validate(self):
17095 
    return
17096 
 
17097 
 
2536 chandransh 17098 
  def __repr__(self):
17099 
    L = ['%s=%r' % (key, value)
17100 
      for key, value in self.__dict__.iteritems()]
17101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17102 
 
17103 
  def __eq__(self, other):
17104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17105 
 
17106 
  def __ne__(self, other):
17107 
    return not (self == other)
17108 
 
17109 
class authorizePickup_args:
17110 
  """
17111 
  Attributes:
17112 
   - orderId
17113 
   - pickupNumber
4602 rajveer 17114 
   - providerId
2536 chandransh 17115 
  """
17116 
 
17117 
  thrift_spec = (
17118 
    None, # 0
17119 
    (1, TType.I64, 'orderId', None, None, ), # 1
17120 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17121 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17122 
  )
17123 
 
4602 rajveer 17124 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17125 
    self.orderId = orderId
17126 
    self.pickupNumber = pickupNumber
4602 rajveer 17127 
    self.providerId = providerId
2536 chandransh 17128 
 
17129 
  def read(self, iprot):
17130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17132 
      return
17133 
    iprot.readStructBegin()
17134 
    while True:
17135 
      (fname, ftype, fid) = iprot.readFieldBegin()
17136 
      if ftype == TType.STOP:
17137 
        break
17138 
      if fid == 1:
17139 
        if ftype == TType.I64:
17140 
          self.orderId = iprot.readI64();
17141 
        else:
17142 
          iprot.skip(ftype)
17143 
      elif fid == 2:
17144 
        if ftype == TType.STRING:
17145 
          self.pickupNumber = iprot.readString();
17146 
        else:
17147 
          iprot.skip(ftype)
4602 rajveer 17148 
      elif fid == 3:
17149 
        if ftype == TType.I64:
17150 
          self.providerId = iprot.readI64();
17151 
        else:
17152 
          iprot.skip(ftype)
2536 chandransh 17153 
      else:
17154 
        iprot.skip(ftype)
17155 
      iprot.readFieldEnd()
17156 
    iprot.readStructEnd()
17157 
 
17158 
  def write(self, oprot):
17159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17161 
      return
17162 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17163 
    if self.orderId is not None:
2536 chandransh 17164 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17165 
      oprot.writeI64(self.orderId)
17166 
      oprot.writeFieldEnd()
3431 rajveer 17167 
    if self.pickupNumber is not None:
2536 chandransh 17168 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17169 
      oprot.writeString(self.pickupNumber)
17170 
      oprot.writeFieldEnd()
4602 rajveer 17171 
    if self.providerId is not None:
17172 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17173 
      oprot.writeI64(self.providerId)
17174 
      oprot.writeFieldEnd()
2536 chandransh 17175 
    oprot.writeFieldStop()
17176 
    oprot.writeStructEnd()
17177 
 
3431 rajveer 17178 
  def validate(self):
17179 
    return
17180 
 
17181 
 
2536 chandransh 17182 
  def __repr__(self):
17183 
    L = ['%s=%r' % (key, value)
17184 
      for key, value in self.__dict__.iteritems()]
17185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17186 
 
17187 
  def __eq__(self, other):
17188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17189 
 
17190 
  def __ne__(self, other):
17191 
    return not (self == other)
17192 
 
17193 
class authorizePickup_result:
17194 
  """
17195 
  Attributes:
17196 
   - success
17197 
   - ex
17198 
  """
17199 
 
17200 
  thrift_spec = (
17201 
    (0, TType.BOOL, 'success', None, None, ), # 0
17202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17203 
  )
17204 
 
17205 
  def __init__(self, success=None, ex=None,):
17206 
    self.success = success
17207 
    self.ex = ex
17208 
 
17209 
  def read(self, iprot):
17210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17212 
      return
17213 
    iprot.readStructBegin()
17214 
    while True:
17215 
      (fname, ftype, fid) = iprot.readFieldBegin()
17216 
      if ftype == TType.STOP:
17217 
        break
17218 
      if fid == 0:
17219 
        if ftype == TType.BOOL:
17220 
          self.success = iprot.readBool();
17221 
        else:
17222 
          iprot.skip(ftype)
17223 
      elif fid == 1:
17224 
        if ftype == TType.STRUCT:
17225 
          self.ex = TransactionServiceException()
17226 
          self.ex.read(iprot)
17227 
        else:
17228 
          iprot.skip(ftype)
17229 
      else:
17230 
        iprot.skip(ftype)
17231 
      iprot.readFieldEnd()
17232 
    iprot.readStructEnd()
17233 
 
17234 
  def write(self, oprot):
17235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17237 
      return
17238 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17239 
    if self.success is not None:
2536 chandransh 17240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17241 
      oprot.writeBool(self.success)
17242 
      oprot.writeFieldEnd()
3431 rajveer 17243 
    if self.ex is not None:
2536 chandransh 17244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17245 
      self.ex.write(oprot)
17246 
      oprot.writeFieldEnd()
17247 
    oprot.writeFieldStop()
17248 
    oprot.writeStructEnd()
17249 
 
3431 rajveer 17250 
  def validate(self):
17251 
    return
17252 
 
17253 
 
2536 chandransh 17254 
  def __repr__(self):
17255 
    L = ['%s=%r' % (key, value)
17256 
      for key, value in self.__dict__.iteritems()]
17257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17258 
 
17259 
  def __eq__(self, other):
17260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17261 
 
17262 
  def __ne__(self, other):
17263 
    return not (self == other)
17264 
 
2764 chandransh 17265 
class markDoasAsPickedUp_args:
17266 
  """
17267 
  Attributes:
17268 
   - providerId
17269 
   - pickupDetails
17270 
  """
17271 
 
17272 
  thrift_spec = (
17273 
    None, # 0
17274 
    (1, TType.I64, 'providerId', None, None, ), # 1
17275 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17276 
  )
17277 
 
17278 
  def __init__(self, providerId=None, pickupDetails=None,):
17279 
    self.providerId = providerId
17280 
    self.pickupDetails = pickupDetails
17281 
 
17282 
  def read(self, iprot):
17283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17285 
      return
17286 
    iprot.readStructBegin()
17287 
    while True:
17288 
      (fname, ftype, fid) = iprot.readFieldBegin()
17289 
      if ftype == TType.STOP:
17290 
        break
17291 
      if fid == 1:
17292 
        if ftype == TType.I64:
17293 
          self.providerId = iprot.readI64();
17294 
        else:
17295 
          iprot.skip(ftype)
17296 
      elif fid == 2:
17297 
        if ftype == TType.MAP:
17298 
          self.pickupDetails = {}
6188 rajveer 17299 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17300 
          for _i411 in xrange(_size407):
17301 
            _key412 = iprot.readString();
17302 
            _val413 = iprot.readString();
17303 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17304 
          iprot.readMapEnd()
17305 
        else:
17306 
          iprot.skip(ftype)
17307 
      else:
17308 
        iprot.skip(ftype)
17309 
      iprot.readFieldEnd()
17310 
    iprot.readStructEnd()
17311 
 
17312 
  def write(self, oprot):
17313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17315 
      return
17316 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17317 
    if self.providerId is not None:
2764 chandransh 17318 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17319 
      oprot.writeI64(self.providerId)
17320 
      oprot.writeFieldEnd()
3431 rajveer 17321 
    if self.pickupDetails is not None:
2764 chandransh 17322 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17323 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17324 
      for kiter414,viter415 in self.pickupDetails.items():
17325 
        oprot.writeString(kiter414)
17326 
        oprot.writeString(viter415)
2764 chandransh 17327 
      oprot.writeMapEnd()
17328 
      oprot.writeFieldEnd()
17329 
    oprot.writeFieldStop()
17330 
    oprot.writeStructEnd()
17331 
 
3431 rajveer 17332 
  def validate(self):
17333 
    return
17334 
 
17335 
 
2764 chandransh 17336 
  def __repr__(self):
17337 
    L = ['%s=%r' % (key, value)
17338 
      for key, value in self.__dict__.iteritems()]
17339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17340 
 
17341 
  def __eq__(self, other):
17342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17343 
 
17344 
  def __ne__(self, other):
17345 
    return not (self == other)
17346 
 
17347 
class markDoasAsPickedUp_result:
4910 phani.kuma 17348 
 
17349 
  thrift_spec = (
17350 
  )
17351 
 
17352 
  def read(self, iprot):
17353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17355 
      return
17356 
    iprot.readStructBegin()
17357 
    while True:
17358 
      (fname, ftype, fid) = iprot.readFieldBegin()
17359 
      if ftype == TType.STOP:
17360 
        break
17361 
      else:
17362 
        iprot.skip(ftype)
17363 
      iprot.readFieldEnd()
17364 
    iprot.readStructEnd()
17365 
 
17366 
  def write(self, oprot):
17367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17369 
      return
17370 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17371 
    oprot.writeFieldStop()
17372 
    oprot.writeStructEnd()
17373 
 
17374 
  def validate(self):
17375 
    return
17376 
 
17377 
 
17378 
  def __repr__(self):
17379 
    L = ['%s=%r' % (key, value)
17380 
      for key, value in self.__dict__.iteritems()]
17381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17382 
 
17383 
  def __eq__(self, other):
17384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17385 
 
17386 
  def __ne__(self, other):
17387 
    return not (self == other)
17388 
 
17389 
class getDoasNotPickedUp_args:
2764 chandransh 17390 
  """
17391 
  Attributes:
4910 phani.kuma 17392 
   - providerId
17393 
  """
17394 
 
17395 
  thrift_spec = (
17396 
    None, # 0
17397 
    (1, TType.I64, 'providerId', None, None, ), # 1
17398 
  )
17399 
 
17400 
  def __init__(self, providerId=None,):
17401 
    self.providerId = providerId
17402 
 
17403 
  def read(self, iprot):
17404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17406 
      return
17407 
    iprot.readStructBegin()
17408 
    while True:
17409 
      (fname, ftype, fid) = iprot.readFieldBegin()
17410 
      if ftype == TType.STOP:
17411 
        break
17412 
      if fid == 1:
17413 
        if ftype == TType.I64:
17414 
          self.providerId = iprot.readI64();
17415 
        else:
17416 
          iprot.skip(ftype)
17417 
      else:
17418 
        iprot.skip(ftype)
17419 
      iprot.readFieldEnd()
17420 
    iprot.readStructEnd()
17421 
 
17422 
  def write(self, oprot):
17423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17425 
      return
17426 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17427 
    if self.providerId is not None:
17428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17429 
      oprot.writeI64(self.providerId)
17430 
      oprot.writeFieldEnd()
17431 
    oprot.writeFieldStop()
17432 
    oprot.writeStructEnd()
17433 
 
17434 
  def validate(self):
17435 
    return
17436 
 
17437 
 
17438 
  def __repr__(self):
17439 
    L = ['%s=%r' % (key, value)
17440 
      for key, value in self.__dict__.iteritems()]
17441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17442 
 
17443 
  def __eq__(self, other):
17444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17445 
 
17446 
  def __ne__(self, other):
17447 
    return not (self == other)
17448 
 
17449 
class getDoasNotPickedUp_result:
17450 
  """
17451 
  Attributes:
2764 chandransh 17452 
   - success
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17457 
  )
17458 
 
17459 
  def __init__(self, success=None,):
17460 
    self.success = success
17461 
 
17462 
  def read(self, iprot):
17463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17465 
      return
17466 
    iprot.readStructBegin()
17467 
    while True:
17468 
      (fname, ftype, fid) = iprot.readFieldBegin()
17469 
      if ftype == TType.STOP:
17470 
        break
17471 
      if fid == 0:
17472 
        if ftype == TType.LIST:
17473 
          self.success = []
6188 rajveer 17474 
          (_etype419, _size416) = iprot.readListBegin()
17475 
          for _i420 in xrange(_size416):
17476 
            _elem421 = Order()
17477 
            _elem421.read(iprot)
17478 
            self.success.append(_elem421)
2764 chandransh 17479 
          iprot.readListEnd()
17480 
        else:
17481 
          iprot.skip(ftype)
17482 
      else:
17483 
        iprot.skip(ftype)
17484 
      iprot.readFieldEnd()
17485 
    iprot.readStructEnd()
17486 
 
17487 
  def write(self, oprot):
17488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17490 
      return
4910 phani.kuma 17491 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17492 
    if self.success is not None:
2764 chandransh 17493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17495 
      for iter422 in self.success:
17496 
        iter422.write(oprot)
2764 chandransh 17497 
      oprot.writeListEnd()
17498 
      oprot.writeFieldEnd()
17499 
    oprot.writeFieldStop()
17500 
    oprot.writeStructEnd()
17501 
 
3431 rajveer 17502 
  def validate(self):
17503 
    return
17504 
 
17505 
 
2764 chandransh 17506 
  def __repr__(self):
17507 
    L = ['%s=%r' % (key, value)
17508 
      for key, value in self.__dict__.iteritems()]
17509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17510 
 
17511 
  def __eq__(self, other):
17512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17513 
 
17514 
  def __ne__(self, other):
17515 
    return not (self == other)
17516 
 
4741 phani.kuma 17517 
class markReturnOrdersAsPickedUp_args:
17518 
  """
17519 
  Attributes:
17520 
   - providerId
17521 
   - pickupDetails
17522 
  """
17523 
 
17524 
  thrift_spec = (
17525 
    None, # 0
17526 
    (1, TType.I64, 'providerId', None, None, ), # 1
17527 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17528 
  )
17529 
 
17530 
  def __init__(self, providerId=None, pickupDetails=None,):
17531 
    self.providerId = providerId
17532 
    self.pickupDetails = pickupDetails
17533 
 
17534 
  def read(self, iprot):
17535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17537 
      return
17538 
    iprot.readStructBegin()
17539 
    while True:
17540 
      (fname, ftype, fid) = iprot.readFieldBegin()
17541 
      if ftype == TType.STOP:
17542 
        break
17543 
      if fid == 1:
17544 
        if ftype == TType.I64:
17545 
          self.providerId = iprot.readI64();
17546 
        else:
17547 
          iprot.skip(ftype)
17548 
      elif fid == 2:
17549 
        if ftype == TType.MAP:
17550 
          self.pickupDetails = {}
6188 rajveer 17551 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17552 
          for _i427 in xrange(_size423):
17553 
            _key428 = iprot.readString();
17554 
            _val429 = iprot.readString();
17555 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17556 
          iprot.readMapEnd()
17557 
        else:
17558 
          iprot.skip(ftype)
17559 
      else:
17560 
        iprot.skip(ftype)
17561 
      iprot.readFieldEnd()
17562 
    iprot.readStructEnd()
17563 
 
17564 
  def write(self, oprot):
17565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17567 
      return
17568 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17569 
    if self.providerId is not None:
17570 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17571 
      oprot.writeI64(self.providerId)
17572 
      oprot.writeFieldEnd()
17573 
    if self.pickupDetails is not None:
17574 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17575 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17576 
      for kiter430,viter431 in self.pickupDetails.items():
17577 
        oprot.writeString(kiter430)
17578 
        oprot.writeString(viter431)
4741 phani.kuma 17579 
      oprot.writeMapEnd()
17580 
      oprot.writeFieldEnd()
17581 
    oprot.writeFieldStop()
17582 
    oprot.writeStructEnd()
17583 
 
17584 
  def validate(self):
17585 
    return
17586 
 
17587 
 
17588 
  def __repr__(self):
17589 
    L = ['%s=%r' % (key, value)
17590 
      for key, value in self.__dict__.iteritems()]
17591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17592 
 
17593 
  def __eq__(self, other):
17594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17595 
 
17596 
  def __ne__(self, other):
17597 
    return not (self == other)
17598 
 
17599 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17600 
 
17601 
  thrift_spec = (
17602 
  )
17603 
 
17604 
  def read(self, iprot):
17605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17607 
      return
17608 
    iprot.readStructBegin()
17609 
    while True:
17610 
      (fname, ftype, fid) = iprot.readFieldBegin()
17611 
      if ftype == TType.STOP:
17612 
        break
17613 
      else:
17614 
        iprot.skip(ftype)
17615 
      iprot.readFieldEnd()
17616 
    iprot.readStructEnd()
17617 
 
17618 
  def write(self, oprot):
17619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17621 
      return
17622 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17623 
    oprot.writeFieldStop()
17624 
    oprot.writeStructEnd()
17625 
 
17626 
  def validate(self):
17627 
    return
17628 
 
17629 
 
17630 
  def __repr__(self):
17631 
    L = ['%s=%r' % (key, value)
17632 
      for key, value in self.__dict__.iteritems()]
17633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17634 
 
17635 
  def __eq__(self, other):
17636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17637 
 
17638 
  def __ne__(self, other):
17639 
    return not (self == other)
17640 
 
17641 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17642 
  """
17643 
  Attributes:
4910 phani.kuma 17644 
   - providerId
17645 
  """
17646 
 
17647 
  thrift_spec = (
17648 
    None, # 0
17649 
    (1, TType.I64, 'providerId', None, None, ), # 1
17650 
  )
17651 
 
17652 
  def __init__(self, providerId=None,):
17653 
    self.providerId = providerId
17654 
 
17655 
  def read(self, iprot):
17656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17658 
      return
17659 
    iprot.readStructBegin()
17660 
    while True:
17661 
      (fname, ftype, fid) = iprot.readFieldBegin()
17662 
      if ftype == TType.STOP:
17663 
        break
17664 
      if fid == 1:
17665 
        if ftype == TType.I64:
17666 
          self.providerId = iprot.readI64();
17667 
        else:
17668 
          iprot.skip(ftype)
17669 
      else:
17670 
        iprot.skip(ftype)
17671 
      iprot.readFieldEnd()
17672 
    iprot.readStructEnd()
17673 
 
17674 
  def write(self, oprot):
17675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17677 
      return
17678 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17679 
    if self.providerId is not None:
17680 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17681 
      oprot.writeI64(self.providerId)
17682 
      oprot.writeFieldEnd()
17683 
    oprot.writeFieldStop()
17684 
    oprot.writeStructEnd()
17685 
 
17686 
  def validate(self):
17687 
    return
17688 
 
17689 
 
17690 
  def __repr__(self):
17691 
    L = ['%s=%r' % (key, value)
17692 
      for key, value in self.__dict__.iteritems()]
17693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17694 
 
17695 
  def __eq__(self, other):
17696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17697 
 
17698 
  def __ne__(self, other):
17699 
    return not (self == other)
17700 
 
17701 
class getReturnOrdersNotPickedUp_result:
17702 
  """
17703 
  Attributes:
4741 phani.kuma 17704 
   - success
17705 
  """
17706 
 
17707 
  thrift_spec = (
17708 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17709 
  )
17710 
 
17711 
  def __init__(self, success=None,):
17712 
    self.success = success
17713 
 
17714 
  def read(self, iprot):
17715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17717 
      return
17718 
    iprot.readStructBegin()
17719 
    while True:
17720 
      (fname, ftype, fid) = iprot.readFieldBegin()
17721 
      if ftype == TType.STOP:
17722 
        break
17723 
      if fid == 0:
17724 
        if ftype == TType.LIST:
17725 
          self.success = []
6188 rajveer 17726 
          (_etype435, _size432) = iprot.readListBegin()
17727 
          for _i436 in xrange(_size432):
17728 
            _elem437 = Order()
17729 
            _elem437.read(iprot)
17730 
            self.success.append(_elem437)
4741 phani.kuma 17731 
          iprot.readListEnd()
17732 
        else:
17733 
          iprot.skip(ftype)
17734 
      else:
17735 
        iprot.skip(ftype)
17736 
      iprot.readFieldEnd()
17737 
    iprot.readStructEnd()
17738 
 
17739 
  def write(self, oprot):
17740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17742 
      return
4910 phani.kuma 17743 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17744 
    if self.success is not None:
17745 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17746 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17747 
      for iter438 in self.success:
17748 
        iter438.write(oprot)
4741 phani.kuma 17749 
      oprot.writeListEnd()
17750 
      oprot.writeFieldEnd()
17751 
    oprot.writeFieldStop()
17752 
    oprot.writeStructEnd()
17753 
 
17754 
  def validate(self):
17755 
    return
17756 
 
17757 
 
17758 
  def __repr__(self):
17759 
    L = ['%s=%r' % (key, value)
17760 
      for key, value in self.__dict__.iteritems()]
17761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17762 
 
17763 
  def __eq__(self, other):
17764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17765 
 
17766 
  def __ne__(self, other):
17767 
    return not (self == other)
17768 
 
2616 chandransh 17769 
class receiveReturn_args:
2591 chandransh 17770 
  """
17771 
  Attributes:
17772 
   - orderId
4479 rajveer 17773 
   - receiveCondition
2591 chandransh 17774 
  """
2536 chandransh 17775 
 
2591 chandransh 17776 
  thrift_spec = (
17777 
    None, # 0
17778 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17779 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17780 
  )
17781 
 
4479 rajveer 17782 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17783 
    self.orderId = orderId
4479 rajveer 17784 
    self.receiveCondition = receiveCondition
2591 chandransh 17785 
 
17786 
  def read(self, iprot):
17787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17789 
      return
17790 
    iprot.readStructBegin()
17791 
    while True:
17792 
      (fname, ftype, fid) = iprot.readFieldBegin()
17793 
      if ftype == TType.STOP:
17794 
        break
17795 
      if fid == 1:
17796 
        if ftype == TType.I64:
17797 
          self.orderId = iprot.readI64();
17798 
        else:
17799 
          iprot.skip(ftype)
4479 rajveer 17800 
      elif fid == 2:
17801 
        if ftype == TType.I64:
17802 
          self.receiveCondition = iprot.readI64();
17803 
        else:
17804 
          iprot.skip(ftype)
2591 chandransh 17805 
      else:
17806 
        iprot.skip(ftype)
17807 
      iprot.readFieldEnd()
17808 
    iprot.readStructEnd()
17809 
 
17810 
  def write(self, oprot):
17811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17813 
      return
2616 chandransh 17814 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17815 
    if self.orderId is not None:
2591 chandransh 17816 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17817 
      oprot.writeI64(self.orderId)
17818 
      oprot.writeFieldEnd()
4479 rajveer 17819 
    if self.receiveCondition is not None:
17820 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17821 
      oprot.writeI64(self.receiveCondition)
17822 
      oprot.writeFieldEnd()
2591 chandransh 17823 
    oprot.writeFieldStop()
17824 
    oprot.writeStructEnd()
17825 
 
3431 rajveer 17826 
  def validate(self):
17827 
    return
17828 
 
17829 
 
2591 chandransh 17830 
  def __repr__(self):
17831 
    L = ['%s=%r' % (key, value)
17832 
      for key, value in self.__dict__.iteritems()]
17833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17834 
 
17835 
  def __eq__(self, other):
17836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17837 
 
17838 
  def __ne__(self, other):
17839 
    return not (self == other)
17840 
 
2616 chandransh 17841 
class receiveReturn_result:
2591 chandransh 17842 
  """
17843 
  Attributes:
17844 
   - success
17845 
   - ex
17846 
  """
17847 
 
17848 
  thrift_spec = (
17849 
    (0, TType.BOOL, 'success', None, None, ), # 0
17850 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17851 
  )
17852 
 
17853 
  def __init__(self, success=None, ex=None,):
17854 
    self.success = success
17855 
    self.ex = ex
17856 
 
17857 
  def read(self, iprot):
17858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17860 
      return
17861 
    iprot.readStructBegin()
17862 
    while True:
17863 
      (fname, ftype, fid) = iprot.readFieldBegin()
17864 
      if ftype == TType.STOP:
17865 
        break
17866 
      if fid == 0:
17867 
        if ftype == TType.BOOL:
17868 
          self.success = iprot.readBool();
17869 
        else:
17870 
          iprot.skip(ftype)
17871 
      elif fid == 1:
17872 
        if ftype == TType.STRUCT:
17873 
          self.ex = TransactionServiceException()
17874 
          self.ex.read(iprot)
17875 
        else:
17876 
          iprot.skip(ftype)
17877 
      else:
17878 
        iprot.skip(ftype)
17879 
      iprot.readFieldEnd()
17880 
    iprot.readStructEnd()
17881 
 
17882 
  def write(self, oprot):
17883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17885 
      return
2616 chandransh 17886 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17887 
    if self.success is not None:
2591 chandransh 17888 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17889 
      oprot.writeBool(self.success)
17890 
      oprot.writeFieldEnd()
3431 rajveer 17891 
    if self.ex is not None:
2591 chandransh 17892 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17893 
      self.ex.write(oprot)
17894 
      oprot.writeFieldEnd()
17895 
    oprot.writeFieldStop()
17896 
    oprot.writeStructEnd()
17897 
 
3431 rajveer 17898 
  def validate(self):
17899 
    return
17900 
 
17901 
 
2591 chandransh 17902 
  def __repr__(self):
17903 
    L = ['%s=%r' % (key, value)
17904 
      for key, value in self.__dict__.iteritems()]
17905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17906 
 
17907 
  def __eq__(self, other):
17908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17909 
 
17910 
  def __ne__(self, other):
17911 
    return not (self == other)
17912 
 
17913 
class validateDoa_args:
17914 
  """
17915 
  Attributes:
17916 
   - orderId
17917 
   - isValid
17918 
  """
17919 
 
17920 
  thrift_spec = (
17921 
    None, # 0
17922 
    (1, TType.I64, 'orderId', None, None, ), # 1
17923 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17924 
  )
17925 
 
17926 
  def __init__(self, orderId=None, isValid=None,):
17927 
    self.orderId = orderId
17928 
    self.isValid = isValid
17929 
 
17930 
  def read(self, iprot):
17931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17933 
      return
17934 
    iprot.readStructBegin()
17935 
    while True:
17936 
      (fname, ftype, fid) = iprot.readFieldBegin()
17937 
      if ftype == TType.STOP:
17938 
        break
17939 
      if fid == 1:
17940 
        if ftype == TType.I64:
17941 
          self.orderId = iprot.readI64();
17942 
        else:
17943 
          iprot.skip(ftype)
17944 
      elif fid == 2:
17945 
        if ftype == TType.BOOL:
17946 
          self.isValid = iprot.readBool();
17947 
        else:
17948 
          iprot.skip(ftype)
17949 
      else:
17950 
        iprot.skip(ftype)
17951 
      iprot.readFieldEnd()
17952 
    iprot.readStructEnd()
17953 
 
17954 
  def write(self, oprot):
17955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17957 
      return
17958 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17959 
    if self.orderId is not None:
2591 chandransh 17960 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17961 
      oprot.writeI64(self.orderId)
17962 
      oprot.writeFieldEnd()
3431 rajveer 17963 
    if self.isValid is not None:
2591 chandransh 17964 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17965 
      oprot.writeBool(self.isValid)
17966 
      oprot.writeFieldEnd()
17967 
    oprot.writeFieldStop()
17968 
    oprot.writeStructEnd()
17969 
 
3431 rajveer 17970 
  def validate(self):
17971 
    return
17972 
 
17973 
 
2591 chandransh 17974 
  def __repr__(self):
17975 
    L = ['%s=%r' % (key, value)
17976 
      for key, value in self.__dict__.iteritems()]
17977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17978 
 
17979 
  def __eq__(self, other):
17980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17981 
 
17982 
  def __ne__(self, other):
17983 
    return not (self == other)
17984 
 
17985 
class validateDoa_result:
17986 
  """
17987 
  Attributes:
17988 
   - success
17989 
   - ex
17990 
  """
17991 
 
17992 
  thrift_spec = (
17993 
    (0, TType.BOOL, 'success', None, None, ), # 0
17994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17995 
  )
17996 
 
17997 
  def __init__(self, success=None, ex=None,):
17998 
    self.success = success
17999 
    self.ex = ex
18000 
 
18001 
  def read(self, iprot):
18002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18004 
      return
18005 
    iprot.readStructBegin()
18006 
    while True:
18007 
      (fname, ftype, fid) = iprot.readFieldBegin()
18008 
      if ftype == TType.STOP:
18009 
        break
18010 
      if fid == 0:
18011 
        if ftype == TType.BOOL:
18012 
          self.success = iprot.readBool();
18013 
        else:
18014 
          iprot.skip(ftype)
18015 
      elif fid == 1:
18016 
        if ftype == TType.STRUCT:
18017 
          self.ex = TransactionServiceException()
18018 
          self.ex.read(iprot)
18019 
        else:
18020 
          iprot.skip(ftype)
18021 
      else:
18022 
        iprot.skip(ftype)
18023 
      iprot.readFieldEnd()
18024 
    iprot.readStructEnd()
18025 
 
18026 
  def write(self, oprot):
18027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18029 
      return
18030 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18031 
    if self.success is not None:
2591 chandransh 18032 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18033 
      oprot.writeBool(self.success)
18034 
      oprot.writeFieldEnd()
3431 rajveer 18035 
    if self.ex is not None:
2591 chandransh 18036 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18037 
      self.ex.write(oprot)
18038 
      oprot.writeFieldEnd()
18039 
    oprot.writeFieldStop()
18040 
    oprot.writeStructEnd()
18041 
 
3431 rajveer 18042 
  def validate(self):
18043 
    return
18044 
 
18045 
 
2591 chandransh 18046 
  def __repr__(self):
18047 
    L = ['%s=%r' % (key, value)
18048 
      for key, value in self.__dict__.iteritems()]
18049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18050 
 
18051 
  def __eq__(self, other):
18052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18053 
 
18054 
  def __ne__(self, other):
18055 
    return not (self == other)
18056 
 
4495 rajveer 18057 
class validateReturnProduct_args:
18058 
  """
18059 
  Attributes:
18060 
   - orderId
18061 
   - isUsable
18062 
  """
18063 
 
18064 
  thrift_spec = (
18065 
    None, # 0
18066 
    (1, TType.I64, 'orderId', None, None, ), # 1
18067 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18068 
  )
18069 
 
18070 
  def __init__(self, orderId=None, isUsable=None,):
18071 
    self.orderId = orderId
18072 
    self.isUsable = isUsable
18073 
 
18074 
  def read(self, iprot):
18075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18077 
      return
18078 
    iprot.readStructBegin()
18079 
    while True:
18080 
      (fname, ftype, fid) = iprot.readFieldBegin()
18081 
      if ftype == TType.STOP:
18082 
        break
18083 
      if fid == 1:
18084 
        if ftype == TType.I64:
18085 
          self.orderId = iprot.readI64();
18086 
        else:
18087 
          iprot.skip(ftype)
18088 
      elif fid == 2:
18089 
        if ftype == TType.BOOL:
18090 
          self.isUsable = iprot.readBool();
18091 
        else:
18092 
          iprot.skip(ftype)
18093 
      else:
18094 
        iprot.skip(ftype)
18095 
      iprot.readFieldEnd()
18096 
    iprot.readStructEnd()
18097 
 
18098 
  def write(self, oprot):
18099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18101 
      return
18102 
    oprot.writeStructBegin('validateReturnProduct_args')
18103 
    if self.orderId is not None:
18104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18105 
      oprot.writeI64(self.orderId)
18106 
      oprot.writeFieldEnd()
18107 
    if self.isUsable is not None:
18108 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18109 
      oprot.writeBool(self.isUsable)
18110 
      oprot.writeFieldEnd()
18111 
    oprot.writeFieldStop()
18112 
    oprot.writeStructEnd()
18113 
 
18114 
  def validate(self):
18115 
    return
18116 
 
18117 
 
18118 
  def __repr__(self):
18119 
    L = ['%s=%r' % (key, value)
18120 
      for key, value in self.__dict__.iteritems()]
18121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18122 
 
18123 
  def __eq__(self, other):
18124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18125 
 
18126 
  def __ne__(self, other):
18127 
    return not (self == other)
18128 
 
18129 
class validateReturnProduct_result:
18130 
  """
18131 
  Attributes:
18132 
   - success
18133 
   - ex
18134 
  """
18135 
 
18136 
  thrift_spec = (
18137 
    (0, TType.BOOL, 'success', None, None, ), # 0
18138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18139 
  )
18140 
 
18141 
  def __init__(self, success=None, ex=None,):
18142 
    self.success = success
18143 
    self.ex = ex
18144 
 
18145 
  def read(self, iprot):
18146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18148 
      return
18149 
    iprot.readStructBegin()
18150 
    while True:
18151 
      (fname, ftype, fid) = iprot.readFieldBegin()
18152 
      if ftype == TType.STOP:
18153 
        break
18154 
      if fid == 0:
18155 
        if ftype == TType.BOOL:
18156 
          self.success = iprot.readBool();
18157 
        else:
18158 
          iprot.skip(ftype)
18159 
      elif fid == 1:
18160 
        if ftype == TType.STRUCT:
18161 
          self.ex = TransactionServiceException()
18162 
          self.ex.read(iprot)
18163 
        else:
18164 
          iprot.skip(ftype)
18165 
      else:
18166 
        iprot.skip(ftype)
18167 
      iprot.readFieldEnd()
18168 
    iprot.readStructEnd()
18169 
 
18170 
  def write(self, oprot):
18171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18173 
      return
18174 
    oprot.writeStructBegin('validateReturnProduct_result')
18175 
    if self.success is not None:
18176 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18177 
      oprot.writeBool(self.success)
18178 
      oprot.writeFieldEnd()
18179 
    if self.ex is not None:
18180 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18181 
      self.ex.write(oprot)
18182 
      oprot.writeFieldEnd()
18183 
    oprot.writeFieldStop()
18184 
    oprot.writeStructEnd()
18185 
 
18186 
  def validate(self):
18187 
    return
18188 
 
18189 
 
18190 
  def __repr__(self):
18191 
    L = ['%s=%r' % (key, value)
18192 
      for key, value in self.__dict__.iteritems()]
18193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18194 
 
18195 
  def __eq__(self, other):
18196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18197 
 
18198 
  def __ne__(self, other):
18199 
    return not (self == other)
18200 
 
2616 chandransh 18201 
class reshipOrder_args:
18202 
  """
18203 
  Attributes:
18204 
   - orderId
18205 
  """
2591 chandransh 18206 
 
2616 chandransh 18207 
  thrift_spec = (
18208 
    None, # 0
18209 
    (1, TType.I64, 'orderId', None, None, ), # 1
18210 
  )
18211 
 
18212 
  def __init__(self, orderId=None,):
18213 
    self.orderId = orderId
18214 
 
18215 
  def read(self, iprot):
18216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18218 
      return
18219 
    iprot.readStructBegin()
18220 
    while True:
18221 
      (fname, ftype, fid) = iprot.readFieldBegin()
18222 
      if ftype == TType.STOP:
18223 
        break
18224 
      if fid == 1:
18225 
        if ftype == TType.I64:
18226 
          self.orderId = iprot.readI64();
18227 
        else:
18228 
          iprot.skip(ftype)
18229 
      else:
18230 
        iprot.skip(ftype)
18231 
      iprot.readFieldEnd()
18232 
    iprot.readStructEnd()
18233 
 
18234 
  def write(self, oprot):
18235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18237 
      return
18238 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18239 
    if self.orderId is not None:
2616 chandransh 18240 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18241 
      oprot.writeI64(self.orderId)
18242 
      oprot.writeFieldEnd()
18243 
    oprot.writeFieldStop()
18244 
    oprot.writeStructEnd()
18245 
 
3431 rajveer 18246 
  def validate(self):
18247 
    return
18248 
 
18249 
 
2616 chandransh 18250 
  def __repr__(self):
18251 
    L = ['%s=%r' % (key, value)
18252 
      for key, value in self.__dict__.iteritems()]
18253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18254 
 
18255 
  def __eq__(self, other):
18256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18257 
 
18258 
  def __ne__(self, other):
18259 
    return not (self == other)
18260 
 
18261 
class reshipOrder_result:
18262 
  """
18263 
  Attributes:
18264 
   - success
18265 
   - ex
18266 
  """
18267 
 
18268 
  thrift_spec = (
18269 
    (0, TType.I64, 'success', None, None, ), # 0
18270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18271 
  )
18272 
 
18273 
  def __init__(self, success=None, ex=None,):
18274 
    self.success = success
18275 
    self.ex = ex
18276 
 
18277 
  def read(self, iprot):
18278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18280 
      return
18281 
    iprot.readStructBegin()
18282 
    while True:
18283 
      (fname, ftype, fid) = iprot.readFieldBegin()
18284 
      if ftype == TType.STOP:
18285 
        break
18286 
      if fid == 0:
18287 
        if ftype == TType.I64:
18288 
          self.success = iprot.readI64();
18289 
        else:
18290 
          iprot.skip(ftype)
18291 
      elif fid == 1:
18292 
        if ftype == TType.STRUCT:
18293 
          self.ex = TransactionServiceException()
18294 
          self.ex.read(iprot)
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      else:
18298 
        iprot.skip(ftype)
18299 
      iprot.readFieldEnd()
18300 
    iprot.readStructEnd()
18301 
 
18302 
  def write(self, oprot):
18303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18305 
      return
18306 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18307 
    if self.success is not None:
2616 chandransh 18308 
      oprot.writeFieldBegin('success', TType.I64, 0)
18309 
      oprot.writeI64(self.success)
18310 
      oprot.writeFieldEnd()
3431 rajveer 18311 
    if self.ex is not None:
2616 chandransh 18312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18313 
      self.ex.write(oprot)
18314 
      oprot.writeFieldEnd()
18315 
    oprot.writeFieldStop()
18316 
    oprot.writeStructEnd()
18317 
 
3431 rajveer 18318 
  def validate(self):
18319 
    return
18320 
 
18321 
 
2616 chandransh 18322 
  def __repr__(self):
18323 
    L = ['%s=%r' % (key, value)
18324 
      for key, value in self.__dict__.iteritems()]
18325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18326 
 
18327 
  def __eq__(self, other):
18328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18329 
 
18330 
  def __ne__(self, other):
18331 
    return not (self == other)
18332 
 
18333 
class refundOrder_args:
18334 
  """
18335 
  Attributes:
18336 
   - orderId
3226 chandransh 18337 
   - refundedBy
18338 
   - reason
2616 chandransh 18339 
  """
18340 
 
18341 
  thrift_spec = (
18342 
    None, # 0
18343 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18344 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18345 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18346 
  )
18347 
 
3226 chandransh 18348 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18349 
    self.orderId = orderId
3226 chandransh 18350 
    self.refundedBy = refundedBy
18351 
    self.reason = reason
2616 chandransh 18352 
 
18353 
  def read(self, iprot):
18354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18356 
      return
18357 
    iprot.readStructBegin()
18358 
    while True:
18359 
      (fname, ftype, fid) = iprot.readFieldBegin()
18360 
      if ftype == TType.STOP:
18361 
        break
18362 
      if fid == 1:
18363 
        if ftype == TType.I64:
18364 
          self.orderId = iprot.readI64();
18365 
        else:
18366 
          iprot.skip(ftype)
3226 chandransh 18367 
      elif fid == 2:
18368 
        if ftype == TType.STRING:
18369 
          self.refundedBy = iprot.readString();
18370 
        else:
18371 
          iprot.skip(ftype)
18372 
      elif fid == 3:
18373 
        if ftype == TType.STRING:
18374 
          self.reason = iprot.readString();
18375 
        else:
18376 
          iprot.skip(ftype)
2616 chandransh 18377 
      else:
18378 
        iprot.skip(ftype)
18379 
      iprot.readFieldEnd()
18380 
    iprot.readStructEnd()
18381 
 
18382 
  def write(self, oprot):
18383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18385 
      return
18386 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18387 
    if self.orderId is not None:
2616 chandransh 18388 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18389 
      oprot.writeI64(self.orderId)
18390 
      oprot.writeFieldEnd()
3431 rajveer 18391 
    if self.refundedBy is not None:
3226 chandransh 18392 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18393 
      oprot.writeString(self.refundedBy)
18394 
      oprot.writeFieldEnd()
3431 rajveer 18395 
    if self.reason is not None:
3226 chandransh 18396 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18397 
      oprot.writeString(self.reason)
18398 
      oprot.writeFieldEnd()
2616 chandransh 18399 
    oprot.writeFieldStop()
18400 
    oprot.writeStructEnd()
18401 
 
3431 rajveer 18402 
  def validate(self):
18403 
    return
18404 
 
18405 
 
2616 chandransh 18406 
  def __repr__(self):
18407 
    L = ['%s=%r' % (key, value)
18408 
      for key, value in self.__dict__.iteritems()]
18409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18410 
 
18411 
  def __eq__(self, other):
18412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18413 
 
18414 
  def __ne__(self, other):
18415 
    return not (self == other)
18416 
 
18417 
class refundOrder_result:
18418 
  """
18419 
  Attributes:
18420 
   - success
18421 
   - ex
18422 
  """
18423 
 
18424 
  thrift_spec = (
18425 
    (0, TType.BOOL, 'success', None, None, ), # 0
18426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18427 
  )
18428 
 
18429 
  def __init__(self, success=None, ex=None,):
18430 
    self.success = success
18431 
    self.ex = ex
18432 
 
18433 
  def read(self, iprot):
18434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18436 
      return
18437 
    iprot.readStructBegin()
18438 
    while True:
18439 
      (fname, ftype, fid) = iprot.readFieldBegin()
18440 
      if ftype == TType.STOP:
18441 
        break
18442 
      if fid == 0:
18443 
        if ftype == TType.BOOL:
18444 
          self.success = iprot.readBool();
18445 
        else:
18446 
          iprot.skip(ftype)
18447 
      elif fid == 1:
18448 
        if ftype == TType.STRUCT:
18449 
          self.ex = TransactionServiceException()
18450 
          self.ex.read(iprot)
18451 
        else:
18452 
          iprot.skip(ftype)
18453 
      else:
18454 
        iprot.skip(ftype)
18455 
      iprot.readFieldEnd()
18456 
    iprot.readStructEnd()
18457 
 
18458 
  def write(self, oprot):
18459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18461 
      return
18462 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18463 
    if self.success is not None:
2616 chandransh 18464 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18465 
      oprot.writeBool(self.success)
18466 
      oprot.writeFieldEnd()
3431 rajveer 18467 
    if self.ex is not None:
2616 chandransh 18468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18469 
      self.ex.write(oprot)
18470 
      oprot.writeFieldEnd()
18471 
    oprot.writeFieldStop()
18472 
    oprot.writeStructEnd()
18473 
 
3431 rajveer 18474 
  def validate(self):
18475 
    return
18476 
 
18477 
 
2616 chandransh 18478 
  def __repr__(self):
18479 
    L = ['%s=%r' % (key, value)
18480 
      for key, value in self.__dict__.iteritems()]
18481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18482 
 
18483 
  def __eq__(self, other):
18484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18485 
 
18486 
  def __ne__(self, other):
18487 
    return not (self == other)
18488 
 
2690 chandransh 18489 
class getReturnOrders_args:
18490 
  """
18491 
  Attributes:
18492 
   - warehouseId
18493 
   - fromDate
18494 
   - toDate
18495 
  """
2616 chandransh 18496 
 
2690 chandransh 18497 
  thrift_spec = (
18498 
    None, # 0
18499 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18500 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18501 
    (3, TType.I64, 'toDate', None, None, ), # 3
18502 
  )
18503 
 
18504 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18505 
    self.warehouseId = warehouseId
18506 
    self.fromDate = fromDate
18507 
    self.toDate = toDate
18508 
 
18509 
  def read(self, iprot):
18510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18512 
      return
18513 
    iprot.readStructBegin()
18514 
    while True:
18515 
      (fname, ftype, fid) = iprot.readFieldBegin()
18516 
      if ftype == TType.STOP:
18517 
        break
18518 
      if fid == 1:
18519 
        if ftype == TType.I64:
18520 
          self.warehouseId = iprot.readI64();
18521 
        else:
18522 
          iprot.skip(ftype)
18523 
      elif fid == 2:
18524 
        if ftype == TType.I64:
18525 
          self.fromDate = iprot.readI64();
18526 
        else:
18527 
          iprot.skip(ftype)
18528 
      elif fid == 3:
18529 
        if ftype == TType.I64:
18530 
          self.toDate = iprot.readI64();
18531 
        else:
18532 
          iprot.skip(ftype)
18533 
      else:
18534 
        iprot.skip(ftype)
18535 
      iprot.readFieldEnd()
18536 
    iprot.readStructEnd()
18537 
 
18538 
  def write(self, oprot):
18539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18541 
      return
18542 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18543 
    if self.warehouseId is not None:
2690 chandransh 18544 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18545 
      oprot.writeI64(self.warehouseId)
18546 
      oprot.writeFieldEnd()
3431 rajveer 18547 
    if self.fromDate is not None:
2690 chandransh 18548 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18549 
      oprot.writeI64(self.fromDate)
18550 
      oprot.writeFieldEnd()
3431 rajveer 18551 
    if self.toDate is not None:
2690 chandransh 18552 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18553 
      oprot.writeI64(self.toDate)
18554 
      oprot.writeFieldEnd()
18555 
    oprot.writeFieldStop()
18556 
    oprot.writeStructEnd()
18557 
 
3431 rajveer 18558 
  def validate(self):
18559 
    return
18560 
 
18561 
 
2690 chandransh 18562 
  def __repr__(self):
18563 
    L = ['%s=%r' % (key, value)
18564 
      for key, value in self.__dict__.iteritems()]
18565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18566 
 
18567 
  def __eq__(self, other):
18568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18569 
 
18570 
  def __ne__(self, other):
18571 
    return not (self == other)
18572 
 
18573 
class getReturnOrders_result:
18574 
  """
18575 
  Attributes:
18576 
   - success
18577 
  """
18578 
 
18579 
  thrift_spec = (
18580 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18581 
  )
18582 
 
18583 
  def __init__(self, success=None,):
18584 
    self.success = success
18585 
 
18586 
  def read(self, iprot):
18587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18589 
      return
18590 
    iprot.readStructBegin()
18591 
    while True:
18592 
      (fname, ftype, fid) = iprot.readFieldBegin()
18593 
      if ftype == TType.STOP:
18594 
        break
18595 
      if fid == 0:
18596 
        if ftype == TType.LIST:
18597 
          self.success = []
6188 rajveer 18598 
          (_etype442, _size439) = iprot.readListBegin()
18599 
          for _i443 in xrange(_size439):
18600 
            _elem444 = ReturnOrder()
18601 
            _elem444.read(iprot)
18602 
            self.success.append(_elem444)
2690 chandransh 18603 
          iprot.readListEnd()
18604 
        else:
18605 
          iprot.skip(ftype)
18606 
      else:
18607 
        iprot.skip(ftype)
18608 
      iprot.readFieldEnd()
18609 
    iprot.readStructEnd()
18610 
 
18611 
  def write(self, oprot):
18612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18614 
      return
18615 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18616 
    if self.success is not None:
2690 chandransh 18617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18619 
      for iter445 in self.success:
18620 
        iter445.write(oprot)
2690 chandransh 18621 
      oprot.writeListEnd()
18622 
      oprot.writeFieldEnd()
18623 
    oprot.writeFieldStop()
18624 
    oprot.writeStructEnd()
18625 
 
3431 rajveer 18626 
  def validate(self):
18627 
    return
18628 
 
18629 
 
2690 chandransh 18630 
  def __repr__(self):
18631 
    L = ['%s=%r' % (key, value)
18632 
      for key, value in self.__dict__.iteritems()]
18633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18634 
 
18635 
  def __eq__(self, other):
18636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18637 
 
18638 
  def __ne__(self, other):
18639 
    return not (self == other)
18640 
 
5481 phani.kuma 18641 
class getAllReturnOrders_args:
18642 
  """
18643 
  Attributes:
18644 
   - onlyNotProcessed
18645 
   - fromDate
18646 
   - toDate
18647 
  """
18648 
 
18649 
  thrift_spec = (
18650 
    None, # 0
18651 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18652 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18653 
    (3, TType.I64, 'toDate', None, None, ), # 3
18654 
  )
18655 
 
18656 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18657 
    self.onlyNotProcessed = onlyNotProcessed
18658 
    self.fromDate = fromDate
18659 
    self.toDate = toDate
18660 
 
18661 
  def read(self, iprot):
18662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18664 
      return
18665 
    iprot.readStructBegin()
18666 
    while True:
18667 
      (fname, ftype, fid) = iprot.readFieldBegin()
18668 
      if ftype == TType.STOP:
18669 
        break
18670 
      if fid == 1:
18671 
        if ftype == TType.BOOL:
18672 
          self.onlyNotProcessed = iprot.readBool();
18673 
        else:
18674 
          iprot.skip(ftype)
18675 
      elif fid == 2:
18676 
        if ftype == TType.I64:
18677 
          self.fromDate = iprot.readI64();
18678 
        else:
18679 
          iprot.skip(ftype)
18680 
      elif fid == 3:
18681 
        if ftype == TType.I64:
18682 
          self.toDate = iprot.readI64();
18683 
        else:
18684 
          iprot.skip(ftype)
18685 
      else:
18686 
        iprot.skip(ftype)
18687 
      iprot.readFieldEnd()
18688 
    iprot.readStructEnd()
18689 
 
18690 
  def write(self, oprot):
18691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18693 
      return
18694 
    oprot.writeStructBegin('getAllReturnOrders_args')
18695 
    if self.onlyNotProcessed is not None:
18696 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18697 
      oprot.writeBool(self.onlyNotProcessed)
18698 
      oprot.writeFieldEnd()
18699 
    if self.fromDate is not None:
18700 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18701 
      oprot.writeI64(self.fromDate)
18702 
      oprot.writeFieldEnd()
18703 
    if self.toDate is not None:
18704 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18705 
      oprot.writeI64(self.toDate)
18706 
      oprot.writeFieldEnd()
18707 
    oprot.writeFieldStop()
18708 
    oprot.writeStructEnd()
18709 
 
18710 
  def validate(self):
18711 
    return
18712 
 
18713 
 
18714 
  def __repr__(self):
18715 
    L = ['%s=%r' % (key, value)
18716 
      for key, value in self.__dict__.iteritems()]
18717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18718 
 
18719 
  def __eq__(self, other):
18720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18721 
 
18722 
  def __ne__(self, other):
18723 
    return not (self == other)
18724 
 
18725 
class getAllReturnOrders_result:
18726 
  """
18727 
  Attributes:
18728 
   - success
18729 
  """
18730 
 
18731 
  thrift_spec = (
18732 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18733 
  )
18734 
 
18735 
  def __init__(self, success=None,):
18736 
    self.success = success
18737 
 
18738 
  def read(self, iprot):
18739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18741 
      return
18742 
    iprot.readStructBegin()
18743 
    while True:
18744 
      (fname, ftype, fid) = iprot.readFieldBegin()
18745 
      if ftype == TType.STOP:
18746 
        break
18747 
      if fid == 0:
18748 
        if ftype == TType.LIST:
18749 
          self.success = []
6188 rajveer 18750 
          (_etype449, _size446) = iprot.readListBegin()
18751 
          for _i450 in xrange(_size446):
18752 
            _elem451 = ReturnOrder()
18753 
            _elem451.read(iprot)
18754 
            self.success.append(_elem451)
5481 phani.kuma 18755 
          iprot.readListEnd()
18756 
        else:
18757 
          iprot.skip(ftype)
18758 
      else:
18759 
        iprot.skip(ftype)
18760 
      iprot.readFieldEnd()
18761 
    iprot.readStructEnd()
18762 
 
18763 
  def write(self, oprot):
18764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18766 
      return
18767 
    oprot.writeStructBegin('getAllReturnOrders_result')
18768 
    if self.success is not None:
18769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18771 
      for iter452 in self.success:
18772 
        iter452.write(oprot)
5481 phani.kuma 18773 
      oprot.writeListEnd()
18774 
      oprot.writeFieldEnd()
18775 
    oprot.writeFieldStop()
18776 
    oprot.writeStructEnd()
18777 
 
18778 
  def validate(self):
18779 
    return
18780 
 
18781 
 
18782 
  def __repr__(self):
18783 
    L = ['%s=%r' % (key, value)
18784 
      for key, value in self.__dict__.iteritems()]
18785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18786 
 
18787 
  def __eq__(self, other):
18788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18789 
 
18790 
  def __ne__(self, other):
18791 
    return not (self == other)
18792 
 
2700 chandransh 18793 
class getReturnOrder_args:
18794 
  """
18795 
  Attributes:
18796 
   - id
18797 
  """
18798 
 
18799 
  thrift_spec = (
18800 
    None, # 0
18801 
    (1, TType.I64, 'id', None, None, ), # 1
18802 
  )
18803 
 
18804 
  def __init__(self, id=None,):
18805 
    self.id = id
18806 
 
18807 
  def read(self, iprot):
18808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18810 
      return
18811 
    iprot.readStructBegin()
18812 
    while True:
18813 
      (fname, ftype, fid) = iprot.readFieldBegin()
18814 
      if ftype == TType.STOP:
18815 
        break
18816 
      if fid == 1:
18817 
        if ftype == TType.I64:
18818 
          self.id = iprot.readI64();
18819 
        else:
18820 
          iprot.skip(ftype)
18821 
      else:
18822 
        iprot.skip(ftype)
18823 
      iprot.readFieldEnd()
18824 
    iprot.readStructEnd()
18825 
 
18826 
  def write(self, oprot):
18827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18829 
      return
18830 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18831 
    if self.id is not None:
2700 chandransh 18832 
      oprot.writeFieldBegin('id', TType.I64, 1)
18833 
      oprot.writeI64(self.id)
18834 
      oprot.writeFieldEnd()
18835 
    oprot.writeFieldStop()
18836 
    oprot.writeStructEnd()
18837 
 
3431 rajveer 18838 
  def validate(self):
18839 
    return
18840 
 
18841 
 
2700 chandransh 18842 
  def __repr__(self):
18843 
    L = ['%s=%r' % (key, value)
18844 
      for key, value in self.__dict__.iteritems()]
18845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18846 
 
18847 
  def __eq__(self, other):
18848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18849 
 
18850 
  def __ne__(self, other):
18851 
    return not (self == other)
18852 
 
18853 
class getReturnOrder_result:
18854 
  """
18855 
  Attributes:
18856 
   - success
18857 
   - ex
18858 
  """
18859 
 
18860 
  thrift_spec = (
18861 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18863 
  )
18864 
 
18865 
  def __init__(self, success=None, ex=None,):
18866 
    self.success = success
18867 
    self.ex = ex
18868 
 
18869 
  def read(self, iprot):
18870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18872 
      return
18873 
    iprot.readStructBegin()
18874 
    while True:
18875 
      (fname, ftype, fid) = iprot.readFieldBegin()
18876 
      if ftype == TType.STOP:
18877 
        break
18878 
      if fid == 0:
18879 
        if ftype == TType.STRUCT:
18880 
          self.success = ReturnOrder()
18881 
          self.success.read(iprot)
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      elif fid == 1:
18885 
        if ftype == TType.STRUCT:
18886 
          self.ex = TransactionServiceException()
18887 
          self.ex.read(iprot)
18888 
        else:
18889 
          iprot.skip(ftype)
18890 
      else:
18891 
        iprot.skip(ftype)
18892 
      iprot.readFieldEnd()
18893 
    iprot.readStructEnd()
18894 
 
18895 
  def write(self, oprot):
18896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18898 
      return
18899 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18900 
    if self.success is not None:
2700 chandransh 18901 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18902 
      self.success.write(oprot)
18903 
      oprot.writeFieldEnd()
3431 rajveer 18904 
    if self.ex is not None:
2700 chandransh 18905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18906 
      self.ex.write(oprot)
18907 
      oprot.writeFieldEnd()
18908 
    oprot.writeFieldStop()
18909 
    oprot.writeStructEnd()
18910 
 
3431 rajveer 18911 
  def validate(self):
18912 
    return
18913 
 
18914 
 
2700 chandransh 18915 
  def __repr__(self):
18916 
    L = ['%s=%r' % (key, value)
18917 
      for key, value in self.__dict__.iteritems()]
18918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18919 
 
18920 
  def __eq__(self, other):
18921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18922 
 
18923 
  def __ne__(self, other):
18924 
    return not (self == other)
18925 
 
2690 chandransh 18926 
class processReturn_args:
18927 
  """
18928 
  Attributes:
18929 
   - returnOrderId
18930 
  """
18931 
 
18932 
  thrift_spec = (
18933 
    None, # 0
18934 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18935 
  )
18936 
 
18937 
  def __init__(self, returnOrderId=None,):
18938 
    self.returnOrderId = returnOrderId
18939 
 
18940 
  def read(self, iprot):
18941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18943 
      return
18944 
    iprot.readStructBegin()
18945 
    while True:
18946 
      (fname, ftype, fid) = iprot.readFieldBegin()
18947 
      if ftype == TType.STOP:
18948 
        break
18949 
      if fid == 1:
18950 
        if ftype == TType.I64:
18951 
          self.returnOrderId = iprot.readI64();
18952 
        else:
18953 
          iprot.skip(ftype)
18954 
      else:
18955 
        iprot.skip(ftype)
18956 
      iprot.readFieldEnd()
18957 
    iprot.readStructEnd()
18958 
 
18959 
  def write(self, oprot):
18960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18962 
      return
18963 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18964 
    if self.returnOrderId is not None:
2690 chandransh 18965 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18966 
      oprot.writeI64(self.returnOrderId)
18967 
      oprot.writeFieldEnd()
18968 
    oprot.writeFieldStop()
18969 
    oprot.writeStructEnd()
18970 
 
3431 rajveer 18971 
  def validate(self):
18972 
    return
18973 
 
18974 
 
2690 chandransh 18975 
  def __repr__(self):
18976 
    L = ['%s=%r' % (key, value)
18977 
      for key, value in self.__dict__.iteritems()]
18978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18979 
 
18980 
  def __eq__(self, other):
18981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18982 
 
18983 
  def __ne__(self, other):
18984 
    return not (self == other)
18985 
 
18986 
class processReturn_result:
18987 
  """
18988 
  Attributes:
18989 
   - ex
18990 
  """
18991 
 
18992 
  thrift_spec = (
18993 
    None, # 0
18994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18995 
  )
18996 
 
18997 
  def __init__(self, ex=None,):
18998 
    self.ex = ex
18999 
 
19000 
  def read(self, iprot):
19001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19003 
      return
19004 
    iprot.readStructBegin()
19005 
    while True:
19006 
      (fname, ftype, fid) = iprot.readFieldBegin()
19007 
      if ftype == TType.STOP:
19008 
        break
19009 
      if fid == 1:
19010 
        if ftype == TType.STRUCT:
19011 
          self.ex = TransactionServiceException()
19012 
          self.ex.read(iprot)
19013 
        else:
19014 
          iprot.skip(ftype)
19015 
      else:
19016 
        iprot.skip(ftype)
19017 
      iprot.readFieldEnd()
19018 
    iprot.readStructEnd()
19019 
 
19020 
  def write(self, oprot):
19021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19023 
      return
19024 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19025 
    if self.ex is not None:
2690 chandransh 19026 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19027 
      self.ex.write(oprot)
19028 
      oprot.writeFieldEnd()
19029 
    oprot.writeFieldStop()
19030 
    oprot.writeStructEnd()
19031 
 
3431 rajveer 19032 
  def validate(self):
19033 
    return
19034 
 
19035 
 
2690 chandransh 19036 
  def __repr__(self):
19037 
    L = ['%s=%r' % (key, value)
19038 
      for key, value in self.__dict__.iteritems()]
19039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19040 
 
19041 
  def __eq__(self, other):
19042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19043 
 
19044 
  def __ne__(self, other):
19045 
    return not (self == other)
19046 
 
3451 chandransh 19047 
class updateWeight_args:
19048 
  """
19049 
  Attributes:
19050 
   - orderId
19051 
   - weight
19052 
  """
19053 
 
19054 
  thrift_spec = (
19055 
    None, # 0
19056 
    (1, TType.I64, 'orderId', None, None, ), # 1
19057 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19058 
  )
19059 
 
19060 
  def __init__(self, orderId=None, weight=None,):
19061 
    self.orderId = orderId
19062 
    self.weight = weight
19063 
 
19064 
  def read(self, iprot):
19065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19067 
      return
19068 
    iprot.readStructBegin()
19069 
    while True:
19070 
      (fname, ftype, fid) = iprot.readFieldBegin()
19071 
      if ftype == TType.STOP:
19072 
        break
19073 
      if fid == 1:
19074 
        if ftype == TType.I64:
19075 
          self.orderId = iprot.readI64();
19076 
        else:
19077 
          iprot.skip(ftype)
19078 
      elif fid == 2:
19079 
        if ftype == TType.DOUBLE:
19080 
          self.weight = iprot.readDouble();
19081 
        else:
19082 
          iprot.skip(ftype)
19083 
      else:
19084 
        iprot.skip(ftype)
19085 
      iprot.readFieldEnd()
19086 
    iprot.readStructEnd()
19087 
 
19088 
  def write(self, oprot):
19089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19091 
      return
19092 
    oprot.writeStructBegin('updateWeight_args')
19093 
    if self.orderId is not None:
19094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19095 
      oprot.writeI64(self.orderId)
19096 
      oprot.writeFieldEnd()
19097 
    if self.weight is not None:
19098 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19099 
      oprot.writeDouble(self.weight)
19100 
      oprot.writeFieldEnd()
19101 
    oprot.writeFieldStop()
19102 
    oprot.writeStructEnd()
19103 
 
19104 
  def validate(self):
19105 
    return
19106 
 
19107 
 
19108 
  def __repr__(self):
19109 
    L = ['%s=%r' % (key, value)
19110 
      for key, value in self.__dict__.iteritems()]
19111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19112 
 
19113 
  def __eq__(self, other):
19114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19115 
 
19116 
  def __ne__(self, other):
19117 
    return not (self == other)
19118 
 
19119 
class updateWeight_result:
19120 
  """
19121 
  Attributes:
19122 
   - success
19123 
   - ex
19124 
  """
19125 
 
19126 
  thrift_spec = (
19127 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19129 
  )
19130 
 
19131 
  def __init__(self, success=None, ex=None,):
19132 
    self.success = success
19133 
    self.ex = ex
19134 
 
19135 
  def read(self, iprot):
19136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19138 
      return
19139 
    iprot.readStructBegin()
19140 
    while True:
19141 
      (fname, ftype, fid) = iprot.readFieldBegin()
19142 
      if ftype == TType.STOP:
19143 
        break
19144 
      if fid == 0:
19145 
        if ftype == TType.STRUCT:
19146 
          self.success = Order()
19147 
          self.success.read(iprot)
19148 
        else:
19149 
          iprot.skip(ftype)
19150 
      elif fid == 1:
19151 
        if ftype == TType.STRUCT:
19152 
          self.ex = TransactionServiceException()
19153 
          self.ex.read(iprot)
19154 
        else:
19155 
          iprot.skip(ftype)
19156 
      else:
19157 
        iprot.skip(ftype)
19158 
      iprot.readFieldEnd()
19159 
    iprot.readStructEnd()
19160 
 
19161 
  def write(self, oprot):
19162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19164 
      return
19165 
    oprot.writeStructBegin('updateWeight_result')
19166 
    if self.success is not None:
19167 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19168 
      self.success.write(oprot)
19169 
      oprot.writeFieldEnd()
19170 
    if self.ex is not None:
19171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19172 
      self.ex.write(oprot)
19173 
      oprot.writeFieldEnd()
19174 
    oprot.writeFieldStop()
19175 
    oprot.writeStructEnd()
19176 
 
19177 
  def validate(self):
19178 
    return
19179 
 
19180 
 
19181 
  def __repr__(self):
19182 
    L = ['%s=%r' % (key, value)
19183 
      for key, value in self.__dict__.iteritems()]
19184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19185 
 
19186 
  def __eq__(self, other):
19187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19188 
 
19189 
  def __ne__(self, other):
19190 
    return not (self == other)
3469 chandransh 19191 
 
19192 
class changeItem_args:
19193 
  """
19194 
  Attributes:
19195 
   - orderId
19196 
   - itemId
19197 
  """
19198 
 
19199 
  thrift_spec = (
19200 
    None, # 0
19201 
    (1, TType.I64, 'orderId', None, None, ), # 1
19202 
    (2, TType.I64, 'itemId', None, None, ), # 2
19203 
  )
19204 
 
19205 
  def __init__(self, orderId=None, itemId=None,):
19206 
    self.orderId = orderId
19207 
    self.itemId = itemId
19208 
 
19209 
  def read(self, iprot):
19210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19212 
      return
19213 
    iprot.readStructBegin()
19214 
    while True:
19215 
      (fname, ftype, fid) = iprot.readFieldBegin()
19216 
      if ftype == TType.STOP:
19217 
        break
19218 
      if fid == 1:
19219 
        if ftype == TType.I64:
19220 
          self.orderId = iprot.readI64();
19221 
        else:
19222 
          iprot.skip(ftype)
19223 
      elif fid == 2:
19224 
        if ftype == TType.I64:
19225 
          self.itemId = iprot.readI64();
19226 
        else:
19227 
          iprot.skip(ftype)
19228 
      else:
19229 
        iprot.skip(ftype)
19230 
      iprot.readFieldEnd()
19231 
    iprot.readStructEnd()
19232 
 
19233 
  def write(self, oprot):
19234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19236 
      return
19237 
    oprot.writeStructBegin('changeItem_args')
19238 
    if self.orderId is not None:
19239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19240 
      oprot.writeI64(self.orderId)
19241 
      oprot.writeFieldEnd()
19242 
    if self.itemId is not None:
19243 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19244 
      oprot.writeI64(self.itemId)
19245 
      oprot.writeFieldEnd()
19246 
    oprot.writeFieldStop()
19247 
    oprot.writeStructEnd()
19248 
 
19249 
  def validate(self):
19250 
    return
19251 
 
19252 
 
19253 
  def __repr__(self):
19254 
    L = ['%s=%r' % (key, value)
19255 
      for key, value in self.__dict__.iteritems()]
19256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19257 
 
19258 
  def __eq__(self, other):
19259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19260 
 
19261 
  def __ne__(self, other):
19262 
    return not (self == other)
19263 
 
19264 
class changeItem_result:
19265 
  """
19266 
  Attributes:
19267 
   - success
19268 
   - ex
19269 
  """
19270 
 
19271 
  thrift_spec = (
19272 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19274 
  )
19275 
 
19276 
  def __init__(self, success=None, ex=None,):
19277 
    self.success = success
19278 
    self.ex = ex
19279 
 
19280 
  def read(self, iprot):
19281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19283 
      return
19284 
    iprot.readStructBegin()
19285 
    while True:
19286 
      (fname, ftype, fid) = iprot.readFieldBegin()
19287 
      if ftype == TType.STOP:
19288 
        break
19289 
      if fid == 0:
19290 
        if ftype == TType.STRUCT:
19291 
          self.success = Order()
19292 
          self.success.read(iprot)
19293 
        else:
19294 
          iprot.skip(ftype)
19295 
      elif fid == 1:
19296 
        if ftype == TType.STRUCT:
19297 
          self.ex = TransactionServiceException()
19298 
          self.ex.read(iprot)
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      else:
19302 
        iprot.skip(ftype)
19303 
      iprot.readFieldEnd()
19304 
    iprot.readStructEnd()
19305 
 
19306 
  def write(self, oprot):
19307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19309 
      return
19310 
    oprot.writeStructBegin('changeItem_result')
19311 
    if self.success is not None:
19312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19313 
      self.success.write(oprot)
19314 
      oprot.writeFieldEnd()
19315 
    if self.ex is not None:
19316 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19317 
      self.ex.write(oprot)
19318 
      oprot.writeFieldEnd()
19319 
    oprot.writeFieldStop()
19320 
    oprot.writeStructEnd()
19321 
 
19322 
  def validate(self):
19323 
    return
19324 
 
19325 
 
19326 
  def __repr__(self):
19327 
    L = ['%s=%r' % (key, value)
19328 
      for key, value in self.__dict__.iteritems()]
19329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19330 
 
19331 
  def __eq__(self, other):
19332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19333 
 
19334 
  def __ne__(self, other):
19335 
    return not (self == other)
19336 
 
19337 
class shiftToWarehouse_args:
19338 
  """
19339 
  Attributes:
19340 
   - orderId
19341 
   - warehouseId
19342 
  """
19343 
 
19344 
  thrift_spec = (
19345 
    None, # 0
19346 
    (1, TType.I64, 'orderId', None, None, ), # 1
19347 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19348 
  )
19349 
 
19350 
  def __init__(self, orderId=None, warehouseId=None,):
19351 
    self.orderId = orderId
19352 
    self.warehouseId = warehouseId
19353 
 
19354 
  def read(self, iprot):
19355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19357 
      return
19358 
    iprot.readStructBegin()
19359 
    while True:
19360 
      (fname, ftype, fid) = iprot.readFieldBegin()
19361 
      if ftype == TType.STOP:
19362 
        break
19363 
      if fid == 1:
19364 
        if ftype == TType.I64:
19365 
          self.orderId = iprot.readI64();
19366 
        else:
19367 
          iprot.skip(ftype)
19368 
      elif fid == 2:
19369 
        if ftype == TType.I64:
19370 
          self.warehouseId = iprot.readI64();
19371 
        else:
19372 
          iprot.skip(ftype)
19373 
      else:
19374 
        iprot.skip(ftype)
19375 
      iprot.readFieldEnd()
19376 
    iprot.readStructEnd()
19377 
 
19378 
  def write(self, oprot):
19379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19381 
      return
19382 
    oprot.writeStructBegin('shiftToWarehouse_args')
19383 
    if self.orderId is not None:
19384 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19385 
      oprot.writeI64(self.orderId)
19386 
      oprot.writeFieldEnd()
19387 
    if self.warehouseId is not None:
19388 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19389 
      oprot.writeI64(self.warehouseId)
19390 
      oprot.writeFieldEnd()
19391 
    oprot.writeFieldStop()
19392 
    oprot.writeStructEnd()
19393 
 
19394 
  def validate(self):
19395 
    return
19396 
 
19397 
 
19398 
  def __repr__(self):
19399 
    L = ['%s=%r' % (key, value)
19400 
      for key, value in self.__dict__.iteritems()]
19401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19402 
 
19403 
  def __eq__(self, other):
19404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19405 
 
19406 
  def __ne__(self, other):
19407 
    return not (self == other)
19408 
 
19409 
class shiftToWarehouse_result:
19410 
  """
19411 
  Attributes:
19412 
   - success
19413 
   - ex
19414 
  """
19415 
 
19416 
  thrift_spec = (
19417 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19419 
  )
19420 
 
19421 
  def __init__(self, success=None, ex=None,):
19422 
    self.success = success
19423 
    self.ex = ex
19424 
 
19425 
  def read(self, iprot):
19426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19428 
      return
19429 
    iprot.readStructBegin()
19430 
    while True:
19431 
      (fname, ftype, fid) = iprot.readFieldBegin()
19432 
      if ftype == TType.STOP:
19433 
        break
19434 
      if fid == 0:
19435 
        if ftype == TType.STRUCT:
19436 
          self.success = Order()
19437 
          self.success.read(iprot)
19438 
        else:
19439 
          iprot.skip(ftype)
19440 
      elif fid == 1:
19441 
        if ftype == TType.STRUCT:
19442 
          self.ex = TransactionServiceException()
19443 
          self.ex.read(iprot)
19444 
        else:
19445 
          iprot.skip(ftype)
19446 
      else:
19447 
        iprot.skip(ftype)
19448 
      iprot.readFieldEnd()
19449 
    iprot.readStructEnd()
19450 
 
19451 
  def write(self, oprot):
19452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19454 
      return
19455 
    oprot.writeStructBegin('shiftToWarehouse_result')
19456 
    if self.success is not None:
19457 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19458 
      self.success.write(oprot)
19459 
      oprot.writeFieldEnd()
19460 
    if self.ex is not None:
19461 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19462 
      self.ex.write(oprot)
19463 
      oprot.writeFieldEnd()
19464 
    oprot.writeFieldStop()
19465 
    oprot.writeStructEnd()
19466 
 
19467 
  def validate(self):
19468 
    return
19469 
 
19470 
 
19471 
  def __repr__(self):
19472 
    L = ['%s=%r' % (key, value)
19473 
      for key, value in self.__dict__.iteritems()]
19474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19475 
 
19476 
  def __eq__(self, other):
19477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19478 
 
19479 
  def __ne__(self, other):
19480 
    return not (self == other)
3553 chandransh 19481 
 
19482 
class addDelayReason_args:
19483 
  """
19484 
  Attributes:
19485 
   - orderId
19486 
   - delayReason
3986 chandransh 19487 
   - furtherDelay
4647 rajveer 19488 
   - delayReasonText
3553 chandransh 19489 
  """
19490 
 
19491 
  thrift_spec = (
19492 
    None, # 0
19493 
    (1, TType.I64, 'orderId', None, None, ), # 1
19494 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19495 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19496 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19497 
  )
19498 
 
4647 rajveer 19499 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19500 
    self.orderId = orderId
19501 
    self.delayReason = delayReason
3986 chandransh 19502 
    self.furtherDelay = furtherDelay
4647 rajveer 19503 
    self.delayReasonText = delayReasonText
3553 chandransh 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 == 1:
19515 
        if ftype == TType.I64:
19516 
          self.orderId = iprot.readI64();
19517 
        else:
19518 
          iprot.skip(ftype)
19519 
      elif fid == 2:
19520 
        if ftype == TType.I32:
19521 
          self.delayReason = iprot.readI32();
19522 
        else:
19523 
          iprot.skip(ftype)
3986 chandransh 19524 
      elif fid == 3:
19525 
        if ftype == TType.I64:
19526 
          self.furtherDelay = iprot.readI64();
19527 
        else:
19528 
          iprot.skip(ftype)
4647 rajveer 19529 
      elif fid == 4:
19530 
        if ftype == TType.STRING:
19531 
          self.delayReasonText = iprot.readString();
19532 
        else:
19533 
          iprot.skip(ftype)
3553 chandransh 19534 
      else:
19535 
        iprot.skip(ftype)
19536 
      iprot.readFieldEnd()
19537 
    iprot.readStructEnd()
19538 
 
19539 
  def write(self, oprot):
19540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19542 
      return
19543 
    oprot.writeStructBegin('addDelayReason_args')
19544 
    if self.orderId is not None:
19545 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19546 
      oprot.writeI64(self.orderId)
19547 
      oprot.writeFieldEnd()
19548 
    if self.delayReason is not None:
19549 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19550 
      oprot.writeI32(self.delayReason)
19551 
      oprot.writeFieldEnd()
3986 chandransh 19552 
    if self.furtherDelay is not None:
19553 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19554 
      oprot.writeI64(self.furtherDelay)
19555 
      oprot.writeFieldEnd()
4647 rajveer 19556 
    if self.delayReasonText is not None:
19557 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19558 
      oprot.writeString(self.delayReasonText)
19559 
      oprot.writeFieldEnd()
3553 chandransh 19560 
    oprot.writeFieldStop()
19561 
    oprot.writeStructEnd()
19562 
 
19563 
  def validate(self):
19564 
    return
19565 
 
19566 
 
19567 
  def __repr__(self):
19568 
    L = ['%s=%r' % (key, value)
19569 
      for key, value in self.__dict__.iteritems()]
19570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19571 
 
19572 
  def __eq__(self, other):
19573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19574 
 
19575 
  def __ne__(self, other):
19576 
    return not (self == other)
19577 
 
19578 
class addDelayReason_result:
19579 
  """
19580 
  Attributes:
19581 
   - success
19582 
   - ex
19583 
  """
19584 
 
19585 
  thrift_spec = (
19586 
    (0, TType.BOOL, 'success', None, None, ), # 0
19587 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19588 
  )
19589 
 
19590 
  def __init__(self, success=None, ex=None,):
19591 
    self.success = success
19592 
    self.ex = ex
19593 
 
19594 
  def read(self, iprot):
19595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19597 
      return
19598 
    iprot.readStructBegin()
19599 
    while True:
19600 
      (fname, ftype, fid) = iprot.readFieldBegin()
19601 
      if ftype == TType.STOP:
19602 
        break
19603 
      if fid == 0:
19604 
        if ftype == TType.BOOL:
19605 
          self.success = iprot.readBool();
19606 
        else:
19607 
          iprot.skip(ftype)
19608 
      elif fid == 1:
19609 
        if ftype == TType.STRUCT:
19610 
          self.ex = TransactionServiceException()
19611 
          self.ex.read(iprot)
19612 
        else:
19613 
          iprot.skip(ftype)
19614 
      else:
19615 
        iprot.skip(ftype)
19616 
      iprot.readFieldEnd()
19617 
    iprot.readStructEnd()
19618 
 
19619 
  def write(self, oprot):
19620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19622 
      return
19623 
    oprot.writeStructBegin('addDelayReason_result')
19624 
    if self.success is not None:
19625 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19626 
      oprot.writeBool(self.success)
19627 
      oprot.writeFieldEnd()
19628 
    if self.ex is not None:
19629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19630 
      self.ex.write(oprot)
19631 
      oprot.writeFieldEnd()
19632 
    oprot.writeFieldStop()
19633 
    oprot.writeStructEnd()
19634 
 
19635 
  def validate(self):
19636 
    return
19637 
 
19638 
 
19639 
  def __repr__(self):
19640 
    L = ['%s=%r' % (key, value)
19641 
      for key, value in self.__dict__.iteritems()]
19642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19643 
 
19644 
  def __eq__(self, other):
19645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19646 
 
19647 
  def __ne__(self, other):
19648 
    return not (self == other)
3956 chandransh 19649 
 
19650 
class reconcileCodCollection_args:
19651 
  """
19652 
  Attributes:
19653 
   - collectedAmountMap
19654 
   - xferBy
19655 
   - xferTxnId
19656 
   - xferDate
19657 
  """
19658 
 
19659 
  thrift_spec = (
19660 
    None, # 0
19661 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19662 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19663 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19664 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19665 
  )
19666 
 
19667 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19668 
    self.collectedAmountMap = collectedAmountMap
19669 
    self.xferBy = xferBy
19670 
    self.xferTxnId = xferTxnId
19671 
    self.xferDate = xferDate
19672 
 
19673 
  def read(self, iprot):
19674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19676 
      return
19677 
    iprot.readStructBegin()
19678 
    while True:
19679 
      (fname, ftype, fid) = iprot.readFieldBegin()
19680 
      if ftype == TType.STOP:
19681 
        break
19682 
      if fid == 1:
19683 
        if ftype == TType.MAP:
19684 
          self.collectedAmountMap = {}
6188 rajveer 19685 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19686 
          for _i457 in xrange(_size453):
19687 
            _key458 = iprot.readString();
19688 
            _val459 = iprot.readDouble();
19689 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19690 
          iprot.readMapEnd()
19691 
        else:
19692 
          iprot.skip(ftype)
19693 
      elif fid == 2:
19694 
        if ftype == TType.STRING:
19695 
          self.xferBy = iprot.readString();
19696 
        else:
19697 
          iprot.skip(ftype)
19698 
      elif fid == 3:
19699 
        if ftype == TType.STRING:
19700 
          self.xferTxnId = iprot.readString();
19701 
        else:
19702 
          iprot.skip(ftype)
19703 
      elif fid == 4:
19704 
        if ftype == TType.I64:
19705 
          self.xferDate = iprot.readI64();
19706 
        else:
19707 
          iprot.skip(ftype)
19708 
      else:
19709 
        iprot.skip(ftype)
19710 
      iprot.readFieldEnd()
19711 
    iprot.readStructEnd()
19712 
 
19713 
  def write(self, oprot):
19714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19716 
      return
19717 
    oprot.writeStructBegin('reconcileCodCollection_args')
19718 
    if self.collectedAmountMap is not None:
19719 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19720 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19721 
      for kiter460,viter461 in self.collectedAmountMap.items():
19722 
        oprot.writeString(kiter460)
19723 
        oprot.writeDouble(viter461)
3956 chandransh 19724 
      oprot.writeMapEnd()
19725 
      oprot.writeFieldEnd()
19726 
    if self.xferBy is not None:
19727 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19728 
      oprot.writeString(self.xferBy)
19729 
      oprot.writeFieldEnd()
19730 
    if self.xferTxnId is not None:
19731 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19732 
      oprot.writeString(self.xferTxnId)
19733 
      oprot.writeFieldEnd()
19734 
    if self.xferDate is not None:
19735 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19736 
      oprot.writeI64(self.xferDate)
19737 
      oprot.writeFieldEnd()
19738 
    oprot.writeFieldStop()
19739 
    oprot.writeStructEnd()
19740 
 
19741 
  def validate(self):
19742 
    return
19743 
 
19744 
 
19745 
  def __repr__(self):
19746 
    L = ['%s=%r' % (key, value)
19747 
      for key, value in self.__dict__.iteritems()]
19748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19749 
 
19750 
  def __eq__(self, other):
19751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19752 
 
19753 
  def __ne__(self, other):
19754 
    return not (self == other)
19755 
 
19756 
class reconcileCodCollection_result:
19757 
  """
19758 
  Attributes:
19759 
   - success
19760 
   - ex
19761 
  """
19762 
 
19763 
  thrift_spec = (
19764 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19765 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19766 
  )
19767 
 
19768 
  def __init__(self, success=None, ex=None,):
19769 
    self.success = success
19770 
    self.ex = ex
19771 
 
19772 
  def read(self, iprot):
19773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19775 
      return
19776 
    iprot.readStructBegin()
19777 
    while True:
19778 
      (fname, ftype, fid) = iprot.readFieldBegin()
19779 
      if ftype == TType.STOP:
19780 
        break
19781 
      if fid == 0:
19782 
        if ftype == TType.MAP:
19783 
          self.success = {}
6188 rajveer 19784 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19785 
          for _i466 in xrange(_size462):
19786 
            _key467 = iprot.readString();
19787 
            _val468 = iprot.readString();
19788 
            self.success[_key467] = _val468
3956 chandransh 19789 
          iprot.readMapEnd()
19790 
        else:
19791 
          iprot.skip(ftype)
19792 
      elif fid == 1:
19793 
        if ftype == TType.STRUCT:
19794 
          self.ex = TransactionServiceException()
19795 
          self.ex.read(iprot)
19796 
        else:
19797 
          iprot.skip(ftype)
19798 
      else:
19799 
        iprot.skip(ftype)
19800 
      iprot.readFieldEnd()
19801 
    iprot.readStructEnd()
19802 
 
19803 
  def write(self, oprot):
19804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19806 
      return
19807 
    oprot.writeStructBegin('reconcileCodCollection_result')
19808 
    if self.success is not None:
19809 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19810 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19811 
      for kiter469,viter470 in self.success.items():
19812 
        oprot.writeString(kiter469)
19813 
        oprot.writeString(viter470)
3956 chandransh 19814 
      oprot.writeMapEnd()
19815 
      oprot.writeFieldEnd()
19816 
    if self.ex is not None:
19817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19818 
      self.ex.write(oprot)
19819 
      oprot.writeFieldEnd()
19820 
    oprot.writeFieldStop()
19821 
    oprot.writeStructEnd()
19822 
 
19823 
  def validate(self):
19824 
    return
19825 
 
19826 
 
19827 
  def __repr__(self):
19828 
    L = ['%s=%r' % (key, value)
19829 
      for key, value in self.__dict__.iteritems()]
19830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19831 
 
19832 
  def __eq__(self, other):
19833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19834 
 
19835 
  def __ne__(self, other):
19836 
    return not (self == other)
4008 mandeep.dh 19837 
 
19838 
class getTransactionsRequiringExtraProcessing_args:
19839 
  """
19840 
  Attributes:
19841 
   - category
19842 
  """
19843 
 
19844 
  thrift_spec = (
19845 
    None, # 0
19846 
    (1, TType.I32, 'category', None, None, ), # 1
19847 
  )
19848 
 
19849 
  def __init__(self, category=None,):
19850 
    self.category = category
19851 
 
19852 
  def read(self, iprot):
19853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19855 
      return
19856 
    iprot.readStructBegin()
19857 
    while True:
19858 
      (fname, ftype, fid) = iprot.readFieldBegin()
19859 
      if ftype == TType.STOP:
19860 
        break
19861 
      if fid == 1:
19862 
        if ftype == TType.I32:
19863 
          self.category = iprot.readI32();
19864 
        else:
19865 
          iprot.skip(ftype)
19866 
      else:
19867 
        iprot.skip(ftype)
19868 
      iprot.readFieldEnd()
19869 
    iprot.readStructEnd()
19870 
 
19871 
  def write(self, oprot):
19872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19874 
      return
19875 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19876 
    if self.category is not None:
19877 
      oprot.writeFieldBegin('category', TType.I32, 1)
19878 
      oprot.writeI32(self.category)
19879 
      oprot.writeFieldEnd()
19880 
    oprot.writeFieldStop()
19881 
    oprot.writeStructEnd()
19882 
 
19883 
  def validate(self):
19884 
    return
19885 
 
19886 
 
19887 
  def __repr__(self):
19888 
    L = ['%s=%r' % (key, value)
19889 
      for key, value in self.__dict__.iteritems()]
19890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19891 
 
19892 
  def __eq__(self, other):
19893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19894 
 
19895 
  def __ne__(self, other):
19896 
    return not (self == other)
19897 
 
19898 
class getTransactionsRequiringExtraProcessing_result:
19899 
  """
19900 
  Attributes:
19901 
   - success
19902 
  """
19903 
 
19904 
  thrift_spec = (
19905 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19906 
  )
19907 
 
19908 
  def __init__(self, success=None,):
19909 
    self.success = success
19910 
 
19911 
  def read(self, iprot):
19912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19914 
      return
19915 
    iprot.readStructBegin()
19916 
    while True:
19917 
      (fname, ftype, fid) = iprot.readFieldBegin()
19918 
      if ftype == TType.STOP:
19919 
        break
19920 
      if fid == 0:
19921 
        if ftype == TType.LIST:
19922 
          self.success = []
6188 rajveer 19923 
          (_etype474, _size471) = iprot.readListBegin()
19924 
          for _i475 in xrange(_size471):
19925 
            _elem476 = iprot.readI64();
19926 
            self.success.append(_elem476)
4008 mandeep.dh 19927 
          iprot.readListEnd()
19928 
        else:
19929 
          iprot.skip(ftype)
19930 
      else:
19931 
        iprot.skip(ftype)
19932 
      iprot.readFieldEnd()
19933 
    iprot.readStructEnd()
19934 
 
19935 
  def write(self, oprot):
19936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19938 
      return
19939 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19940 
    if self.success is not None:
19941 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19942 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19943 
      for iter477 in self.success:
19944 
        oprot.writeI64(iter477)
4008 mandeep.dh 19945 
      oprot.writeListEnd()
19946 
      oprot.writeFieldEnd()
19947 
    oprot.writeFieldStop()
19948 
    oprot.writeStructEnd()
19949 
 
19950 
  def validate(self):
19951 
    return
19952 
 
19953 
 
19954 
  def __repr__(self):
19955 
    L = ['%s=%r' % (key, value)
19956 
      for key, value in self.__dict__.iteritems()]
19957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19958 
 
19959 
  def __eq__(self, other):
19960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19961 
 
19962 
  def __ne__(self, other):
19963 
    return not (self == other)
19964 
 
19965 
class markTransactionAsProcessed_args:
19966 
  """
19967 
  Attributes:
19968 
   - transactionId
19969 
   - category
19970 
  """
19971 
 
19972 
  thrift_spec = (
19973 
    None, # 0
19974 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19975 
    (2, TType.I32, 'category', None, None, ), # 2
19976 
  )
19977 
 
19978 
  def __init__(self, transactionId=None, category=None,):
19979 
    self.transactionId = transactionId
19980 
    self.category = category
19981 
 
19982 
  def read(self, iprot):
19983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19985 
      return
19986 
    iprot.readStructBegin()
19987 
    while True:
19988 
      (fname, ftype, fid) = iprot.readFieldBegin()
19989 
      if ftype == TType.STOP:
19990 
        break
19991 
      if fid == 1:
19992 
        if ftype == TType.I64:
19993 
          self.transactionId = iprot.readI64();
19994 
        else:
19995 
          iprot.skip(ftype)
19996 
      elif fid == 2:
19997 
        if ftype == TType.I32:
19998 
          self.category = iprot.readI32();
19999 
        else:
20000 
          iprot.skip(ftype)
20001 
      else:
20002 
        iprot.skip(ftype)
20003 
      iprot.readFieldEnd()
20004 
    iprot.readStructEnd()
20005 
 
20006 
  def write(self, oprot):
20007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20009 
      return
20010 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20011 
    if self.transactionId is not None:
20012 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20013 
      oprot.writeI64(self.transactionId)
20014 
      oprot.writeFieldEnd()
20015 
    if self.category is not None:
20016 
      oprot.writeFieldBegin('category', TType.I32, 2)
20017 
      oprot.writeI32(self.category)
20018 
      oprot.writeFieldEnd()
20019 
    oprot.writeFieldStop()
20020 
    oprot.writeStructEnd()
20021 
 
20022 
  def validate(self):
20023 
    return
20024 
 
20025 
 
20026 
  def __repr__(self):
20027 
    L = ['%s=%r' % (key, value)
20028 
      for key, value in self.__dict__.iteritems()]
20029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20030 
 
20031 
  def __eq__(self, other):
20032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20033 
 
20034 
  def __ne__(self, other):
20035 
    return not (self == other)
20036 
 
20037 
class markTransactionAsProcessed_result:
20038 
 
20039 
  thrift_spec = (
20040 
  )
20041 
 
20042 
  def read(self, iprot):
20043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20045 
      return
20046 
    iprot.readStructBegin()
20047 
    while True:
20048 
      (fname, ftype, fid) = iprot.readFieldBegin()
20049 
      if ftype == TType.STOP:
20050 
        break
20051 
      else:
20052 
        iprot.skip(ftype)
20053 
      iprot.readFieldEnd()
20054 
    iprot.readStructEnd()
20055 
 
20056 
  def write(self, oprot):
20057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20059 
      return
20060 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20061 
    oprot.writeFieldStop()
20062 
    oprot.writeStructEnd()
20063 
 
20064 
  def validate(self):
20065 
    return
20066 
 
20067 
 
20068 
  def __repr__(self):
20069 
    L = ['%s=%r' % (key, value)
20070 
      for key, value in self.__dict__.iteritems()]
20071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20072 
 
20073 
  def __eq__(self, other):
20074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20075 
 
20076 
  def __ne__(self, other):
20077 
    return not (self == other)
4018 chandransh 20078 
 
20079 
class getItemWiseRiskyOrdersCount_args:
20080 
 
20081 
  thrift_spec = (
20082 
  )
20083 
 
20084 
  def read(self, iprot):
20085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20087 
      return
20088 
    iprot.readStructBegin()
20089 
    while True:
20090 
      (fname, ftype, fid) = iprot.readFieldBegin()
20091 
      if ftype == TType.STOP:
20092 
        break
20093 
      else:
20094 
        iprot.skip(ftype)
20095 
      iprot.readFieldEnd()
20096 
    iprot.readStructEnd()
20097 
 
20098 
  def write(self, oprot):
20099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20101 
      return
20102 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20103 
    oprot.writeFieldStop()
20104 
    oprot.writeStructEnd()
20105 
 
20106 
  def validate(self):
20107 
    return
20108 
 
20109 
 
20110 
  def __repr__(self):
20111 
    L = ['%s=%r' % (key, value)
20112 
      for key, value in self.__dict__.iteritems()]
20113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20114 
 
20115 
  def __eq__(self, other):
20116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20117 
 
20118 
  def __ne__(self, other):
20119 
    return not (self == other)
20120 
 
20121 
class getItemWiseRiskyOrdersCount_result:
20122 
  """
20123 
  Attributes:
20124 
   - success
20125 
  """
20126 
 
20127 
  thrift_spec = (
20128 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20129 
  )
20130 
 
20131 
  def __init__(self, success=None,):
20132 
    self.success = success
20133 
 
20134 
  def read(self, iprot):
20135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20137 
      return
20138 
    iprot.readStructBegin()
20139 
    while True:
20140 
      (fname, ftype, fid) = iprot.readFieldBegin()
20141 
      if ftype == TType.STOP:
20142 
        break
20143 
      if fid == 0:
20144 
        if ftype == TType.MAP:
20145 
          self.success = {}
6188 rajveer 20146 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20147 
          for _i482 in xrange(_size478):
20148 
            _key483 = iprot.readI64();
20149 
            _val484 = iprot.readI64();
20150 
            self.success[_key483] = _val484
4018 chandransh 20151 
          iprot.readMapEnd()
20152 
        else:
20153 
          iprot.skip(ftype)
20154 
      else:
20155 
        iprot.skip(ftype)
20156 
      iprot.readFieldEnd()
20157 
    iprot.readStructEnd()
20158 
 
20159 
  def write(self, oprot):
20160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20162 
      return
20163 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20164 
    if self.success is not None:
20165 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20166 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20167 
      for kiter485,viter486 in self.success.items():
20168 
        oprot.writeI64(kiter485)
20169 
        oprot.writeI64(viter486)
4018 chandransh 20170 
      oprot.writeMapEnd()
20171 
      oprot.writeFieldEnd()
20172 
    oprot.writeFieldStop()
20173 
    oprot.writeStructEnd()
20174 
 
20175 
  def validate(self):
20176 
    return
20177 
 
20178 
 
20179 
  def __repr__(self):
20180 
    L = ['%s=%r' % (key, value)
20181 
      for key, value in self.__dict__.iteritems()]
20182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20183 
 
20184 
  def __eq__(self, other):
20185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20186 
 
20187 
  def __ne__(self, other):
20188 
    return not (self == other)
4247 rajveer 20189 
 
4295 varun.gupt 20190 
class getOrdersForItemIds_args:
20191 
  """
20192 
  Attributes:
20193 
   - itemIds
20194 
  """
20195 
 
20196 
  thrift_spec = (
20197 
    None, # 0
20198 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20199 
  )
20200 
 
20201 
  def __init__(self, itemIds=None,):
20202 
    self.itemIds = itemIds
20203 
 
20204 
  def read(self, iprot):
20205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20207 
      return
20208 
    iprot.readStructBegin()
20209 
    while True:
20210 
      (fname, ftype, fid) = iprot.readFieldBegin()
20211 
      if ftype == TType.STOP:
20212 
        break
20213 
      if fid == 1:
20214 
        if ftype == TType.LIST:
20215 
          self.itemIds = []
6188 rajveer 20216 
          (_etype490, _size487) = iprot.readListBegin()
20217 
          for _i491 in xrange(_size487):
20218 
            _elem492 = iprot.readI64();
20219 
            self.itemIds.append(_elem492)
4295 varun.gupt 20220 
          iprot.readListEnd()
20221 
        else:
20222 
          iprot.skip(ftype)
20223 
      else:
20224 
        iprot.skip(ftype)
20225 
      iprot.readFieldEnd()
20226 
    iprot.readStructEnd()
20227 
 
20228 
  def write(self, oprot):
20229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20231 
      return
20232 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20233 
    if self.itemIds is not None:
20234 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20235 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20236 
      for iter493 in self.itemIds:
20237 
        oprot.writeI64(iter493)
4295 varun.gupt 20238 
      oprot.writeListEnd()
20239 
      oprot.writeFieldEnd()
20240 
    oprot.writeFieldStop()
20241 
    oprot.writeStructEnd()
20242 
 
20243 
  def validate(self):
20244 
    return
20245 
 
20246 
 
20247 
  def __repr__(self):
20248 
    L = ['%s=%r' % (key, value)
20249 
      for key, value in self.__dict__.iteritems()]
20250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20251 
 
20252 
  def __eq__(self, other):
20253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20254 
 
20255 
  def __ne__(self, other):
20256 
    return not (self == other)
20257 
 
20258 
class getOrdersForItemIds_result:
20259 
  """
20260 
  Attributes:
20261 
   - success
20262 
  """
20263 
 
20264 
  thrift_spec = (
20265 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20266 
  )
20267 
 
20268 
  def __init__(self, success=None,):
20269 
    self.success = success
20270 
 
20271 
  def read(self, iprot):
20272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20274 
      return
20275 
    iprot.readStructBegin()
20276 
    while True:
20277 
      (fname, ftype, fid) = iprot.readFieldBegin()
20278 
      if ftype == TType.STOP:
20279 
        break
20280 
      if fid == 0:
20281 
        if ftype == TType.LIST:
20282 
          self.success = []
6188 rajveer 20283 
          (_etype497, _size494) = iprot.readListBegin()
20284 
          for _i498 in xrange(_size494):
20285 
            _elem499 = Order()
20286 
            _elem499.read(iprot)
20287 
            self.success.append(_elem499)
4295 varun.gupt 20288 
          iprot.readListEnd()
20289 
        else:
20290 
          iprot.skip(ftype)
20291 
      else:
20292 
        iprot.skip(ftype)
20293 
      iprot.readFieldEnd()
20294 
    iprot.readStructEnd()
20295 
 
20296 
  def write(self, oprot):
20297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20299 
      return
20300 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20301 
    if self.success is not None:
20302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20304 
      for iter500 in self.success:
20305 
        iter500.write(oprot)
4295 varun.gupt 20306 
      oprot.writeListEnd()
20307 
      oprot.writeFieldEnd()
20308 
    oprot.writeFieldStop()
20309 
    oprot.writeStructEnd()
20310 
 
20311 
  def validate(self):
20312 
    return
20313 
 
20314 
 
20315 
  def __repr__(self):
20316 
    L = ['%s=%r' % (key, value)
20317 
      for key, value in self.__dict__.iteritems()]
20318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20319 
 
20320 
  def __eq__(self, other):
20321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20322 
 
20323 
  def __ne__(self, other):
20324 
    return not (self == other)
20325 
 
4247 rajveer 20326 
class markOrderCancellationRequestReceived_args:
20327 
  """
20328 
  Attributes:
20329 
   - orderId
20330 
  """
20331 
 
20332 
  thrift_spec = (
20333 
    None, # 0
20334 
    (1, TType.I64, 'orderId', None, None, ), # 1
20335 
  )
20336 
 
20337 
  def __init__(self, orderId=None,):
20338 
    self.orderId = orderId
20339 
 
20340 
  def read(self, iprot):
20341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20343 
      return
20344 
    iprot.readStructBegin()
20345 
    while True:
20346 
      (fname, ftype, fid) = iprot.readFieldBegin()
20347 
      if ftype == TType.STOP:
20348 
        break
20349 
      if fid == 1:
20350 
        if ftype == TType.I64:
20351 
          self.orderId = iprot.readI64();
20352 
        else:
20353 
          iprot.skip(ftype)
20354 
      else:
20355 
        iprot.skip(ftype)
20356 
      iprot.readFieldEnd()
20357 
    iprot.readStructEnd()
20358 
 
20359 
  def write(self, oprot):
20360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20362 
      return
20363 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20364 
    if self.orderId is not None:
20365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20366 
      oprot.writeI64(self.orderId)
20367 
      oprot.writeFieldEnd()
20368 
    oprot.writeFieldStop()
20369 
    oprot.writeStructEnd()
20370 
 
20371 
  def validate(self):
20372 
    return
20373 
 
20374 
 
20375 
  def __repr__(self):
20376 
    L = ['%s=%r' % (key, value)
20377 
      for key, value in self.__dict__.iteritems()]
20378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20379 
 
20380 
  def __eq__(self, other):
20381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20382 
 
20383 
  def __ne__(self, other):
20384 
    return not (self == other)
20385 
 
20386 
class markOrderCancellationRequestReceived_result:
20387 
  """
20388 
  Attributes:
20389 
   - ex
20390 
  """
20391 
 
20392 
  thrift_spec = (
20393 
    None, # 0
20394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20395 
  )
20396 
 
20397 
  def __init__(self, ex=None,):
20398 
    self.ex = ex
20399 
 
20400 
  def read(self, iprot):
20401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20403 
      return
20404 
    iprot.readStructBegin()
20405 
    while True:
20406 
      (fname, ftype, fid) = iprot.readFieldBegin()
20407 
      if ftype == TType.STOP:
20408 
        break
20409 
      if fid == 1:
20410 
        if ftype == TType.STRUCT:
20411 
          self.ex = TransactionServiceException()
20412 
          self.ex.read(iprot)
20413 
        else:
20414 
          iprot.skip(ftype)
20415 
      else:
20416 
        iprot.skip(ftype)
20417 
      iprot.readFieldEnd()
20418 
    iprot.readStructEnd()
20419 
 
20420 
  def write(self, oprot):
20421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20423 
      return
20424 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20425 
    if self.ex is not None:
20426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20427 
      self.ex.write(oprot)
20428 
      oprot.writeFieldEnd()
20429 
    oprot.writeFieldStop()
20430 
    oprot.writeStructEnd()
20431 
 
20432 
  def validate(self):
20433 
    return
20434 
 
20435 
 
20436 
  def __repr__(self):
20437 
    L = ['%s=%r' % (key, value)
20438 
      for key, value in self.__dict__.iteritems()]
20439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20440 
 
20441 
  def __eq__(self, other):
20442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20443 
 
20444 
  def __ne__(self, other):
20445 
    return not (self == other)
20446 
 
20447 
class markOrderCancellationRequestConfirmed_args:
20448 
  """
20449 
  Attributes:
20450 
   - orderId
20451 
  """
20452 
 
20453 
  thrift_spec = (
20454 
    None, # 0
20455 
    (1, TType.I64, 'orderId', None, None, ), # 1
20456 
  )
20457 
 
20458 
  def __init__(self, orderId=None,):
20459 
    self.orderId = orderId
20460 
 
20461 
  def read(self, iprot):
20462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20464 
      return
20465 
    iprot.readStructBegin()
20466 
    while True:
20467 
      (fname, ftype, fid) = iprot.readFieldBegin()
20468 
      if ftype == TType.STOP:
20469 
        break
20470 
      if fid == 1:
20471 
        if ftype == TType.I64:
20472 
          self.orderId = iprot.readI64();
20473 
        else:
20474 
          iprot.skip(ftype)
20475 
      else:
20476 
        iprot.skip(ftype)
20477 
      iprot.readFieldEnd()
20478 
    iprot.readStructEnd()
20479 
 
20480 
  def write(self, oprot):
20481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20483 
      return
20484 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20485 
    if self.orderId is not None:
20486 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20487 
      oprot.writeI64(self.orderId)
20488 
      oprot.writeFieldEnd()
20489 
    oprot.writeFieldStop()
20490 
    oprot.writeStructEnd()
20491 
 
20492 
  def validate(self):
20493 
    return
20494 
 
20495 
 
20496 
  def __repr__(self):
20497 
    L = ['%s=%r' % (key, value)
20498 
      for key, value in self.__dict__.iteritems()]
20499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20500 
 
20501 
  def __eq__(self, other):
20502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20503 
 
20504 
  def __ne__(self, other):
20505 
    return not (self == other)
20506 
 
20507 
class markOrderCancellationRequestConfirmed_result:
20508 
  """
20509 
  Attributes:
20510 
   - ex
20511 
  """
20512 
 
20513 
  thrift_spec = (
20514 
    None, # 0
20515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20516 
  )
20517 
 
20518 
  def __init__(self, ex=None,):
20519 
    self.ex = ex
20520 
 
20521 
  def read(self, iprot):
20522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20524 
      return
20525 
    iprot.readStructBegin()
20526 
    while True:
20527 
      (fname, ftype, fid) = iprot.readFieldBegin()
20528 
      if ftype == TType.STOP:
20529 
        break
20530 
      if fid == 1:
20531 
        if ftype == TType.STRUCT:
20532 
          self.ex = TransactionServiceException()
20533 
          self.ex.read(iprot)
20534 
        else:
20535 
          iprot.skip(ftype)
20536 
      else:
20537 
        iprot.skip(ftype)
20538 
      iprot.readFieldEnd()
20539 
    iprot.readStructEnd()
20540 
 
20541 
  def write(self, oprot):
20542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20544 
      return
20545 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20546 
    if self.ex is not None:
20547 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20548 
      self.ex.write(oprot)
20549 
      oprot.writeFieldEnd()
20550 
    oprot.writeFieldStop()
20551 
    oprot.writeStructEnd()
20552 
 
20553 
  def validate(self):
20554 
    return
20555 
 
20556 
 
20557 
  def __repr__(self):
20558 
    L = ['%s=%r' % (key, value)
20559 
      for key, value in self.__dict__.iteritems()]
20560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20561 
 
20562 
  def __eq__(self, other):
20563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20564 
 
20565 
  def __ne__(self, other):
20566 
    return not (self == other)
20567 
 
20568 
class markOrderCancellationRequestDenied_args:
20569 
  """
20570 
  Attributes:
20571 
   - orderId
20572 
  """
20573 
 
20574 
  thrift_spec = (
20575 
    None, # 0
20576 
    (1, TType.I64, 'orderId', None, None, ), # 1
20577 
  )
20578 
 
20579 
  def __init__(self, orderId=None,):
20580 
    self.orderId = orderId
20581 
 
20582 
  def read(self, iprot):
20583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20585 
      return
20586 
    iprot.readStructBegin()
20587 
    while True:
20588 
      (fname, ftype, fid) = iprot.readFieldBegin()
20589 
      if ftype == TType.STOP:
20590 
        break
20591 
      if fid == 1:
20592 
        if ftype == TType.I64:
20593 
          self.orderId = iprot.readI64();
20594 
        else:
20595 
          iprot.skip(ftype)
20596 
      else:
20597 
        iprot.skip(ftype)
20598 
      iprot.readFieldEnd()
20599 
    iprot.readStructEnd()
20600 
 
20601 
  def write(self, oprot):
20602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20604 
      return
20605 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20606 
    if self.orderId is not None:
20607 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20608 
      oprot.writeI64(self.orderId)
20609 
      oprot.writeFieldEnd()
20610 
    oprot.writeFieldStop()
20611 
    oprot.writeStructEnd()
20612 
 
20613 
  def validate(self):
20614 
    return
20615 
 
20616 
 
20617 
  def __repr__(self):
20618 
    L = ['%s=%r' % (key, value)
20619 
      for key, value in self.__dict__.iteritems()]
20620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20621 
 
20622 
  def __eq__(self, other):
20623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20624 
 
20625 
  def __ne__(self, other):
20626 
    return not (self == other)
20627 
 
20628 
class markOrderCancellationRequestDenied_result:
20629 
  """
20630 
  Attributes:
20631 
   - ex
20632 
  """
20633 
 
20634 
  thrift_spec = (
20635 
    None, # 0
20636 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20637 
  )
20638 
 
20639 
  def __init__(self, ex=None,):
20640 
    self.ex = ex
20641 
 
20642 
  def read(self, iprot):
20643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20645 
      return
20646 
    iprot.readStructBegin()
20647 
    while True:
20648 
      (fname, ftype, fid) = iprot.readFieldBegin()
20649 
      if ftype == TType.STOP:
20650 
        break
20651 
      if fid == 1:
20652 
        if ftype == TType.STRUCT:
20653 
          self.ex = TransactionServiceException()
20654 
          self.ex.read(iprot)
20655 
        else:
20656 
          iprot.skip(ftype)
20657 
      else:
20658 
        iprot.skip(ftype)
20659 
      iprot.readFieldEnd()
20660 
    iprot.readStructEnd()
20661 
 
20662 
  def write(self, oprot):
20663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20665 
      return
20666 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20667 
    if self.ex is not None:
20668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20669 
      self.ex.write(oprot)
20670 
      oprot.writeFieldEnd()
20671 
    oprot.writeFieldStop()
20672 
    oprot.writeStructEnd()
20673 
 
20674 
  def validate(self):
20675 
    return
20676 
 
20677 
 
20678 
  def __repr__(self):
20679 
    L = ['%s=%r' % (key, value)
20680 
      for key, value in self.__dict__.iteritems()]
20681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20682 
 
20683 
  def __eq__(self, other):
20684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20685 
 
20686 
  def __ne__(self, other):
20687 
    return not (self == other)
20688 
 
4258 rajveer 20689 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20690 
  """
20691 
  Attributes:
4258 rajveer 20692 
   - transactionId
4247 rajveer 20693 
  """
20694 
 
20695 
  thrift_spec = (
20696 
    None, # 0
4258 rajveer 20697 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20698 
  )
20699 
 
4258 rajveer 20700 
  def __init__(self, transactionId=None,):
20701 
    self.transactionId = transactionId
4247 rajveer 20702 
 
20703 
  def read(self, iprot):
20704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20706 
      return
20707 
    iprot.readStructBegin()
20708 
    while True:
20709 
      (fname, ftype, fid) = iprot.readFieldBegin()
20710 
      if ftype == TType.STOP:
20711 
        break
20712 
      if fid == 1:
20713 
        if ftype == TType.I64:
4258 rajveer 20714 
          self.transactionId = iprot.readI64();
4247 rajveer 20715 
        else:
20716 
          iprot.skip(ftype)
20717 
      else:
20718 
        iprot.skip(ftype)
20719 
      iprot.readFieldEnd()
20720 
    iprot.readStructEnd()
20721 
 
20722 
  def write(self, oprot):
20723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20725 
      return
4258 rajveer 20726 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20727 
    if self.transactionId is not None:
20728 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20729 
      oprot.writeI64(self.transactionId)
4247 rajveer 20730 
      oprot.writeFieldEnd()
20731 
    oprot.writeFieldStop()
20732 
    oprot.writeStructEnd()
20733 
 
20734 
  def validate(self):
20735 
    return
20736 
 
20737 
 
20738 
  def __repr__(self):
20739 
    L = ['%s=%r' % (key, value)
20740 
      for key, value in self.__dict__.iteritems()]
20741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20742 
 
20743 
  def __eq__(self, other):
20744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20745 
 
20746 
  def __ne__(self, other):
20747 
    return not (self == other)
20748 
 
4258 rajveer 20749 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20750 
  """
20751 
  Attributes:
20752 
   - ex
20753 
  """
20754 
 
20755 
  thrift_spec = (
20756 
    None, # 0
20757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20758 
  )
20759 
 
20760 
  def __init__(self, ex=None,):
20761 
    self.ex = ex
20762 
 
20763 
  def read(self, iprot):
20764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20766 
      return
20767 
    iprot.readStructBegin()
20768 
    while True:
20769 
      (fname, ftype, fid) = iprot.readFieldBegin()
20770 
      if ftype == TType.STOP:
20771 
        break
20772 
      if fid == 1:
20773 
        if ftype == TType.STRUCT:
20774 
          self.ex = TransactionServiceException()
20775 
          self.ex.read(iprot)
20776 
        else:
20777 
          iprot.skip(ftype)
20778 
      else:
20779 
        iprot.skip(ftype)
20780 
      iprot.readFieldEnd()
20781 
    iprot.readStructEnd()
20782 
 
20783 
  def write(self, oprot):
20784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20786 
      return
4258 rajveer 20787 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20788 
    if self.ex is not None:
20789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20790 
      self.ex.write(oprot)
20791 
      oprot.writeFieldEnd()
20792 
    oprot.writeFieldStop()
20793 
    oprot.writeStructEnd()
20794 
 
20795 
  def validate(self):
20796 
    return
20797 
 
20798 
 
20799 
  def __repr__(self):
20800 
    L = ['%s=%r' % (key, value)
20801 
      for key, value in self.__dict__.iteritems()]
20802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20803 
 
20804 
  def __eq__(self, other):
20805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20806 
 
20807 
  def __ne__(self, other):
20808 
    return not (self == other)
4259 anupam.sin 20809 
 
20810 
class refundTransaction_args:
20811 
  """
20812 
  Attributes:
20813 
   - transactionId
20814 
   - refundedBy
20815 
   - reason
20816 
  """
20817 
 
20818 
  thrift_spec = (
20819 
    None, # 0
20820 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20821 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20822 
    (3, TType.STRING, 'reason', None, None, ), # 3
20823 
  )
20824 
 
20825 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20826 
    self.transactionId = transactionId
20827 
    self.refundedBy = refundedBy
20828 
    self.reason = reason
20829 
 
20830 
  def read(self, iprot):
20831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20833 
      return
20834 
    iprot.readStructBegin()
20835 
    while True:
20836 
      (fname, ftype, fid) = iprot.readFieldBegin()
20837 
      if ftype == TType.STOP:
20838 
        break
20839 
      if fid == 1:
20840 
        if ftype == TType.I64:
20841 
          self.transactionId = iprot.readI64();
20842 
        else:
20843 
          iprot.skip(ftype)
20844 
      elif fid == 2:
20845 
        if ftype == TType.STRING:
20846 
          self.refundedBy = iprot.readString();
20847 
        else:
20848 
          iprot.skip(ftype)
20849 
      elif fid == 3:
20850 
        if ftype == TType.STRING:
20851 
          self.reason = iprot.readString();
20852 
        else:
20853 
          iprot.skip(ftype)
20854 
      else:
20855 
        iprot.skip(ftype)
20856 
      iprot.readFieldEnd()
20857 
    iprot.readStructEnd()
20858 
 
20859 
  def write(self, oprot):
20860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20862 
      return
20863 
    oprot.writeStructBegin('refundTransaction_args')
20864 
    if self.transactionId is not None:
20865 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20866 
      oprot.writeI64(self.transactionId)
20867 
      oprot.writeFieldEnd()
20868 
    if self.refundedBy is not None:
20869 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20870 
      oprot.writeString(self.refundedBy)
20871 
      oprot.writeFieldEnd()
20872 
    if self.reason is not None:
20873 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20874 
      oprot.writeString(self.reason)
20875 
      oprot.writeFieldEnd()
20876 
    oprot.writeFieldStop()
20877 
    oprot.writeStructEnd()
20878 
 
20879 
  def validate(self):
20880 
    return
20881 
 
20882 
 
20883 
  def __repr__(self):
20884 
    L = ['%s=%r' % (key, value)
20885 
      for key, value in self.__dict__.iteritems()]
20886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20887 
 
20888 
  def __eq__(self, other):
20889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20890 
 
20891 
  def __ne__(self, other):
20892 
    return not (self == other)
20893 
 
20894 
class refundTransaction_result:
20895 
  """
20896 
  Attributes:
20897 
   - ex
20898 
  """
20899 
 
20900 
  thrift_spec = (
20901 
    None, # 0
20902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20903 
  )
20904 
 
20905 
  def __init__(self, ex=None,):
20906 
    self.ex = ex
20907 
 
20908 
  def read(self, iprot):
20909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20911 
      return
20912 
    iprot.readStructBegin()
20913 
    while True:
20914 
      (fname, ftype, fid) = iprot.readFieldBegin()
20915 
      if ftype == TType.STOP:
20916 
        break
20917 
      if fid == 1:
20918 
        if ftype == TType.STRUCT:
20919 
          self.ex = TransactionServiceException()
20920 
          self.ex.read(iprot)
20921 
        else:
20922 
          iprot.skip(ftype)
20923 
      else:
20924 
        iprot.skip(ftype)
20925 
      iprot.readFieldEnd()
20926 
    iprot.readStructEnd()
20927 
 
20928 
  def write(self, oprot):
20929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20931 
      return
20932 
    oprot.writeStructBegin('refundTransaction_result')
20933 
    if self.ex is not None:
20934 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20935 
      self.ex.write(oprot)
20936 
      oprot.writeFieldEnd()
20937 
    oprot.writeFieldStop()
20938 
    oprot.writeStructEnd()
20939 
 
20940 
  def validate(self):
20941 
    return
20942 
 
20943 
 
20944 
  def __repr__(self):
20945 
    L = ['%s=%r' % (key, value)
20946 
      for key, value in self.__dict__.iteritems()]
20947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20948 
 
20949 
  def __eq__(self, other):
20950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20951 
 
20952 
  def __ne__(self, other):
20953 
    return not (self == other)
4285 rajveer 20954 
 
4324 mandeep.dh 20955 
class updateShipmentAddress_args:
20956 
  """
20957 
  Attributes:
20958 
   - orderId
20959 
   - addressId
20960 
  """
20961 
 
20962 
  thrift_spec = (
20963 
    None, # 0
20964 
    (1, TType.I64, 'orderId', None, None, ), # 1
20965 
    (2, TType.I64, 'addressId', None, None, ), # 2
20966 
  )
20967 
 
20968 
  def __init__(self, orderId=None, addressId=None,):
20969 
    self.orderId = orderId
20970 
    self.addressId = addressId
20971 
 
20972 
  def read(self, iprot):
20973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20975 
      return
20976 
    iprot.readStructBegin()
20977 
    while True:
20978 
      (fname, ftype, fid) = iprot.readFieldBegin()
20979 
      if ftype == TType.STOP:
20980 
        break
20981 
      if fid == 1:
20982 
        if ftype == TType.I64:
20983 
          self.orderId = iprot.readI64();
20984 
        else:
20985 
          iprot.skip(ftype)
20986 
      elif fid == 2:
20987 
        if ftype == TType.I64:
20988 
          self.addressId = iprot.readI64();
20989 
        else:
20990 
          iprot.skip(ftype)
20991 
      else:
20992 
        iprot.skip(ftype)
20993 
      iprot.readFieldEnd()
20994 
    iprot.readStructEnd()
20995 
 
20996 
  def write(self, oprot):
20997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20999 
      return
21000 
    oprot.writeStructBegin('updateShipmentAddress_args')
21001 
    if self.orderId is not None:
21002 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21003 
      oprot.writeI64(self.orderId)
21004 
      oprot.writeFieldEnd()
21005 
    if self.addressId is not None:
21006 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21007 
      oprot.writeI64(self.addressId)
21008 
      oprot.writeFieldEnd()
21009 
    oprot.writeFieldStop()
21010 
    oprot.writeStructEnd()
21011 
 
21012 
  def validate(self):
21013 
    return
21014 
 
21015 
 
21016 
  def __repr__(self):
21017 
    L = ['%s=%r' % (key, value)
21018 
      for key, value in self.__dict__.iteritems()]
21019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21020 
 
21021 
  def __eq__(self, other):
21022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21023 
 
21024 
  def __ne__(self, other):
21025 
    return not (self == other)
21026 
 
21027 
class updateShipmentAddress_result:
21028 
  """
21029 
  Attributes:
21030 
   - ex
21031 
  """
21032 
 
21033 
  thrift_spec = (
21034 
    None, # 0
21035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21036 
  )
21037 
 
21038 
  def __init__(self, ex=None,):
21039 
    self.ex = ex
21040 
 
21041 
  def read(self, iprot):
21042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21044 
      return
21045 
    iprot.readStructBegin()
21046 
    while True:
21047 
      (fname, ftype, fid) = iprot.readFieldBegin()
21048 
      if ftype == TType.STOP:
21049 
        break
21050 
      if fid == 1:
21051 
        if ftype == TType.STRUCT:
21052 
          self.ex = TransactionServiceException()
21053 
          self.ex.read(iprot)
21054 
        else:
21055 
          iprot.skip(ftype)
21056 
      else:
21057 
        iprot.skip(ftype)
21058 
      iprot.readFieldEnd()
21059 
    iprot.readStructEnd()
21060 
 
21061 
  def write(self, oprot):
21062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21064 
      return
21065 
    oprot.writeStructBegin('updateShipmentAddress_result')
21066 
    if self.ex is not None:
21067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21068 
      self.ex.write(oprot)
21069 
      oprot.writeFieldEnd()
21070 
    oprot.writeFieldStop()
21071 
    oprot.writeStructEnd()
21072 
 
21073 
  def validate(self):
21074 
    return
21075 
 
21076 
 
21077 
  def __repr__(self):
21078 
    L = ['%s=%r' % (key, value)
21079 
      for key, value in self.__dict__.iteritems()]
21080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21081 
 
21082 
  def __eq__(self, other):
21083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21084 
 
21085 
  def __ne__(self, other):
21086 
    return not (self == other)
21087 
 
4285 rajveer 21088 
class acceptOrdersForItemId_args:
21089 
  """
21090 
  Attributes:
21091 
   - itemId
21092 
   - inventory
21093 
  """
21094 
 
21095 
  thrift_spec = (
21096 
    None, # 0
21097 
    (1, TType.I64, 'itemId', None, None, ), # 1
21098 
    (2, TType.I64, 'inventory', None, None, ), # 2
21099 
  )
21100 
 
21101 
  def __init__(self, itemId=None, inventory=None,):
21102 
    self.itemId = itemId
21103 
    self.inventory = inventory
21104 
 
21105 
  def read(self, iprot):
21106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21108 
      return
21109 
    iprot.readStructBegin()
21110 
    while True:
21111 
      (fname, ftype, fid) = iprot.readFieldBegin()
21112 
      if ftype == TType.STOP:
21113 
        break
21114 
      if fid == 1:
21115 
        if ftype == TType.I64:
21116 
          self.itemId = iprot.readI64();
21117 
        else:
21118 
          iprot.skip(ftype)
21119 
      elif fid == 2:
21120 
        if ftype == TType.I64:
21121 
          self.inventory = iprot.readI64();
21122 
        else:
21123 
          iprot.skip(ftype)
21124 
      else:
21125 
        iprot.skip(ftype)
21126 
      iprot.readFieldEnd()
21127 
    iprot.readStructEnd()
21128 
 
21129 
  def write(self, oprot):
21130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21132 
      return
21133 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21134 
    if self.itemId is not None:
21135 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21136 
      oprot.writeI64(self.itemId)
21137 
      oprot.writeFieldEnd()
21138 
    if self.inventory is not None:
21139 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21140 
      oprot.writeI64(self.inventory)
21141 
      oprot.writeFieldEnd()
21142 
    oprot.writeFieldStop()
21143 
    oprot.writeStructEnd()
21144 
 
21145 
  def validate(self):
21146 
    return
21147 
 
21148 
 
21149 
  def __repr__(self):
21150 
    L = ['%s=%r' % (key, value)
21151 
      for key, value in self.__dict__.iteritems()]
21152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21153 
 
21154 
  def __eq__(self, other):
21155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21156 
 
21157 
  def __ne__(self, other):
21158 
    return not (self == other)
21159 
 
21160 
class acceptOrdersForItemId_result:
21161 
  """
21162 
  Attributes:
21163 
   - success
21164 
   - ex
21165 
  """
21166 
 
21167 
  thrift_spec = (
21168 
    (0, TType.BOOL, 'success', None, None, ), # 0
21169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21170 
  )
21171 
 
21172 
  def __init__(self, success=None, ex=None,):
21173 
    self.success = success
21174 
    self.ex = ex
21175 
 
21176 
  def read(self, iprot):
21177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21179 
      return
21180 
    iprot.readStructBegin()
21181 
    while True:
21182 
      (fname, ftype, fid) = iprot.readFieldBegin()
21183 
      if ftype == TType.STOP:
21184 
        break
21185 
      if fid == 0:
21186 
        if ftype == TType.BOOL:
21187 
          self.success = iprot.readBool();
21188 
        else:
21189 
          iprot.skip(ftype)
21190 
      elif fid == 1:
21191 
        if ftype == TType.STRUCT:
21192 
          self.ex = TransactionServiceException()
21193 
          self.ex.read(iprot)
21194 
        else:
21195 
          iprot.skip(ftype)
21196 
      else:
21197 
        iprot.skip(ftype)
21198 
      iprot.readFieldEnd()
21199 
    iprot.readStructEnd()
21200 
 
21201 
  def write(self, oprot):
21202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21204 
      return
21205 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21206 
    if self.success is not None:
21207 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21208 
      oprot.writeBool(self.success)
21209 
      oprot.writeFieldEnd()
21210 
    if self.ex is not None:
21211 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21212 
      self.ex.write(oprot)
21213 
      oprot.writeFieldEnd()
21214 
    oprot.writeFieldStop()
21215 
    oprot.writeStructEnd()
21216 
 
21217 
  def validate(self):
21218 
    return
21219 
 
21220 
 
21221 
  def __repr__(self):
21222 
    L = ['%s=%r' % (key, value)
21223 
      for key, value in self.__dict__.iteritems()]
21224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21225 
 
21226 
  def __eq__(self, other):
21227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21228 
 
21229 
  def __ne__(self, other):
21230 
    return not (self == other)
4303 rajveer 21231 
 
21232 
class markOrdersAsPORaised_args:
21233 
  """
21234 
  Attributes:
21235 
   - vendorId
21236 
   - itemId
21237 
   - quantity
21238 
   - estimate
4369 rajveer 21239 
   - isReminder
4303 rajveer 21240 
  """
21241 
 
21242 
  thrift_spec = (
21243 
    None, # 0
21244 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21245 
    (2, TType.I64, 'itemId', None, None, ), # 2
21246 
    (3, TType.I64, 'quantity', None, None, ), # 3
21247 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21248 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21249 
  )
21250 
 
4369 rajveer 21251 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21252 
    self.vendorId = vendorId
21253 
    self.itemId = itemId
21254 
    self.quantity = quantity
21255 
    self.estimate = estimate
4369 rajveer 21256 
    self.isReminder = isReminder
4303 rajveer 21257 
 
21258 
  def read(self, iprot):
21259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21261 
      return
21262 
    iprot.readStructBegin()
21263 
    while True:
21264 
      (fname, ftype, fid) = iprot.readFieldBegin()
21265 
      if ftype == TType.STOP:
21266 
        break
21267 
      if fid == 1:
21268 
        if ftype == TType.I64:
21269 
          self.vendorId = iprot.readI64();
21270 
        else:
21271 
          iprot.skip(ftype)
21272 
      elif fid == 2:
21273 
        if ftype == TType.I64:
21274 
          self.itemId = iprot.readI64();
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      elif fid == 3:
21278 
        if ftype == TType.I64:
21279 
          self.quantity = iprot.readI64();
21280 
        else:
21281 
          iprot.skip(ftype)
21282 
      elif fid == 4:
21283 
        if ftype == TType.I64:
21284 
          self.estimate = iprot.readI64();
21285 
        else:
21286 
          iprot.skip(ftype)
4369 rajveer 21287 
      elif fid == 5:
21288 
        if ftype == TType.BOOL:
21289 
          self.isReminder = iprot.readBool();
21290 
        else:
21291 
          iprot.skip(ftype)
4303 rajveer 21292 
      else:
21293 
        iprot.skip(ftype)
21294 
      iprot.readFieldEnd()
21295 
    iprot.readStructEnd()
21296 
 
21297 
  def write(self, oprot):
21298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21300 
      return
21301 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21302 
    if self.vendorId is not None:
21303 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21304 
      oprot.writeI64(self.vendorId)
21305 
      oprot.writeFieldEnd()
21306 
    if self.itemId is not None:
21307 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21308 
      oprot.writeI64(self.itemId)
21309 
      oprot.writeFieldEnd()
21310 
    if self.quantity is not None:
21311 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21312 
      oprot.writeI64(self.quantity)
21313 
      oprot.writeFieldEnd()
21314 
    if self.estimate is not None:
21315 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21316 
      oprot.writeI64(self.estimate)
21317 
      oprot.writeFieldEnd()
4369 rajveer 21318 
    if self.isReminder is not None:
21319 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21320 
      oprot.writeBool(self.isReminder)
21321 
      oprot.writeFieldEnd()
4303 rajveer 21322 
    oprot.writeFieldStop()
21323 
    oprot.writeStructEnd()
21324 
 
21325 
  def validate(self):
21326 
    return
21327 
 
21328 
 
21329 
  def __repr__(self):
21330 
    L = ['%s=%r' % (key, value)
21331 
      for key, value in self.__dict__.iteritems()]
21332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21333 
 
21334 
  def __eq__(self, other):
21335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21336 
 
21337 
  def __ne__(self, other):
21338 
    return not (self == other)
21339 
 
21340 
class markOrdersAsPORaised_result:
21341 
  """
21342 
  Attributes:
21343 
   - ex
21344 
  """
21345 
 
21346 
  thrift_spec = (
21347 
    None, # 0
21348 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21349 
  )
21350 
 
21351 
  def __init__(self, ex=None,):
21352 
    self.ex = ex
21353 
 
21354 
  def read(self, iprot):
21355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21357 
      return
21358 
    iprot.readStructBegin()
21359 
    while True:
21360 
      (fname, ftype, fid) = iprot.readFieldBegin()
21361 
      if ftype == TType.STOP:
21362 
        break
21363 
      if fid == 1:
21364 
        if ftype == TType.STRUCT:
21365 
          self.ex = TransactionServiceException()
21366 
          self.ex.read(iprot)
21367 
        else:
21368 
          iprot.skip(ftype)
21369 
      else:
21370 
        iprot.skip(ftype)
21371 
      iprot.readFieldEnd()
21372 
    iprot.readStructEnd()
21373 
 
21374 
  def write(self, oprot):
21375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21377 
      return
21378 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21379 
    if self.ex is not None:
21380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21381 
      self.ex.write(oprot)
21382 
      oprot.writeFieldEnd()
21383 
    oprot.writeFieldStop()
21384 
    oprot.writeStructEnd()
21385 
 
21386 
  def validate(self):
21387 
    return
21388 
 
21389 
 
21390 
  def __repr__(self):
21391 
    L = ['%s=%r' % (key, value)
21392 
      for key, value in self.__dict__.iteritems()]
21393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21394 
 
21395 
  def __eq__(self, other):
21396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21397 
 
21398 
  def __ne__(self, other):
21399 
    return not (self == other)
21400 
 
21401 
class markOrdersAsReversalInitiated_args:
21402 
  """
21403 
  Attributes:
21404 
   - vendorId
21405 
   - itemId
21406 
   - quantity
21407 
   - estimate
4369 rajveer 21408 
   - isReminder
4303 rajveer 21409 
  """
21410 
 
21411 
  thrift_spec = (
21412 
    None, # 0
21413 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21414 
    (2, TType.I64, 'itemId', None, None, ), # 2
21415 
    (3, TType.I64, 'quantity', None, None, ), # 3
21416 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21417 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21418 
  )
21419 
 
4369 rajveer 21420 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21421 
    self.vendorId = vendorId
21422 
    self.itemId = itemId
21423 
    self.quantity = quantity
21424 
    self.estimate = estimate
4369 rajveer 21425 
    self.isReminder = isReminder
4303 rajveer 21426 
 
21427 
  def read(self, iprot):
21428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21430 
      return
21431 
    iprot.readStructBegin()
21432 
    while True:
21433 
      (fname, ftype, fid) = iprot.readFieldBegin()
21434 
      if ftype == TType.STOP:
21435 
        break
21436 
      if fid == 1:
21437 
        if ftype == TType.I64:
21438 
          self.vendorId = iprot.readI64();
21439 
        else:
21440 
          iprot.skip(ftype)
21441 
      elif fid == 2:
21442 
        if ftype == TType.I64:
21443 
          self.itemId = iprot.readI64();
21444 
        else:
21445 
          iprot.skip(ftype)
21446 
      elif fid == 3:
21447 
        if ftype == TType.I64:
21448 
          self.quantity = iprot.readI64();
21449 
        else:
21450 
          iprot.skip(ftype)
21451 
      elif fid == 4:
21452 
        if ftype == TType.I64:
21453 
          self.estimate = iprot.readI64();
21454 
        else:
21455 
          iprot.skip(ftype)
4369 rajveer 21456 
      elif fid == 5:
21457 
        if ftype == TType.BOOL:
21458 
          self.isReminder = iprot.readBool();
21459 
        else:
21460 
          iprot.skip(ftype)
4303 rajveer 21461 
      else:
21462 
        iprot.skip(ftype)
21463 
      iprot.readFieldEnd()
21464 
    iprot.readStructEnd()
21465 
 
21466 
  def write(self, oprot):
21467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21469 
      return
21470 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21471 
    if self.vendorId is not None:
21472 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21473 
      oprot.writeI64(self.vendorId)
21474 
      oprot.writeFieldEnd()
21475 
    if self.itemId is not None:
21476 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21477 
      oprot.writeI64(self.itemId)
21478 
      oprot.writeFieldEnd()
21479 
    if self.quantity is not None:
21480 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21481 
      oprot.writeI64(self.quantity)
21482 
      oprot.writeFieldEnd()
21483 
    if self.estimate is not None:
21484 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21485 
      oprot.writeI64(self.estimate)
21486 
      oprot.writeFieldEnd()
4369 rajveer 21487 
    if self.isReminder is not None:
21488 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21489 
      oprot.writeBool(self.isReminder)
21490 
      oprot.writeFieldEnd()
4303 rajveer 21491 
    oprot.writeFieldStop()
21492 
    oprot.writeStructEnd()
21493 
 
21494 
  def validate(self):
21495 
    return
21496 
 
21497 
 
21498 
  def __repr__(self):
21499 
    L = ['%s=%r' % (key, value)
21500 
      for key, value in self.__dict__.iteritems()]
21501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21502 
 
21503 
  def __eq__(self, other):
21504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21505 
 
21506 
  def __ne__(self, other):
21507 
    return not (self == other)
21508 
 
21509 
class markOrdersAsReversalInitiated_result:
21510 
  """
21511 
  Attributes:
21512 
   - ex
21513 
  """
21514 
 
21515 
  thrift_spec = (
21516 
    None, # 0
21517 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21518 
  )
21519 
 
21520 
  def __init__(self, ex=None,):
21521 
    self.ex = ex
21522 
 
21523 
  def read(self, iprot):
21524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21526 
      return
21527 
    iprot.readStructBegin()
21528 
    while True:
21529 
      (fname, ftype, fid) = iprot.readFieldBegin()
21530 
      if ftype == TType.STOP:
21531 
        break
21532 
      if fid == 1:
21533 
        if ftype == TType.STRUCT:
21534 
          self.ex = TransactionServiceException()
21535 
          self.ex.read(iprot)
21536 
        else:
21537 
          iprot.skip(ftype)
21538 
      else:
21539 
        iprot.skip(ftype)
21540 
      iprot.readFieldEnd()
21541 
    iprot.readStructEnd()
21542 
 
21543 
  def write(self, oprot):
21544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21546 
      return
21547 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21548 
    if self.ex is not None:
21549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21550 
      self.ex.write(oprot)
21551 
      oprot.writeFieldEnd()
21552 
    oprot.writeFieldStop()
21553 
    oprot.writeStructEnd()
21554 
 
21555 
  def validate(self):
21556 
    return
21557 
 
21558 
 
21559 
  def __repr__(self):
21560 
    L = ['%s=%r' % (key, value)
21561 
      for key, value in self.__dict__.iteritems()]
21562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21563 
 
21564 
  def __eq__(self, other):
21565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21566 
 
21567 
  def __ne__(self, other):
21568 
    return not (self == other)
21569 
 
21570 
class markOrdersAsNotAvailabke_args:
21571 
  """
21572 
  Attributes:
21573 
   - vendorId
21574 
   - itemId
21575 
   - quantity
21576 
   - estimate
4369 rajveer 21577 
   - isReminder
4303 rajveer 21578 
  """
21579 
 
21580 
  thrift_spec = (
21581 
    None, # 0
21582 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21583 
    (2, TType.I64, 'itemId', None, None, ), # 2
21584 
    (3, TType.I64, 'quantity', None, None, ), # 3
21585 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21586 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21587 
  )
21588 
 
4369 rajveer 21589 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21590 
    self.vendorId = vendorId
21591 
    self.itemId = itemId
21592 
    self.quantity = quantity
21593 
    self.estimate = estimate
4369 rajveer 21594 
    self.isReminder = isReminder
4303 rajveer 21595 
 
21596 
  def read(self, iprot):
21597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21599 
      return
21600 
    iprot.readStructBegin()
21601 
    while True:
21602 
      (fname, ftype, fid) = iprot.readFieldBegin()
21603 
      if ftype == TType.STOP:
21604 
        break
21605 
      if fid == 1:
21606 
        if ftype == TType.I64:
21607 
          self.vendorId = iprot.readI64();
21608 
        else:
21609 
          iprot.skip(ftype)
21610 
      elif fid == 2:
21611 
        if ftype == TType.I64:
21612 
          self.itemId = iprot.readI64();
21613 
        else:
21614 
          iprot.skip(ftype)
21615 
      elif fid == 3:
21616 
        if ftype == TType.I64:
21617 
          self.quantity = iprot.readI64();
21618 
        else:
21619 
          iprot.skip(ftype)
21620 
      elif fid == 4:
21621 
        if ftype == TType.I64:
21622 
          self.estimate = iprot.readI64();
21623 
        else:
21624 
          iprot.skip(ftype)
4369 rajveer 21625 
      elif fid == 5:
21626 
        if ftype == TType.BOOL:
21627 
          self.isReminder = iprot.readBool();
21628 
        else:
21629 
          iprot.skip(ftype)
4303 rajveer 21630 
      else:
21631 
        iprot.skip(ftype)
21632 
      iprot.readFieldEnd()
21633 
    iprot.readStructEnd()
21634 
 
21635 
  def write(self, oprot):
21636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21638 
      return
21639 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21640 
    if self.vendorId is not None:
21641 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21642 
      oprot.writeI64(self.vendorId)
21643 
      oprot.writeFieldEnd()
21644 
    if self.itemId is not None:
21645 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21646 
      oprot.writeI64(self.itemId)
21647 
      oprot.writeFieldEnd()
21648 
    if self.quantity is not None:
21649 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21650 
      oprot.writeI64(self.quantity)
21651 
      oprot.writeFieldEnd()
21652 
    if self.estimate is not None:
21653 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21654 
      oprot.writeI64(self.estimate)
21655 
      oprot.writeFieldEnd()
4369 rajveer 21656 
    if self.isReminder is not None:
21657 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21658 
      oprot.writeBool(self.isReminder)
21659 
      oprot.writeFieldEnd()
4303 rajveer 21660 
    oprot.writeFieldStop()
21661 
    oprot.writeStructEnd()
21662 
 
21663 
  def validate(self):
21664 
    return
21665 
 
21666 
 
21667 
  def __repr__(self):
21668 
    L = ['%s=%r' % (key, value)
21669 
      for key, value in self.__dict__.iteritems()]
21670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21671 
 
21672 
  def __eq__(self, other):
21673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21674 
 
21675 
  def __ne__(self, other):
21676 
    return not (self == other)
21677 
 
21678 
class markOrdersAsNotAvailabke_result:
21679 
  """
21680 
  Attributes:
21681 
   - ex
21682 
  """
21683 
 
21684 
  thrift_spec = (
21685 
    None, # 0
21686 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21687 
  )
21688 
 
21689 
  def __init__(self, ex=None,):
21690 
    self.ex = ex
21691 
 
21692 
  def read(self, iprot):
21693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21695 
      return
21696 
    iprot.readStructBegin()
21697 
    while True:
21698 
      (fname, ftype, fid) = iprot.readFieldBegin()
21699 
      if ftype == TType.STOP:
21700 
        break
21701 
      if fid == 1:
21702 
        if ftype == TType.STRUCT:
21703 
          self.ex = TransactionServiceException()
21704 
          self.ex.read(iprot)
21705 
        else:
21706 
          iprot.skip(ftype)
21707 
      else:
21708 
        iprot.skip(ftype)
21709 
      iprot.readFieldEnd()
21710 
    iprot.readStructEnd()
21711 
 
21712 
  def write(self, oprot):
21713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21715 
      return
21716 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21717 
    if self.ex is not None:
21718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21719 
      self.ex.write(oprot)
21720 
      oprot.writeFieldEnd()
21721 
    oprot.writeFieldStop()
21722 
    oprot.writeStructEnd()
21723 
 
21724 
  def validate(self):
21725 
    return
21726 
 
21727 
 
21728 
  def __repr__(self):
21729 
    L = ['%s=%r' % (key, value)
21730 
      for key, value in self.__dict__.iteritems()]
21731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21732 
 
21733 
  def __eq__(self, other):
21734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21735 
 
21736 
  def __ne__(self, other):
21737 
    return not (self == other)
4369 rajveer 21738 
 
21739 
class markOrdersAsTimeout_args:
21740 
  """
21741 
  Attributes:
21742 
   - vendorId
21743 
  """
21744 
 
21745 
  thrift_spec = (
21746 
    None, # 0
21747 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21748 
  )
21749 
 
21750 
  def __init__(self, vendorId=None,):
21751 
    self.vendorId = vendorId
21752 
 
21753 
  def read(self, iprot):
21754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21756 
      return
21757 
    iprot.readStructBegin()
21758 
    while True:
21759 
      (fname, ftype, fid) = iprot.readFieldBegin()
21760 
      if ftype == TType.STOP:
21761 
        break
21762 
      if fid == 1:
21763 
        if ftype == TType.I64:
21764 
          self.vendorId = iprot.readI64();
21765 
        else:
21766 
          iprot.skip(ftype)
21767 
      else:
21768 
        iprot.skip(ftype)
21769 
      iprot.readFieldEnd()
21770 
    iprot.readStructEnd()
21771 
 
21772 
  def write(self, oprot):
21773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21775 
      return
21776 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21777 
    if self.vendorId is not None:
21778 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21779 
      oprot.writeI64(self.vendorId)
21780 
      oprot.writeFieldEnd()
21781 
    oprot.writeFieldStop()
21782 
    oprot.writeStructEnd()
21783 
 
21784 
  def validate(self):
21785 
    return
21786 
 
21787 
 
21788 
  def __repr__(self):
21789 
    L = ['%s=%r' % (key, value)
21790 
      for key, value in self.__dict__.iteritems()]
21791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21792 
 
21793 
  def __eq__(self, other):
21794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21795 
 
21796 
  def __ne__(self, other):
21797 
    return not (self == other)
21798 
 
21799 
class markOrdersAsTimeout_result:
21800 
  """
21801 
  Attributes:
21802 
   - success
21803 
   - ex
21804 
  """
21805 
 
21806 
  thrift_spec = (
21807 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21809 
  )
21810 
 
21811 
  def __init__(self, success=None, ex=None,):
21812 
    self.success = success
21813 
    self.ex = ex
21814 
 
21815 
  def read(self, iprot):
21816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21818 
      return
21819 
    iprot.readStructBegin()
21820 
    while True:
21821 
      (fname, ftype, fid) = iprot.readFieldBegin()
21822 
      if ftype == TType.STOP:
21823 
        break
21824 
      if fid == 0:
21825 
        if ftype == TType.MAP:
21826 
          self.success = {}
6188 rajveer 21827 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21828 
          for _i505 in xrange(_size501):
21829 
            _key506 = iprot.readI32();
21830 
            _val507 = TimeoutSummary()
21831 
            _val507.read(iprot)
21832 
            self.success[_key506] = _val507
4369 rajveer 21833 
          iprot.readMapEnd()
21834 
        else:
21835 
          iprot.skip(ftype)
21836 
      elif fid == 1:
21837 
        if ftype == TType.STRUCT:
21838 
          self.ex = TransactionServiceException()
21839 
          self.ex.read(iprot)
21840 
        else:
21841 
          iprot.skip(ftype)
21842 
      else:
21843 
        iprot.skip(ftype)
21844 
      iprot.readFieldEnd()
21845 
    iprot.readStructEnd()
21846 
 
21847 
  def write(self, oprot):
21848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21850 
      return
21851 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21852 
    if self.success is not None:
21853 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21854 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21855 
      for kiter508,viter509 in self.success.items():
21856 
        oprot.writeI32(kiter508)
21857 
        viter509.write(oprot)
4369 rajveer 21858 
      oprot.writeMapEnd()
21859 
      oprot.writeFieldEnd()
21860 
    if self.ex is not None:
21861 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21862 
      self.ex.write(oprot)
21863 
      oprot.writeFieldEnd()
21864 
    oprot.writeFieldStop()
21865 
    oprot.writeStructEnd()
21866 
 
21867 
  def validate(self):
21868 
    return
21869 
 
21870 
 
21871 
  def __repr__(self):
21872 
    L = ['%s=%r' % (key, value)
21873 
      for key, value in self.__dict__.iteritems()]
21874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21875 
 
21876 
  def __eq__(self, other):
21877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21878 
 
21879 
  def __ne__(self, other):
21880 
    return not (self == other)
4386 anupam.sin 21881 
 
4662 rajveer 21882 
class markOrderAsLostInTransit_args:
21883 
  """
21884 
  Attributes:
21885 
   - orderId
21886 
  """
21887 
 
21888 
  thrift_spec = (
21889 
    None, # 0
21890 
    (1, TType.I64, 'orderId', None, None, ), # 1
21891 
  )
21892 
 
21893 
  def __init__(self, orderId=None,):
21894 
    self.orderId = orderId
21895 
 
21896 
  def read(self, iprot):
21897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21899 
      return
21900 
    iprot.readStructBegin()
21901 
    while True:
21902 
      (fname, ftype, fid) = iprot.readFieldBegin()
21903 
      if ftype == TType.STOP:
21904 
        break
21905 
      if fid == 1:
21906 
        if ftype == TType.I64:
21907 
          self.orderId = iprot.readI64();
21908 
        else:
21909 
          iprot.skip(ftype)
21910 
      else:
21911 
        iprot.skip(ftype)
21912 
      iprot.readFieldEnd()
21913 
    iprot.readStructEnd()
21914 
 
21915 
  def write(self, oprot):
21916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21918 
      return
21919 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21920 
    if self.orderId is not None:
21921 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21922 
      oprot.writeI64(self.orderId)
21923 
      oprot.writeFieldEnd()
21924 
    oprot.writeFieldStop()
21925 
    oprot.writeStructEnd()
21926 
 
21927 
  def validate(self):
21928 
    return
21929 
 
21930 
 
21931 
  def __repr__(self):
21932 
    L = ['%s=%r' % (key, value)
21933 
      for key, value in self.__dict__.iteritems()]
21934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21935 
 
21936 
  def __eq__(self, other):
21937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21938 
 
21939 
  def __ne__(self, other):
21940 
    return not (self == other)
21941 
 
21942 
class markOrderAsLostInTransit_result:
21943 
  """
21944 
  Attributes:
21945 
   - success
21946 
   - ex
21947 
  """
21948 
 
21949 
  thrift_spec = (
21950 
    (0, TType.BOOL, 'success', None, None, ), # 0
21951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21952 
  )
21953 
 
21954 
  def __init__(self, success=None, ex=None,):
21955 
    self.success = success
21956 
    self.ex = ex
21957 
 
21958 
  def read(self, iprot):
21959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21961 
      return
21962 
    iprot.readStructBegin()
21963 
    while True:
21964 
      (fname, ftype, fid) = iprot.readFieldBegin()
21965 
      if ftype == TType.STOP:
21966 
        break
21967 
      if fid == 0:
21968 
        if ftype == TType.BOOL:
21969 
          self.success = iprot.readBool();
21970 
        else:
21971 
          iprot.skip(ftype)
21972 
      elif fid == 1:
21973 
        if ftype == TType.STRUCT:
21974 
          self.ex = TransactionServiceException()
21975 
          self.ex.read(iprot)
21976 
        else:
21977 
          iprot.skip(ftype)
21978 
      else:
21979 
        iprot.skip(ftype)
21980 
      iprot.readFieldEnd()
21981 
    iprot.readStructEnd()
21982 
 
21983 
  def write(self, oprot):
21984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21986 
      return
21987 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21988 
    if self.success is not None:
21989 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21990 
      oprot.writeBool(self.success)
21991 
      oprot.writeFieldEnd()
21992 
    if self.ex is not None:
21993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21994 
      self.ex.write(oprot)
21995 
      oprot.writeFieldEnd()
21996 
    oprot.writeFieldStop()
21997 
    oprot.writeStructEnd()
21998 
 
21999 
  def validate(self):
22000 
    return
22001 
 
22002 
 
22003 
  def __repr__(self):
22004 
    L = ['%s=%r' % (key, value)
22005 
      for key, value in self.__dict__.iteritems()]
22006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22007 
 
22008 
  def __eq__(self, other):
22009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22010 
 
22011 
  def __ne__(self, other):
22012 
    return not (self == other)
22013 
 
4386 anupam.sin 22014 
class getOrderForAwb_args:
22015 
  """
22016 
  Attributes:
22017 
   - awb
22018 
  """
22019 
 
22020 
  thrift_spec = (
22021 
    None, # 0
22022 
    (1, TType.STRING, 'awb', None, None, ), # 1
22023 
  )
22024 
 
22025 
  def __init__(self, awb=None,):
22026 
    self.awb = awb
22027 
 
22028 
  def read(self, iprot):
22029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22031 
      return
22032 
    iprot.readStructBegin()
22033 
    while True:
22034 
      (fname, ftype, fid) = iprot.readFieldBegin()
22035 
      if ftype == TType.STOP:
22036 
        break
22037 
      if fid == 1:
22038 
        if ftype == TType.STRING:
22039 
          self.awb = iprot.readString();
22040 
        else:
22041 
          iprot.skip(ftype)
22042 
      else:
22043 
        iprot.skip(ftype)
22044 
      iprot.readFieldEnd()
22045 
    iprot.readStructEnd()
22046 
 
22047 
  def write(self, oprot):
22048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22050 
      return
22051 
    oprot.writeStructBegin('getOrderForAwb_args')
22052 
    if self.awb is not None:
22053 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22054 
      oprot.writeString(self.awb)
22055 
      oprot.writeFieldEnd()
22056 
    oprot.writeFieldStop()
22057 
    oprot.writeStructEnd()
22058 
 
22059 
  def validate(self):
22060 
    return
22061 
 
22062 
 
22063 
  def __repr__(self):
22064 
    L = ['%s=%r' % (key, value)
22065 
      for key, value in self.__dict__.iteritems()]
22066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22067 
 
22068 
  def __eq__(self, other):
22069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22070 
 
22071 
  def __ne__(self, other):
22072 
    return not (self == other)
22073 
 
22074 
class getOrderForAwb_result:
22075 
  """
22076 
  Attributes:
22077 
   - success
22078 
   - ex
22079 
  """
22080 
 
22081 
  thrift_spec = (
22082 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22083 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22084 
  )
22085 
 
22086 
  def __init__(self, success=None, ex=None,):
22087 
    self.success = success
22088 
    self.ex = ex
22089 
 
22090 
  def read(self, iprot):
22091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22093 
      return
22094 
    iprot.readStructBegin()
22095 
    while True:
22096 
      (fname, ftype, fid) = iprot.readFieldBegin()
22097 
      if ftype == TType.STOP:
22098 
        break
22099 
      if fid == 0:
22100 
        if ftype == TType.STRUCT:
22101 
          self.success = Order()
22102 
          self.success.read(iprot)
22103 
        else:
22104 
          iprot.skip(ftype)
22105 
      elif fid == 1:
22106 
        if ftype == TType.STRUCT:
22107 
          self.ex = TransactionServiceException()
22108 
          self.ex.read(iprot)
22109 
        else:
22110 
          iprot.skip(ftype)
22111 
      else:
22112 
        iprot.skip(ftype)
22113 
      iprot.readFieldEnd()
22114 
    iprot.readStructEnd()
22115 
 
22116 
  def write(self, oprot):
22117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22119 
      return
22120 
    oprot.writeStructBegin('getOrderForAwb_result')
22121 
    if self.success is not None:
22122 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22123 
      self.success.write(oprot)
22124 
      oprot.writeFieldEnd()
22125 
    if self.ex is not None:
22126 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22127 
      self.ex.write(oprot)
22128 
      oprot.writeFieldEnd()
22129 
    oprot.writeFieldStop()
22130 
    oprot.writeStructEnd()
22131 
 
22132 
  def validate(self):
22133 
    return
22134 
 
22135 
 
22136 
  def __repr__(self):
22137 
    L = ['%s=%r' % (key, value)
22138 
      for key, value in self.__dict__.iteritems()]
22139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22140 
 
22141 
  def __eq__(self, other):
22142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22143 
 
22144 
  def __ne__(self, other):
22145 
    return not (self == other)
4506 phani.kuma 22146 
 
22147 
class getOrdersForProviderForStatus_args:
22148 
  """
22149 
  Attributes:
22150 
   - logistics_provider_id
4910 phani.kuma 22151 
   - order_status_list
4506 phani.kuma 22152 
  """
22153 
 
22154 
  thrift_spec = (
22155 
    None, # 0
22156 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22157 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22158 
  )
22159 
 
4910 phani.kuma 22160 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22161 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22162 
    self.order_status_list = order_status_list
4506 phani.kuma 22163 
 
22164 
  def read(self, iprot):
22165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22167 
      return
22168 
    iprot.readStructBegin()
22169 
    while True:
22170 
      (fname, ftype, fid) = iprot.readFieldBegin()
22171 
      if ftype == TType.STOP:
22172 
        break
22173 
      if fid == 1:
22174 
        if ftype == TType.I64:
22175 
          self.logistics_provider_id = iprot.readI64();
22176 
        else:
22177 
          iprot.skip(ftype)
22178 
      elif fid == 2:
4910 phani.kuma 22179 
        if ftype == TType.LIST:
22180 
          self.order_status_list = []
6188 rajveer 22181 
          (_etype513, _size510) = iprot.readListBegin()
22182 
          for _i514 in xrange(_size510):
22183 
            _elem515 = iprot.readI32();
22184 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22185 
          iprot.readListEnd()
4506 phani.kuma 22186 
        else:
22187 
          iprot.skip(ftype)
22188 
      else:
22189 
        iprot.skip(ftype)
22190 
      iprot.readFieldEnd()
22191 
    iprot.readStructEnd()
22192 
 
22193 
  def write(self, oprot):
22194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22196 
      return
22197 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22198 
    if self.logistics_provider_id is not None:
22199 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22200 
      oprot.writeI64(self.logistics_provider_id)
22201 
      oprot.writeFieldEnd()
4910 phani.kuma 22202 
    if self.order_status_list is not None:
22203 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22204 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22205 
      for iter516 in self.order_status_list:
22206 
        oprot.writeI32(iter516)
4910 phani.kuma 22207 
      oprot.writeListEnd()
4506 phani.kuma 22208 
      oprot.writeFieldEnd()
22209 
    oprot.writeFieldStop()
22210 
    oprot.writeStructEnd()
22211 
 
22212 
  def validate(self):
22213 
    return
22214 
 
22215 
 
22216 
  def __repr__(self):
22217 
    L = ['%s=%r' % (key, value)
22218 
      for key, value in self.__dict__.iteritems()]
22219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22220 
 
22221 
  def __eq__(self, other):
22222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22223 
 
22224 
  def __ne__(self, other):
22225 
    return not (self == other)
22226 
 
22227 
class getOrdersForProviderForStatus_result:
22228 
  """
22229 
  Attributes:
22230 
   - success
22231 
   - ex
22232 
  """
22233 
 
22234 
  thrift_spec = (
22235 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22237 
  )
22238 
 
22239 
  def __init__(self, success=None, ex=None,):
22240 
    self.success = success
22241 
    self.ex = ex
22242 
 
22243 
  def read(self, iprot):
22244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22246 
      return
22247 
    iprot.readStructBegin()
22248 
    while True:
22249 
      (fname, ftype, fid) = iprot.readFieldBegin()
22250 
      if ftype == TType.STOP:
22251 
        break
22252 
      if fid == 0:
22253 
        if ftype == TType.LIST:
22254 
          self.success = []
6188 rajveer 22255 
          (_etype520, _size517) = iprot.readListBegin()
22256 
          for _i521 in xrange(_size517):
22257 
            _elem522 = Order()
22258 
            _elem522.read(iprot)
22259 
            self.success.append(_elem522)
4506 phani.kuma 22260 
          iprot.readListEnd()
22261 
        else:
22262 
          iprot.skip(ftype)
22263 
      elif fid == 1:
22264 
        if ftype == TType.STRUCT:
22265 
          self.ex = TransactionServiceException()
22266 
          self.ex.read(iprot)
22267 
        else:
22268 
          iprot.skip(ftype)
22269 
      else:
22270 
        iprot.skip(ftype)
22271 
      iprot.readFieldEnd()
22272 
    iprot.readStructEnd()
22273 
 
22274 
  def write(self, oprot):
22275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22277 
      return
22278 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22279 
    if self.success is not None:
22280 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22281 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22282 
      for iter523 in self.success:
22283 
        iter523.write(oprot)
4506 phani.kuma 22284 
      oprot.writeListEnd()
22285 
      oprot.writeFieldEnd()
22286 
    if self.ex is not None:
22287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22288 
      self.ex.write(oprot)
22289 
      oprot.writeFieldEnd()
22290 
    oprot.writeFieldStop()
22291 
    oprot.writeStructEnd()
22292 
 
22293 
  def validate(self):
22294 
    return
22295 
 
22296 
 
22297 
  def __repr__(self):
22298 
    L = ['%s=%r' % (key, value)
22299 
      for key, value in self.__dict__.iteritems()]
22300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22301 
 
22302 
  def __eq__(self, other):
22303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22304 
 
22305 
  def __ne__(self, other):
22306 
    return not (self == other)
4600 varun.gupt 22307 
 
22308 
class getBilledOrdersForVendor_args:
22309 
  """
22310 
  Attributes:
22311 
   - vendorId
22312 
   - billingDateFrom
22313 
   - billingDateTo
22314 
  """
22315 
 
22316 
  thrift_spec = (
22317 
    None, # 0
22318 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22319 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22320 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22321 
  )
22322 
 
22323 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22324 
    self.vendorId = vendorId
22325 
    self.billingDateFrom = billingDateFrom
22326 
    self.billingDateTo = billingDateTo
22327 
 
22328 
  def read(self, iprot):
22329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22331 
      return
22332 
    iprot.readStructBegin()
22333 
    while True:
22334 
      (fname, ftype, fid) = iprot.readFieldBegin()
22335 
      if ftype == TType.STOP:
22336 
        break
22337 
      if fid == 1:
22338 
        if ftype == TType.I64:
22339 
          self.vendorId = iprot.readI64();
22340 
        else:
22341 
          iprot.skip(ftype)
22342 
      elif fid == 2:
22343 
        if ftype == TType.I64:
22344 
          self.billingDateFrom = iprot.readI64();
22345 
        else:
22346 
          iprot.skip(ftype)
22347 
      elif fid == 3:
22348 
        if ftype == TType.I64:
22349 
          self.billingDateTo = iprot.readI64();
22350 
        else:
22351 
          iprot.skip(ftype)
22352 
      else:
22353 
        iprot.skip(ftype)
22354 
      iprot.readFieldEnd()
22355 
    iprot.readStructEnd()
22356 
 
22357 
  def write(self, oprot):
22358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22360 
      return
22361 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22362 
    if self.vendorId is not None:
22363 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22364 
      oprot.writeI64(self.vendorId)
22365 
      oprot.writeFieldEnd()
22366 
    if self.billingDateFrom is not None:
22367 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22368 
      oprot.writeI64(self.billingDateFrom)
22369 
      oprot.writeFieldEnd()
22370 
    if self.billingDateTo is not None:
22371 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22372 
      oprot.writeI64(self.billingDateTo)
22373 
      oprot.writeFieldEnd()
22374 
    oprot.writeFieldStop()
22375 
    oprot.writeStructEnd()
22376 
 
22377 
  def validate(self):
22378 
    return
22379 
 
22380 
 
22381 
  def __repr__(self):
22382 
    L = ['%s=%r' % (key, value)
22383 
      for key, value in self.__dict__.iteritems()]
22384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22385 
 
22386 
  def __eq__(self, other):
22387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22388 
 
22389 
  def __ne__(self, other):
22390 
    return not (self == other)
22391 
 
22392 
class getBilledOrdersForVendor_result:
22393 
  """
22394 
  Attributes:
22395 
   - success
22396 
   - ex
22397 
  """
22398 
 
22399 
  thrift_spec = (
22400 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22401 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22402 
  )
22403 
 
22404 
  def __init__(self, success=None, ex=None,):
22405 
    self.success = success
22406 
    self.ex = ex
22407 
 
22408 
  def read(self, iprot):
22409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22411 
      return
22412 
    iprot.readStructBegin()
22413 
    while True:
22414 
      (fname, ftype, fid) = iprot.readFieldBegin()
22415 
      if ftype == TType.STOP:
22416 
        break
22417 
      if fid == 0:
22418 
        if ftype == TType.LIST:
22419 
          self.success = []
6188 rajveer 22420 
          (_etype527, _size524) = iprot.readListBegin()
22421 
          for _i528 in xrange(_size524):
22422 
            _elem529 = Order()
22423 
            _elem529.read(iprot)
22424 
            self.success.append(_elem529)
4600 varun.gupt 22425 
          iprot.readListEnd()
22426 
        else:
22427 
          iprot.skip(ftype)
22428 
      elif fid == 1:
22429 
        if ftype == TType.STRUCT:
22430 
          self.ex = TransactionServiceException()
22431 
          self.ex.read(iprot)
22432 
        else:
22433 
          iprot.skip(ftype)
22434 
      else:
22435 
        iprot.skip(ftype)
22436 
      iprot.readFieldEnd()
22437 
    iprot.readStructEnd()
22438 
 
22439 
  def write(self, oprot):
22440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22442 
      return
22443 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22444 
    if self.success is not None:
22445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22447 
      for iter530 in self.success:
22448 
        iter530.write(oprot)
4600 varun.gupt 22449 
      oprot.writeListEnd()
22450 
      oprot.writeFieldEnd()
22451 
    if self.ex is not None:
22452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22453 
      self.ex.write(oprot)
22454 
      oprot.writeFieldEnd()
22455 
    oprot.writeFieldStop()
22456 
    oprot.writeStructEnd()
22457 
 
22458 
  def validate(self):
22459 
    return
22460 
 
22461 
 
22462 
  def __repr__(self):
22463 
    L = ['%s=%r' % (key, value)
22464 
      for key, value in self.__dict__.iteritems()]
22465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22466 
 
22467 
  def __eq__(self, other):
22468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22469 
 
22470 
  def __ne__(self, other):
22471 
    return not (self == other)
22472 
 
4607 rajveer 22473 
class getSlippedSippingDateOrders_args:
22474 
 
22475 
  thrift_spec = (
22476 
  )
22477 
 
22478 
  def read(self, iprot):
22479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22481 
      return
22482 
    iprot.readStructBegin()
22483 
    while True:
22484 
      (fname, ftype, fid) = iprot.readFieldBegin()
22485 
      if ftype == TType.STOP:
22486 
        break
22487 
      else:
22488 
        iprot.skip(ftype)
22489 
      iprot.readFieldEnd()
22490 
    iprot.readStructEnd()
22491 
 
22492 
  def write(self, oprot):
22493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22495 
      return
22496 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22497 
    oprot.writeFieldStop()
22498 
    oprot.writeStructEnd()
22499 
 
22500 
  def validate(self):
22501 
    return
22502 
 
22503 
 
22504 
  def __repr__(self):
22505 
    L = ['%s=%r' % (key, value)
22506 
      for key, value in self.__dict__.iteritems()]
22507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22508 
 
22509 
  def __eq__(self, other):
22510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22511 
 
22512 
  def __ne__(self, other):
22513 
    return not (self == other)
22514 
 
22515 
class getSlippedSippingDateOrders_result:
22516 
  """
22517 
  Attributes:
22518 
   - success
22519 
   - ex
22520 
  """
22521 
 
22522 
  thrift_spec = (
22523 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22524 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22525 
  )
22526 
 
22527 
  def __init__(self, success=None, ex=None,):
22528 
    self.success = success
22529 
    self.ex = ex
22530 
 
22531 
  def read(self, iprot):
22532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22534 
      return
22535 
    iprot.readStructBegin()
22536 
    while True:
22537 
      (fname, ftype, fid) = iprot.readFieldBegin()
22538 
      if ftype == TType.STOP:
22539 
        break
22540 
      if fid == 0:
22541 
        if ftype == TType.LIST:
22542 
          self.success = []
6188 rajveer 22543 
          (_etype534, _size531) = iprot.readListBegin()
22544 
          for _i535 in xrange(_size531):
22545 
            _elem536 = Order()
22546 
            _elem536.read(iprot)
22547 
            self.success.append(_elem536)
4607 rajveer 22548 
          iprot.readListEnd()
22549 
        else:
22550 
          iprot.skip(ftype)
22551 
      elif fid == 1:
22552 
        if ftype == TType.STRUCT:
22553 
          self.ex = TransactionServiceException()
22554 
          self.ex.read(iprot)
22555 
        else:
22556 
          iprot.skip(ftype)
22557 
      else:
22558 
        iprot.skip(ftype)
22559 
      iprot.readFieldEnd()
22560 
    iprot.readStructEnd()
22561 
 
22562 
  def write(self, oprot):
22563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22565 
      return
22566 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22567 
    if self.success is not None:
22568 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22569 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22570 
      for iter537 in self.success:
22571 
        iter537.write(oprot)
4607 rajveer 22572 
      oprot.writeListEnd()
22573 
      oprot.writeFieldEnd()
22574 
    if self.ex is not None:
22575 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22576 
      self.ex.write(oprot)
22577 
      oprot.writeFieldEnd()
22578 
    oprot.writeFieldStop()
22579 
    oprot.writeStructEnd()
22580 
 
22581 
  def validate(self):
22582 
    return
22583 
 
22584 
 
22585 
  def __repr__(self):
22586 
    L = ['%s=%r' % (key, value)
22587 
      for key, value in self.__dict__.iteritems()]
22588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22589 
 
22590 
  def __eq__(self, other):
22591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22592 
 
22593 
  def __ne__(self, other):
22594 
    return not (self == other)
22595 
 
4709 rajveer 22596 
class getCancelledOrders_args:
22597 
  """
22598 
  Attributes:
22599 
   - cancelDateFrom
22600 
   - cancelDateTo
22601 
  """
22602 
 
22603 
  thrift_spec = (
22604 
    None, # 0
22605 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22606 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22607 
  )
22608 
 
22609 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22610 
    self.cancelDateFrom = cancelDateFrom
22611 
    self.cancelDateTo = cancelDateTo
22612 
 
22613 
  def read(self, iprot):
22614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22616 
      return
22617 
    iprot.readStructBegin()
22618 
    while True:
22619 
      (fname, ftype, fid) = iprot.readFieldBegin()
22620 
      if ftype == TType.STOP:
22621 
        break
22622 
      if fid == 1:
22623 
        if ftype == TType.I64:
22624 
          self.cancelDateFrom = iprot.readI64();
22625 
        else:
22626 
          iprot.skip(ftype)
22627 
      elif fid == 2:
22628 
        if ftype == TType.I64:
22629 
          self.cancelDateTo = iprot.readI64();
22630 
        else:
22631 
          iprot.skip(ftype)
22632 
      else:
22633 
        iprot.skip(ftype)
22634 
      iprot.readFieldEnd()
22635 
    iprot.readStructEnd()
22636 
 
22637 
  def write(self, oprot):
22638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22640 
      return
22641 
    oprot.writeStructBegin('getCancelledOrders_args')
22642 
    if self.cancelDateFrom is not None:
22643 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22644 
      oprot.writeI64(self.cancelDateFrom)
22645 
      oprot.writeFieldEnd()
22646 
    if self.cancelDateTo is not None:
22647 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22648 
      oprot.writeI64(self.cancelDateTo)
22649 
      oprot.writeFieldEnd()
22650 
    oprot.writeFieldStop()
22651 
    oprot.writeStructEnd()
22652 
 
22653 
  def validate(self):
22654 
    return
22655 
 
22656 
 
22657 
  def __repr__(self):
22658 
    L = ['%s=%r' % (key, value)
22659 
      for key, value in self.__dict__.iteritems()]
22660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22661 
 
22662 
  def __eq__(self, other):
22663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22664 
 
22665 
  def __ne__(self, other):
22666 
    return not (self == other)
22667 
 
22668 
class getCancelledOrders_result:
22669 
  """
22670 
  Attributes:
22671 
   - success
22672 
   - ex
22673 
  """
22674 
 
22675 
  thrift_spec = (
22676 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22677 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22678 
  )
22679 
 
22680 
  def __init__(self, success=None, ex=None,):
22681 
    self.success = success
22682 
    self.ex = ex
22683 
 
22684 
  def read(self, iprot):
22685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22687 
      return
22688 
    iprot.readStructBegin()
22689 
    while True:
22690 
      (fname, ftype, fid) = iprot.readFieldBegin()
22691 
      if ftype == TType.STOP:
22692 
        break
22693 
      if fid == 0:
22694 
        if ftype == TType.LIST:
22695 
          self.success = []
6188 rajveer 22696 
          (_etype541, _size538) = iprot.readListBegin()
22697 
          for _i542 in xrange(_size538):
22698 
            _elem543 = Order()
22699 
            _elem543.read(iprot)
22700 
            self.success.append(_elem543)
4709 rajveer 22701 
          iprot.readListEnd()
22702 
        else:
22703 
          iprot.skip(ftype)
22704 
      elif fid == 1:
22705 
        if ftype == TType.STRUCT:
22706 
          self.ex = TransactionServiceException()
22707 
          self.ex.read(iprot)
22708 
        else:
22709 
          iprot.skip(ftype)
22710 
      else:
22711 
        iprot.skip(ftype)
22712 
      iprot.readFieldEnd()
22713 
    iprot.readStructEnd()
22714 
 
22715 
  def write(self, oprot):
22716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22718 
      return
22719 
    oprot.writeStructBegin('getCancelledOrders_result')
22720 
    if self.success is not None:
22721 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22722 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22723 
      for iter544 in self.success:
22724 
        iter544.write(oprot)
4709 rajveer 22725 
      oprot.writeListEnd()
22726 
      oprot.writeFieldEnd()
22727 
    if self.ex is not None:
22728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22729 
      self.ex.write(oprot)
22730 
      oprot.writeFieldEnd()
22731 
    oprot.writeFieldStop()
22732 
    oprot.writeStructEnd()
22733 
 
22734 
  def validate(self):
22735 
    return
22736 
 
22737 
 
22738 
  def __repr__(self):
22739 
    L = ['%s=%r' % (key, value)
22740 
      for key, value in self.__dict__.iteritems()]
22741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22742 
 
22743 
  def __eq__(self, other):
22744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22745 
 
22746 
  def __ne__(self, other):
22747 
    return not (self == other)
22748 
 
4600 varun.gupt 22749 
class saveBluedartSettlements_args:
22750 
  """
22751 
  Attributes:
22752 
   - mapAWBAndAmount
22753 
  """
22754 
 
22755 
  thrift_spec = (
22756 
    None, # 0
22757 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22758 
  )
22759 
 
22760 
  def __init__(self, mapAWBAndAmount=None,):
22761 
    self.mapAWBAndAmount = mapAWBAndAmount
22762 
 
22763 
  def read(self, iprot):
22764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22766 
      return
22767 
    iprot.readStructBegin()
22768 
    while True:
22769 
      (fname, ftype, fid) = iprot.readFieldBegin()
22770 
      if ftype == TType.STOP:
22771 
        break
22772 
      if fid == 1:
22773 
        if ftype == TType.MAP:
22774 
          self.mapAWBAndAmount = {}
6188 rajveer 22775 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22776 
          for _i549 in xrange(_size545):
22777 
            _key550 = iprot.readI64();
22778 
            _val551 = iprot.readDouble();
22779 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22780 
          iprot.readMapEnd()
22781 
        else:
22782 
          iprot.skip(ftype)
22783 
      else:
22784 
        iprot.skip(ftype)
22785 
      iprot.readFieldEnd()
22786 
    iprot.readStructEnd()
22787 
 
22788 
  def write(self, oprot):
22789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22791 
      return
22792 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22793 
    if self.mapAWBAndAmount is not None:
22794 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22795 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22796 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22797 
        oprot.writeI64(kiter552)
22798 
        oprot.writeDouble(viter553)
4600 varun.gupt 22799 
      oprot.writeMapEnd()
22800 
      oprot.writeFieldEnd()
22801 
    oprot.writeFieldStop()
22802 
    oprot.writeStructEnd()
22803 
 
22804 
  def validate(self):
22805 
    return
22806 
 
22807 
 
22808 
  def __repr__(self):
22809 
    L = ['%s=%r' % (key, value)
22810 
      for key, value in self.__dict__.iteritems()]
22811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22812 
 
22813 
  def __eq__(self, other):
22814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22815 
 
22816 
  def __ne__(self, other):
22817 
    return not (self == other)
22818 
 
22819 
class saveBluedartSettlements_result:
22820 
  """
22821 
  Attributes:
22822 
   - ex
22823 
  """
22824 
 
22825 
  thrift_spec = (
22826 
    None, # 0
22827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22828 
  )
22829 
 
22830 
  def __init__(self, ex=None,):
22831 
    self.ex = ex
22832 
 
22833 
  def read(self, iprot):
22834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22836 
      return
22837 
    iprot.readStructBegin()
22838 
    while True:
22839 
      (fname, ftype, fid) = iprot.readFieldBegin()
22840 
      if ftype == TType.STOP:
22841 
        break
22842 
      if fid == 1:
22843 
        if ftype == TType.STRUCT:
22844 
          self.ex = TransactionServiceException()
22845 
          self.ex.read(iprot)
22846 
        else:
22847 
          iprot.skip(ftype)
22848 
      else:
22849 
        iprot.skip(ftype)
22850 
      iprot.readFieldEnd()
22851 
    iprot.readStructEnd()
22852 
 
22853 
  def write(self, oprot):
22854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22856 
      return
22857 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22858 
    if self.ex is not None:
22859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22860 
      self.ex.write(oprot)
22861 
      oprot.writeFieldEnd()
22862 
    oprot.writeFieldStop()
22863 
    oprot.writeStructEnd()
22864 
 
22865 
  def validate(self):
22866 
    return
22867 
 
22868 
 
22869 
  def __repr__(self):
22870 
    L = ['%s=%r' % (key, value)
22871 
      for key, value in self.__dict__.iteritems()]
22872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22873 
 
22874 
  def __eq__(self, other):
22875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22876 
 
22877 
  def __ne__(self, other):
22878 
    return not (self == other)
22879 
 
22880 
class savePaymentSettlements_args:
22881 
  """
22882 
  Attributes:
22883 
   - settlementDate
22884 
   - paymentGatewayId
4905 varun.gupt 22885 
   - referenceId
4600 varun.gupt 22886 
   - serviceTax
22887 
   - otherCharges
22888 
   - netCollection
22889 
  """
22890 
 
22891 
  thrift_spec = (
22892 
    None, # 0
22893 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22894 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22895 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22896 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22897 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22898 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22899 
  )
22900 
 
4905 varun.gupt 22901 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22902 
    self.settlementDate = settlementDate
22903 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22904 
    self.referenceId = referenceId
4600 varun.gupt 22905 
    self.serviceTax = serviceTax
22906 
    self.otherCharges = otherCharges
22907 
    self.netCollection = netCollection
22908 
 
22909 
  def read(self, iprot):
22910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22912 
      return
22913 
    iprot.readStructBegin()
22914 
    while True:
22915 
      (fname, ftype, fid) = iprot.readFieldBegin()
22916 
      if ftype == TType.STOP:
22917 
        break
22918 
      if fid == 1:
22919 
        if ftype == TType.I64:
22920 
          self.settlementDate = iprot.readI64();
22921 
        else:
22922 
          iprot.skip(ftype)
22923 
      elif fid == 2:
22924 
        if ftype == TType.I64:
22925 
          self.paymentGatewayId = iprot.readI64();
22926 
        else:
22927 
          iprot.skip(ftype)
22928 
      elif fid == 3:
22929 
        if ftype == TType.I64:
4905 varun.gupt 22930 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22931 
        else:
22932 
          iprot.skip(ftype)
22933 
      elif fid == 4:
22934 
        if ftype == TType.DOUBLE:
22935 
          self.serviceTax = iprot.readDouble();
22936 
        else:
22937 
          iprot.skip(ftype)
22938 
      elif fid == 5:
22939 
        if ftype == TType.DOUBLE:
22940 
          self.otherCharges = iprot.readDouble();
22941 
        else:
22942 
          iprot.skip(ftype)
22943 
      elif fid == 6:
22944 
        if ftype == TType.DOUBLE:
22945 
          self.netCollection = iprot.readDouble();
22946 
        else:
22947 
          iprot.skip(ftype)
22948 
      else:
22949 
        iprot.skip(ftype)
22950 
      iprot.readFieldEnd()
22951 
    iprot.readStructEnd()
22952 
 
22953 
  def write(self, oprot):
22954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22956 
      return
22957 
    oprot.writeStructBegin('savePaymentSettlements_args')
22958 
    if self.settlementDate is not None:
22959 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22960 
      oprot.writeI64(self.settlementDate)
22961 
      oprot.writeFieldEnd()
22962 
    if self.paymentGatewayId is not None:
22963 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22964 
      oprot.writeI64(self.paymentGatewayId)
22965 
      oprot.writeFieldEnd()
4905 varun.gupt 22966 
    if self.referenceId is not None:
22967 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22968 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22969 
      oprot.writeFieldEnd()
22970 
    if self.serviceTax is not None:
22971 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22972 
      oprot.writeDouble(self.serviceTax)
22973 
      oprot.writeFieldEnd()
22974 
    if self.otherCharges is not None:
22975 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22976 
      oprot.writeDouble(self.otherCharges)
22977 
      oprot.writeFieldEnd()
22978 
    if self.netCollection is not None:
22979 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22980 
      oprot.writeDouble(self.netCollection)
22981 
      oprot.writeFieldEnd()
22982 
    oprot.writeFieldStop()
22983 
    oprot.writeStructEnd()
22984 
 
22985 
  def validate(self):
22986 
    return
22987 
 
22988 
 
22989 
  def __repr__(self):
22990 
    L = ['%s=%r' % (key, value)
22991 
      for key, value in self.__dict__.iteritems()]
22992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22993 
 
22994 
  def __eq__(self, other):
22995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22996 
 
22997 
  def __ne__(self, other):
22998 
    return not (self == other)
22999 
 
23000 
class savePaymentSettlements_result:
23001 
  """
23002 
  Attributes:
23003 
   - ex
23004 
  """
23005 
 
23006 
  thrift_spec = (
23007 
    None, # 0
23008 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23009 
  )
23010 
 
23011 
  def __init__(self, ex=None,):
23012 
    self.ex = ex
23013 
 
23014 
  def read(self, iprot):
23015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23017 
      return
23018 
    iprot.readStructBegin()
23019 
    while True:
23020 
      (fname, ftype, fid) = iprot.readFieldBegin()
23021 
      if ftype == TType.STOP:
23022 
        break
23023 
      if fid == 1:
23024 
        if ftype == TType.STRUCT:
23025 
          self.ex = TransactionServiceException()
23026 
          self.ex.read(iprot)
23027 
        else:
23028 
          iprot.skip(ftype)
23029 
      else:
23030 
        iprot.skip(ftype)
23031 
      iprot.readFieldEnd()
23032 
    iprot.readStructEnd()
23033 
 
23034 
  def write(self, oprot):
23035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23037 
      return
23038 
    oprot.writeStructBegin('savePaymentSettlements_result')
23039 
    if self.ex is not None:
23040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23041 
      self.ex.write(oprot)
23042 
      oprot.writeFieldEnd()
23043 
    oprot.writeFieldStop()
23044 
    oprot.writeStructEnd()
23045 
 
23046 
  def validate(self):
23047 
    return
23048 
 
23049 
 
23050 
  def __repr__(self):
23051 
    L = ['%s=%r' % (key, value)
23052 
      for key, value in self.__dict__.iteritems()]
23053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23054 
 
23055 
  def __eq__(self, other):
23056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23057 
 
23058 
  def __ne__(self, other):
23059 
    return not (self == other)
23060 
 
23061 
class saveEBSSettlementSummary_args:
23062 
  """
23063 
  Attributes:
23064 
   - settlementId
23065 
   - settlementDate
23066 
   - transactionDateFrom
23067 
   - transactionDateTo
23068 
   - amount
23069 
  """
23070 
 
23071 
  thrift_spec = (
23072 
    None, # 0
23073 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23074 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23075 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23076 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23077 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23078 
  )
23079 
 
23080 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23081 
    self.settlementId = settlementId
23082 
    self.settlementDate = settlementDate
23083 
    self.transactionDateFrom = transactionDateFrom
23084 
    self.transactionDateTo = transactionDateTo
23085 
    self.amount = amount
23086 
 
23087 
  def read(self, iprot):
23088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23090 
      return
23091 
    iprot.readStructBegin()
23092 
    while True:
23093 
      (fname, ftype, fid) = iprot.readFieldBegin()
23094 
      if ftype == TType.STOP:
23095 
        break
23096 
      if fid == 1:
23097 
        if ftype == TType.I64:
23098 
          self.settlementId = iprot.readI64();
23099 
        else:
23100 
          iprot.skip(ftype)
23101 
      elif fid == 2:
23102 
        if ftype == TType.I64:
23103 
          self.settlementDate = iprot.readI64();
23104 
        else:
23105 
          iprot.skip(ftype)
23106 
      elif fid == 3:
23107 
        if ftype == TType.I64:
23108 
          self.transactionDateFrom = iprot.readI64();
23109 
        else:
23110 
          iprot.skip(ftype)
23111 
      elif fid == 4:
23112 
        if ftype == TType.I64:
23113 
          self.transactionDateTo = iprot.readI64();
23114 
        else:
23115 
          iprot.skip(ftype)
23116 
      elif fid == 5:
23117 
        if ftype == TType.DOUBLE:
23118 
          self.amount = iprot.readDouble();
23119 
        else:
23120 
          iprot.skip(ftype)
23121 
      else:
23122 
        iprot.skip(ftype)
23123 
      iprot.readFieldEnd()
23124 
    iprot.readStructEnd()
23125 
 
23126 
  def write(self, oprot):
23127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23129 
      return
23130 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23131 
    if self.settlementId is not None:
23132 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23133 
      oprot.writeI64(self.settlementId)
23134 
      oprot.writeFieldEnd()
23135 
    if self.settlementDate is not None:
23136 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23137 
      oprot.writeI64(self.settlementDate)
23138 
      oprot.writeFieldEnd()
23139 
    if self.transactionDateFrom is not None:
23140 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23141 
      oprot.writeI64(self.transactionDateFrom)
23142 
      oprot.writeFieldEnd()
23143 
    if self.transactionDateTo is not None:
23144 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23145 
      oprot.writeI64(self.transactionDateTo)
23146 
      oprot.writeFieldEnd()
23147 
    if self.amount is not None:
23148 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23149 
      oprot.writeDouble(self.amount)
23150 
      oprot.writeFieldEnd()
23151 
    oprot.writeFieldStop()
23152 
    oprot.writeStructEnd()
23153 
 
23154 
  def validate(self):
23155 
    return
23156 
 
23157 
 
23158 
  def __repr__(self):
23159 
    L = ['%s=%r' % (key, value)
23160 
      for key, value in self.__dict__.iteritems()]
23161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23162 
 
23163 
  def __eq__(self, other):
23164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23165 
 
23166 
  def __ne__(self, other):
23167 
    return not (self == other)
23168 
 
23169 
class saveEBSSettlementSummary_result:
23170 
  """
23171 
  Attributes:
23172 
   - ex
23173 
  """
23174 
 
23175 
  thrift_spec = (
23176 
    None, # 0
23177 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23178 
  )
23179 
 
23180 
  def __init__(self, ex=None,):
23181 
    self.ex = ex
23182 
 
23183 
  def read(self, iprot):
23184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23186 
      return
23187 
    iprot.readStructBegin()
23188 
    while True:
23189 
      (fname, ftype, fid) = iprot.readFieldBegin()
23190 
      if ftype == TType.STOP:
23191 
        break
23192 
      if fid == 1:
23193 
        if ftype == TType.STRUCT:
23194 
          self.ex = TransactionServiceException()
23195 
          self.ex.read(iprot)
23196 
        else:
23197 
          iprot.skip(ftype)
23198 
      else:
23199 
        iprot.skip(ftype)
23200 
      iprot.readFieldEnd()
23201 
    iprot.readStructEnd()
23202 
 
23203 
  def write(self, oprot):
23204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23206 
      return
23207 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23208 
    if self.ex is not None:
23209 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23210 
      self.ex.write(oprot)
23211 
      oprot.writeFieldEnd()
23212 
    oprot.writeFieldStop()
23213 
    oprot.writeStructEnd()
23214 
 
23215 
  def validate(self):
23216 
    return
23217 
 
23218 
 
23219 
  def __repr__(self):
23220 
    L = ['%s=%r' % (key, value)
23221 
      for key, value in self.__dict__.iteritems()]
23222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23223 
 
23224 
  def __eq__(self, other):
23225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23226 
 
23227 
  def __ne__(self, other):
23228 
    return not (self == other)
23229 
 
5386 phani.kuma 23230 
class getSettlementForPrepaid_args:
4600 varun.gupt 23231 
  """
23232 
  Attributes:
5189 varun.gupt 23233 
   - referenceId
23234 
   - isRefund
4600 varun.gupt 23235 
  """
23236 
 
23237 
  thrift_spec = (
23238 
    None, # 0
5189 varun.gupt 23239 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23240 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23241 
  )
23242 
 
5386 phani.kuma 23243 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23244 
    self.referenceId = referenceId
23245 
    self.isRefund = isRefund
4600 varun.gupt 23246 
 
23247 
  def read(self, iprot):
23248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23250 
      return
23251 
    iprot.readStructBegin()
23252 
    while True:
23253 
      (fname, ftype, fid) = iprot.readFieldBegin()
23254 
      if ftype == TType.STOP:
23255 
        break
23256 
      if fid == 1:
23257 
        if ftype == TType.I64:
5189 varun.gupt 23258 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23259 
        else:
23260 
          iprot.skip(ftype)
5189 varun.gupt 23261 
      elif fid == 2:
23262 
        if ftype == TType.BOOL:
23263 
          self.isRefund = iprot.readBool();
23264 
        else:
23265 
          iprot.skip(ftype)
4600 varun.gupt 23266 
      else:
23267 
        iprot.skip(ftype)
23268 
      iprot.readFieldEnd()
23269 
    iprot.readStructEnd()
23270 
 
23271 
  def write(self, oprot):
23272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23274 
      return
5386 phani.kuma 23275 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23276 
    if self.referenceId is not None:
23277 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23278 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23279 
      oprot.writeFieldEnd()
5386 phani.kuma 23280 
    if self.isRefund is not None:
23281 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23282 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23283 
      oprot.writeFieldEnd()
5386 phani.kuma 23284 
    oprot.writeFieldStop()
23285 
    oprot.writeStructEnd()
23286 
 
23287 
  def validate(self):
23288 
    return
23289 
 
23290 
 
23291 
  def __repr__(self):
23292 
    L = ['%s=%r' % (key, value)
23293 
      for key, value in self.__dict__.iteritems()]
23294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23295 
 
23296 
  def __eq__(self, other):
23297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23298 
 
23299 
  def __ne__(self, other):
23300 
    return not (self == other)
23301 
 
23302 
class getSettlementForPrepaid_result:
23303 
  """
23304 
  Attributes:
23305 
   - success
23306 
   - ex
23307 
  """
23308 
 
23309 
  thrift_spec = (
23310 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23311 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23312 
  )
23313 
 
23314 
  def __init__(self, success=None, ex=None,):
23315 
    self.success = success
23316 
    self.ex = ex
23317 
 
23318 
  def read(self, iprot):
23319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23321 
      return
23322 
    iprot.readStructBegin()
23323 
    while True:
23324 
      (fname, ftype, fid) = iprot.readFieldBegin()
23325 
      if ftype == TType.STOP:
23326 
        break
23327 
      if fid == 0:
23328 
        if ftype == TType.STRUCT:
23329 
          self.success = PaymentSettlement()
23330 
          self.success.read(iprot)
23331 
        else:
23332 
          iprot.skip(ftype)
23333 
      elif fid == 1:
23334 
        if ftype == TType.STRUCT:
23335 
          self.ex = TransactionServiceException()
23336 
          self.ex.read(iprot)
23337 
        else:
23338 
          iprot.skip(ftype)
23339 
      else:
23340 
        iprot.skip(ftype)
23341 
      iprot.readFieldEnd()
23342 
    iprot.readStructEnd()
23343 
 
23344 
  def write(self, oprot):
23345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23347 
      return
23348 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23349 
    if self.success is not None:
23350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23351 
      self.success.write(oprot)
23352 
      oprot.writeFieldEnd()
23353 
    if self.ex is not None:
23354 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23355 
      self.ex.write(oprot)
23356 
      oprot.writeFieldEnd()
23357 
    oprot.writeFieldStop()
23358 
    oprot.writeStructEnd()
23359 
 
23360 
  def validate(self):
23361 
    return
23362 
 
23363 
 
23364 
  def __repr__(self):
23365 
    L = ['%s=%r' % (key, value)
23366 
      for key, value in self.__dict__.iteritems()]
23367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23368 
 
23369 
  def __eq__(self, other):
23370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23371 
 
23372 
  def __ne__(self, other):
23373 
    return not (self == other)
23374 
 
23375 
class getSettlementForCod_args:
23376 
  """
23377 
  Attributes:
23378 
   - orderId
23379 
   - isRefund
23380 
  """
23381 
 
23382 
  thrift_spec = (
23383 
    None, # 0
23384 
    (1, TType.I64, 'orderId', None, None, ), # 1
23385 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23386 
  )
23387 
 
23388 
  def __init__(self, orderId=None, isRefund=None,):
23389 
    self.orderId = orderId
23390 
    self.isRefund = isRefund
23391 
 
23392 
  def read(self, iprot):
23393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23395 
      return
23396 
    iprot.readStructBegin()
23397 
    while True:
23398 
      (fname, ftype, fid) = iprot.readFieldBegin()
23399 
      if ftype == TType.STOP:
23400 
        break
23401 
      if fid == 1:
23402 
        if ftype == TType.I64:
23403 
          self.orderId = iprot.readI64();
23404 
        else:
23405 
          iprot.skip(ftype)
23406 
      elif fid == 2:
23407 
        if ftype == TType.BOOL:
23408 
          self.isRefund = iprot.readBool();
23409 
        else:
23410 
          iprot.skip(ftype)
23411 
      else:
23412 
        iprot.skip(ftype)
23413 
      iprot.readFieldEnd()
23414 
    iprot.readStructEnd()
23415 
 
23416 
  def write(self, oprot):
23417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23419 
      return
23420 
    oprot.writeStructBegin('getSettlementForCod_args')
23421 
    if self.orderId is not None:
23422 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23423 
      oprot.writeI64(self.orderId)
23424 
      oprot.writeFieldEnd()
5189 varun.gupt 23425 
    if self.isRefund is not None:
5386 phani.kuma 23426 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23427 
      oprot.writeBool(self.isRefund)
23428 
      oprot.writeFieldEnd()
4600 varun.gupt 23429 
    oprot.writeFieldStop()
23430 
    oprot.writeStructEnd()
23431 
 
23432 
  def validate(self):
23433 
    return
23434 
 
23435 
 
23436 
  def __repr__(self):
23437 
    L = ['%s=%r' % (key, value)
23438 
      for key, value in self.__dict__.iteritems()]
23439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23440 
 
23441 
  def __eq__(self, other):
23442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23443 
 
23444 
  def __ne__(self, other):
23445 
    return not (self == other)
23446 
 
5386 phani.kuma 23447 
class getSettlementForCod_result:
4600 varun.gupt 23448 
  """
23449 
  Attributes:
23450 
   - success
23451 
   - ex
23452 
  """
23453 
 
23454 
  thrift_spec = (
23455 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23456 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23457 
  )
23458 
 
23459 
  def __init__(self, success=None, ex=None,):
23460 
    self.success = success
23461 
    self.ex = ex
23462 
 
23463 
  def read(self, iprot):
23464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23466 
      return
23467 
    iprot.readStructBegin()
23468 
    while True:
23469 
      (fname, ftype, fid) = iprot.readFieldBegin()
23470 
      if ftype == TType.STOP:
23471 
        break
23472 
      if fid == 0:
23473 
        if ftype == TType.STRUCT:
23474 
          self.success = PaymentSettlement()
23475 
          self.success.read(iprot)
23476 
        else:
23477 
          iprot.skip(ftype)
23478 
      elif fid == 1:
23479 
        if ftype == TType.STRUCT:
23480 
          self.ex = TransactionServiceException()
23481 
          self.ex.read(iprot)
23482 
        else:
23483 
          iprot.skip(ftype)
23484 
      else:
23485 
        iprot.skip(ftype)
23486 
      iprot.readFieldEnd()
23487 
    iprot.readStructEnd()
23488 
 
23489 
  def write(self, oprot):
23490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23492 
      return
5386 phani.kuma 23493 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23494 
    if self.success is not None:
23495 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23496 
      self.success.write(oprot)
23497 
      oprot.writeFieldEnd()
23498 
    if self.ex is not None:
23499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23500 
      self.ex.write(oprot)
23501 
      oprot.writeFieldEnd()
23502 
    oprot.writeFieldStop()
23503 
    oprot.writeStructEnd()
23504 
 
23505 
  def validate(self):
23506 
    return
23507 
 
23508 
 
23509 
  def __repr__(self):
23510 
    L = ['%s=%r' % (key, value)
23511 
      for key, value in self.__dict__.iteritems()]
23512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23513 
 
23514 
  def __eq__(self, other):
23515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23516 
 
23517 
  def __ne__(self, other):
23518 
    return not (self == other)
23519 
 
23520 
class getEBSSettlementSummaries_args:
23521 
 
23522 
  thrift_spec = (
23523 
  )
23524 
 
23525 
  def read(self, iprot):
23526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23528 
      return
23529 
    iprot.readStructBegin()
23530 
    while True:
23531 
      (fname, ftype, fid) = iprot.readFieldBegin()
23532 
      if ftype == TType.STOP:
23533 
        break
23534 
      else:
23535 
        iprot.skip(ftype)
23536 
      iprot.readFieldEnd()
23537 
    iprot.readStructEnd()
23538 
 
23539 
  def write(self, oprot):
23540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23542 
      return
23543 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23544 
    oprot.writeFieldStop()
23545 
    oprot.writeStructEnd()
23546 
 
23547 
  def validate(self):
23548 
    return
23549 
 
23550 
 
23551 
  def __repr__(self):
23552 
    L = ['%s=%r' % (key, value)
23553 
      for key, value in self.__dict__.iteritems()]
23554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23555 
 
23556 
  def __eq__(self, other):
23557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23558 
 
23559 
  def __ne__(self, other):
23560 
    return not (self == other)
23561 
 
23562 
class getEBSSettlementSummaries_result:
23563 
  """
23564 
  Attributes:
23565 
   - success
23566 
   - ex
23567 
  """
23568 
 
23569 
  thrift_spec = (
23570 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23572 
  )
23573 
 
23574 
  def __init__(self, success=None, ex=None,):
23575 
    self.success = success
23576 
    self.ex = ex
23577 
 
23578 
  def read(self, iprot):
23579 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23580 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23581 
      return
23582 
    iprot.readStructBegin()
23583 
    while True:
23584 
      (fname, ftype, fid) = iprot.readFieldBegin()
23585 
      if ftype == TType.STOP:
23586 
        break
23587 
      if fid == 0:
23588 
        if ftype == TType.MAP:
23589 
          self.success = {}
6188 rajveer 23590 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23591 
          for _i558 in xrange(_size554):
23592 
            _key559 = iprot.readI64();
23593 
            _val560 = iprot.readString();
23594 
            self.success[_key559] = _val560
4600 varun.gupt 23595 
          iprot.readMapEnd()
23596 
        else:
23597 
          iprot.skip(ftype)
23598 
      elif fid == 1:
23599 
        if ftype == TType.STRUCT:
23600 
          self.ex = TransactionServiceException()
23601 
          self.ex.read(iprot)
23602 
        else:
23603 
          iprot.skip(ftype)
23604 
      else:
23605 
        iprot.skip(ftype)
23606 
      iprot.readFieldEnd()
23607 
    iprot.readStructEnd()
23608 
 
23609 
  def write(self, oprot):
23610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23612 
      return
23613 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23614 
    if self.success is not None:
23615 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23616 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23617 
      for kiter561,viter562 in self.success.items():
23618 
        oprot.writeI64(kiter561)
23619 
        oprot.writeString(viter562)
4600 varun.gupt 23620 
      oprot.writeMapEnd()
23621 
      oprot.writeFieldEnd()
23622 
    if self.ex is not None:
23623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23624 
      self.ex.write(oprot)
23625 
      oprot.writeFieldEnd()
23626 
    oprot.writeFieldStop()
23627 
    oprot.writeStructEnd()
23628 
 
23629 
  def validate(self):
23630 
    return
23631 
 
23632 
 
23633 
  def __repr__(self):
23634 
    L = ['%s=%r' % (key, value)
23635 
      for key, value in self.__dict__.iteritems()]
23636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23637 
 
23638 
  def __eq__(self, other):
23639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23640 
 
23641 
  def __ne__(self, other):
23642 
    return not (self == other)
23643 
 
23644 
class markEBSSettlementUploaded_args:
23645 
  """
23646 
  Attributes:
23647 
   - settlementId
23648 
  """
23649 
 
23650 
  thrift_spec = (
23651 
    None, # 0
23652 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23653 
  )
23654 
 
23655 
  def __init__(self, settlementId=None,):
23656 
    self.settlementId = settlementId
23657 
 
23658 
  def read(self, iprot):
23659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23661 
      return
23662 
    iprot.readStructBegin()
23663 
    while True:
23664 
      (fname, ftype, fid) = iprot.readFieldBegin()
23665 
      if ftype == TType.STOP:
23666 
        break
23667 
      if fid == 1:
23668 
        if ftype == TType.I64:
23669 
          self.settlementId = iprot.readI64();
23670 
        else:
23671 
          iprot.skip(ftype)
23672 
      else:
23673 
        iprot.skip(ftype)
23674 
      iprot.readFieldEnd()
23675 
    iprot.readStructEnd()
23676 
 
23677 
  def write(self, oprot):
23678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23680 
      return
23681 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23682 
    if self.settlementId is not None:
23683 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23684 
      oprot.writeI64(self.settlementId)
23685 
      oprot.writeFieldEnd()
23686 
    oprot.writeFieldStop()
23687 
    oprot.writeStructEnd()
23688 
 
23689 
  def validate(self):
23690 
    return
23691 
 
23692 
 
23693 
  def __repr__(self):
23694 
    L = ['%s=%r' % (key, value)
23695 
      for key, value in self.__dict__.iteritems()]
23696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23697 
 
23698 
  def __eq__(self, other):
23699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23700 
 
23701 
  def __ne__(self, other):
23702 
    return not (self == other)
23703 
 
23704 
class markEBSSettlementUploaded_result:
23705 
  """
23706 
  Attributes:
23707 
   - ex
23708 
  """
23709 
 
23710 
  thrift_spec = (
23711 
    None, # 0
23712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23713 
  )
23714 
 
23715 
  def __init__(self, ex=None,):
23716 
    self.ex = ex
23717 
 
23718 
  def read(self, iprot):
23719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23721 
      return
23722 
    iprot.readStructBegin()
23723 
    while True:
23724 
      (fname, ftype, fid) = iprot.readFieldBegin()
23725 
      if ftype == TType.STOP:
23726 
        break
23727 
      if fid == 1:
23728 
        if ftype == TType.STRUCT:
23729 
          self.ex = TransactionServiceException()
23730 
          self.ex.read(iprot)
23731 
        else:
23732 
          iprot.skip(ftype)
23733 
      else:
23734 
        iprot.skip(ftype)
23735 
      iprot.readFieldEnd()
23736 
    iprot.readStructEnd()
23737 
 
23738 
  def write(self, oprot):
23739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23741 
      return
23742 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23743 
    if self.ex is not None:
23744 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23745 
      self.ex.write(oprot)
23746 
      oprot.writeFieldEnd()
23747 
    oprot.writeFieldStop()
23748 
    oprot.writeStructEnd()
23749 
 
23750 
  def validate(self):
23751 
    return
23752 
 
23753 
 
23754 
  def __repr__(self):
23755 
    L = ['%s=%r' % (key, value)
23756 
      for key, value in self.__dict__.iteritems()]
23757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23758 
 
23759 
  def __eq__(self, other):
23760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23761 
 
23762 
  def __ne__(self, other):
23763 
    return not (self == other)
23764 
 
23765 
class getEBSSettlementDate_args:
23766 
  """
23767 
  Attributes:
23768 
   - settlementId
23769 
  """
23770 
 
23771 
  thrift_spec = (
23772 
    None, # 0
23773 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23774 
  )
23775 
 
23776 
  def __init__(self, settlementId=None,):
23777 
    self.settlementId = settlementId
23778 
 
23779 
  def read(self, iprot):
23780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23782 
      return
23783 
    iprot.readStructBegin()
23784 
    while True:
23785 
      (fname, ftype, fid) = iprot.readFieldBegin()
23786 
      if ftype == TType.STOP:
23787 
        break
23788 
      if fid == 1:
23789 
        if ftype == TType.I64:
23790 
          self.settlementId = iprot.readI64();
23791 
        else:
23792 
          iprot.skip(ftype)
23793 
      else:
23794 
        iprot.skip(ftype)
23795 
      iprot.readFieldEnd()
23796 
    iprot.readStructEnd()
23797 
 
23798 
  def write(self, oprot):
23799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23801 
      return
23802 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23803 
    if self.settlementId is not None:
23804 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23805 
      oprot.writeI64(self.settlementId)
23806 
      oprot.writeFieldEnd()
23807 
    oprot.writeFieldStop()
23808 
    oprot.writeStructEnd()
23809 
 
23810 
  def validate(self):
23811 
    return
23812 
 
23813 
 
23814 
  def __repr__(self):
23815 
    L = ['%s=%r' % (key, value)
23816 
      for key, value in self.__dict__.iteritems()]
23817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23818 
 
23819 
  def __eq__(self, other):
23820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23821 
 
23822 
  def __ne__(self, other):
23823 
    return not (self == other)
23824 
 
23825 
class getEBSSettlementDate_result:
23826 
  """
23827 
  Attributes:
23828 
   - success
23829 
   - ex
23830 
  """
23831 
 
23832 
  thrift_spec = (
23833 
    (0, TType.I64, 'success', None, None, ), # 0
23834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23835 
  )
23836 
 
23837 
  def __init__(self, success=None, ex=None,):
23838 
    self.success = success
23839 
    self.ex = ex
23840 
 
23841 
  def read(self, iprot):
23842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23844 
      return
23845 
    iprot.readStructBegin()
23846 
    while True:
23847 
      (fname, ftype, fid) = iprot.readFieldBegin()
23848 
      if ftype == TType.STOP:
23849 
        break
23850 
      if fid == 0:
23851 
        if ftype == TType.I64:
23852 
          self.success = iprot.readI64();
23853 
        else:
23854 
          iprot.skip(ftype)
23855 
      elif fid == 1:
23856 
        if ftype == TType.STRUCT:
23857 
          self.ex = TransactionServiceException()
23858 
          self.ex.read(iprot)
23859 
        else:
23860 
          iprot.skip(ftype)
23861 
      else:
23862 
        iprot.skip(ftype)
23863 
      iprot.readFieldEnd()
23864 
    iprot.readStructEnd()
23865 
 
23866 
  def write(self, oprot):
23867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23869 
      return
23870 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23871 
    if self.success is not None:
23872 
      oprot.writeFieldBegin('success', TType.I64, 0)
23873 
      oprot.writeI64(self.success)
23874 
      oprot.writeFieldEnd()
23875 
    if self.ex is not None:
23876 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23877 
      self.ex.write(oprot)
23878 
      oprot.writeFieldEnd()
23879 
    oprot.writeFieldStop()
23880 
    oprot.writeStructEnd()
23881 
 
23882 
  def validate(self):
23883 
    return
23884 
 
23885 
 
23886 
  def __repr__(self):
23887 
    L = ['%s=%r' % (key, value)
23888 
      for key, value in self.__dict__.iteritems()]
23889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23890 
 
23891 
  def __eq__(self, other):
23892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23893 
 
23894 
  def __ne__(self, other):
23895 
    return not (self == other)
4715 varun.gupt 23896 
 
23897 
class getSettlementsByDate_args:
23898 
  """
23899 
  Attributes:
23900 
   - settlementDateFrom
23901 
   - settlementDateTo
23902 
   - isRefund
23903 
  """
23904 
 
23905 
  thrift_spec = (
23906 
    None, # 0
23907 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23908 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23909 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23910 
  )
23911 
 
23912 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23913 
    self.settlementDateFrom = settlementDateFrom
23914 
    self.settlementDateTo = settlementDateTo
23915 
    self.isRefund = isRefund
23916 
 
23917 
  def read(self, iprot):
23918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23920 
      return
23921 
    iprot.readStructBegin()
23922 
    while True:
23923 
      (fname, ftype, fid) = iprot.readFieldBegin()
23924 
      if ftype == TType.STOP:
23925 
        break
23926 
      if fid == 1:
23927 
        if ftype == TType.I64:
23928 
          self.settlementDateFrom = iprot.readI64();
23929 
        else:
23930 
          iprot.skip(ftype)
23931 
      elif fid == 2:
23932 
        if ftype == TType.I64:
23933 
          self.settlementDateTo = iprot.readI64();
23934 
        else:
23935 
          iprot.skip(ftype)
23936 
      elif fid == 3:
23937 
        if ftype == TType.BOOL:
23938 
          self.isRefund = iprot.readBool();
23939 
        else:
23940 
          iprot.skip(ftype)
23941 
      else:
23942 
        iprot.skip(ftype)
23943 
      iprot.readFieldEnd()
23944 
    iprot.readStructEnd()
23945 
 
23946 
  def write(self, oprot):
23947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23949 
      return
23950 
    oprot.writeStructBegin('getSettlementsByDate_args')
23951 
    if self.settlementDateFrom is not None:
23952 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23953 
      oprot.writeI64(self.settlementDateFrom)
23954 
      oprot.writeFieldEnd()
23955 
    if self.settlementDateTo is not None:
23956 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23957 
      oprot.writeI64(self.settlementDateTo)
23958 
      oprot.writeFieldEnd()
23959 
    if self.isRefund is not None:
23960 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23961 
      oprot.writeBool(self.isRefund)
23962 
      oprot.writeFieldEnd()
23963 
    oprot.writeFieldStop()
23964 
    oprot.writeStructEnd()
23965 
 
23966 
  def validate(self):
23967 
    return
23968 
 
23969 
 
23970 
  def __repr__(self):
23971 
    L = ['%s=%r' % (key, value)
23972 
      for key, value in self.__dict__.iteritems()]
23973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23974 
 
23975 
  def __eq__(self, other):
23976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23977 
 
23978 
  def __ne__(self, other):
23979 
    return not (self == other)
23980 
 
23981 
class getSettlementsByDate_result:
23982 
  """
23983 
  Attributes:
23984 
   - success
23985 
   - ex
23986 
  """
23987 
 
23988 
  thrift_spec = (
23989 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23990 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23991 
  )
23992 
 
23993 
  def __init__(self, success=None, ex=None,):
23994 
    self.success = success
23995 
    self.ex = ex
23996 
 
23997 
  def read(self, iprot):
23998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24000 
      return
24001 
    iprot.readStructBegin()
24002 
    while True:
24003 
      (fname, ftype, fid) = iprot.readFieldBegin()
24004 
      if ftype == TType.STOP:
24005 
        break
24006 
      if fid == 0:
24007 
        if ftype == TType.LIST:
24008 
          self.success = []
6188 rajveer 24009 
          (_etype566, _size563) = iprot.readListBegin()
24010 
          for _i567 in xrange(_size563):
24011 
            _elem568 = PaymentSettlement()
24012 
            _elem568.read(iprot)
24013 
            self.success.append(_elem568)
4715 varun.gupt 24014 
          iprot.readListEnd()
24015 
        else:
24016 
          iprot.skip(ftype)
24017 
      elif fid == 1:
24018 
        if ftype == TType.STRUCT:
24019 
          self.ex = TransactionServiceException()
24020 
          self.ex.read(iprot)
24021 
        else:
24022 
          iprot.skip(ftype)
24023 
      else:
24024 
        iprot.skip(ftype)
24025 
      iprot.readFieldEnd()
24026 
    iprot.readStructEnd()
24027 
 
24028 
  def write(self, oprot):
24029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24031 
      return
24032 
    oprot.writeStructBegin('getSettlementsByDate_result')
24033 
    if self.success is not None:
24034 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24035 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24036 
      for iter569 in self.success:
24037 
        iter569.write(oprot)
4715 varun.gupt 24038 
      oprot.writeListEnd()
24039 
      oprot.writeFieldEnd()
24040 
    if self.ex is not None:
24041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24042 
      self.ex.write(oprot)
24043 
      oprot.writeFieldEnd()
24044 
    oprot.writeFieldStop()
24045 
    oprot.writeStructEnd()
24046 
 
24047 
  def validate(self):
24048 
    return
24049 
 
24050 
 
24051 
  def __repr__(self):
24052 
    L = ['%s=%r' % (key, value)
24053 
      for key, value in self.__dict__.iteritems()]
24054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24055 
 
24056 
  def __eq__(self, other):
24057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24058 
 
24059 
  def __ne__(self, other):
24060 
    return not (self == other)
24061 
 
24062 
class getReshippedOrderIds_args:
24063 
  """
24064 
  Attributes:
24065 
   - orderIds
24066 
  """
24067 
 
24068 
  thrift_spec = (
24069 
    None, # 0
24070 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24071 
  )
24072 
 
24073 
  def __init__(self, orderIds=None,):
24074 
    self.orderIds = orderIds
24075 
 
24076 
  def read(self, iprot):
24077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24079 
      return
24080 
    iprot.readStructBegin()
24081 
    while True:
24082 
      (fname, ftype, fid) = iprot.readFieldBegin()
24083 
      if ftype == TType.STOP:
24084 
        break
24085 
      if fid == 1:
24086 
        if ftype == TType.LIST:
24087 
          self.orderIds = []
6188 rajveer 24088 
          (_etype573, _size570) = iprot.readListBegin()
24089 
          for _i574 in xrange(_size570):
24090 
            _elem575 = iprot.readI64();
24091 
            self.orderIds.append(_elem575)
4715 varun.gupt 24092 
          iprot.readListEnd()
24093 
        else:
24094 
          iprot.skip(ftype)
24095 
      else:
24096 
        iprot.skip(ftype)
24097 
      iprot.readFieldEnd()
24098 
    iprot.readStructEnd()
24099 
 
24100 
  def write(self, oprot):
24101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24103 
      return
24104 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24105 
    if self.orderIds is not None:
24106 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24107 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24108 
      for iter576 in self.orderIds:
24109 
        oprot.writeI64(iter576)
4715 varun.gupt 24110 
      oprot.writeListEnd()
24111 
      oprot.writeFieldEnd()
24112 
    oprot.writeFieldStop()
24113 
    oprot.writeStructEnd()
24114 
 
24115 
  def validate(self):
24116 
    return
24117 
 
24118 
 
24119 
  def __repr__(self):
24120 
    L = ['%s=%r' % (key, value)
24121 
      for key, value in self.__dict__.iteritems()]
24122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24123 
 
24124 
  def __eq__(self, other):
24125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24126 
 
24127 
  def __ne__(self, other):
24128 
    return not (self == other)
24129 
 
24130 
class getReshippedOrderIds_result:
24131 
  """
24132 
  Attributes:
24133 
   - success
24134 
   - ex
24135 
  """
24136 
 
24137 
  thrift_spec = (
24138 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24139 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24140 
  )
24141 
 
24142 
  def __init__(self, success=None, ex=None,):
24143 
    self.success = success
24144 
    self.ex = ex
24145 
 
24146 
  def read(self, iprot):
24147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24149 
      return
24150 
    iprot.readStructBegin()
24151 
    while True:
24152 
      (fname, ftype, fid) = iprot.readFieldBegin()
24153 
      if ftype == TType.STOP:
24154 
        break
24155 
      if fid == 0:
24156 
        if ftype == TType.LIST:
24157 
          self.success = []
6188 rajveer 24158 
          (_etype580, _size577) = iprot.readListBegin()
24159 
          for _i581 in xrange(_size577):
24160 
            _elem582 = iprot.readI64();
24161 
            self.success.append(_elem582)
4715 varun.gupt 24162 
          iprot.readListEnd()
24163 
        else:
24164 
          iprot.skip(ftype)
24165 
      elif fid == 1:
24166 
        if ftype == TType.STRUCT:
24167 
          self.ex = TransactionServiceException()
24168 
          self.ex.read(iprot)
24169 
        else:
24170 
          iprot.skip(ftype)
24171 
      else:
24172 
        iprot.skip(ftype)
24173 
      iprot.readFieldEnd()
24174 
    iprot.readStructEnd()
24175 
 
24176 
  def write(self, oprot):
24177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24179 
      return
24180 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24181 
    if self.success is not None:
24182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24183 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24184 
      for iter583 in self.success:
24185 
        oprot.writeI64(iter583)
4715 varun.gupt 24186 
      oprot.writeListEnd()
24187 
      oprot.writeFieldEnd()
24188 
    if self.ex is not None:
24189 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24190 
      self.ex.write(oprot)
24191 
      oprot.writeFieldEnd()
24192 
    oprot.writeFieldStop()
24193 
    oprot.writeStructEnd()
24194 
 
24195 
  def validate(self):
24196 
    return
24197 
 
24198 
 
24199 
  def __repr__(self):
24200 
    L = ['%s=%r' % (key, value)
24201 
      for key, value in self.__dict__.iteritems()]
24202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24203 
 
24204 
  def __eq__(self, other):
24205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24206 
 
24207 
  def __ne__(self, other):
24208 
    return not (self == other)
4757 mandeep.dh 24209 
 
5481 phani.kuma 24210 
class getBilledOrders_args:
4875 varun.gupt 24211 
  """
24212 
  Attributes:
24213 
   - vendorId
5481 phani.kuma 24214 
   - onlyVendorNotPaid
24215 
   - billingDateFrom
24216 
   - billingDateTo
4875 varun.gupt 24217 
  """
24218 
 
24219 
  thrift_spec = (
24220 
    None, # 0
24221 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24222 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24223 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24224 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24225 
  )
24226 
 
5481 phani.kuma 24227 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24228 
    self.vendorId = vendorId
5481 phani.kuma 24229 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24230 
    self.billingDateFrom = billingDateFrom
24231 
    self.billingDateTo = billingDateTo
4875 varun.gupt 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 == 1:
24243 
        if ftype == TType.I64:
24244 
          self.vendorId = iprot.readI64();
24245 
        else:
24246 
          iprot.skip(ftype)
5481 phani.kuma 24247 
      elif fid == 2:
24248 
        if ftype == TType.BOOL:
24249 
          self.onlyVendorNotPaid = iprot.readBool();
24250 
        else:
24251 
          iprot.skip(ftype)
24252 
      elif fid == 3:
24253 
        if ftype == TType.I64:
24254 
          self.billingDateFrom = iprot.readI64();
24255 
        else:
24256 
          iprot.skip(ftype)
24257 
      elif fid == 4:
24258 
        if ftype == TType.I64:
24259 
          self.billingDateTo = iprot.readI64();
24260 
        else:
24261 
          iprot.skip(ftype)
4875 varun.gupt 24262 
      else:
24263 
        iprot.skip(ftype)
24264 
      iprot.readFieldEnd()
24265 
    iprot.readStructEnd()
24266 
 
24267 
  def write(self, oprot):
24268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24270 
      return
5481 phani.kuma 24271 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24272 
    if self.vendorId is not None:
24273 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24274 
      oprot.writeI64(self.vendorId)
24275 
      oprot.writeFieldEnd()
5481 phani.kuma 24276 
    if self.onlyVendorNotPaid is not None:
24277 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24278 
      oprot.writeBool(self.onlyVendorNotPaid)
24279 
      oprot.writeFieldEnd()
24280 
    if self.billingDateFrom is not None:
24281 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24282 
      oprot.writeI64(self.billingDateFrom)
24283 
      oprot.writeFieldEnd()
24284 
    if self.billingDateTo is not None:
24285 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24286 
      oprot.writeI64(self.billingDateTo)
24287 
      oprot.writeFieldEnd()
4875 varun.gupt 24288 
    oprot.writeFieldStop()
24289 
    oprot.writeStructEnd()
24290 
 
24291 
  def validate(self):
24292 
    return
24293 
 
24294 
 
24295 
  def __repr__(self):
24296 
    L = ['%s=%r' % (key, value)
24297 
      for key, value in self.__dict__.iteritems()]
24298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24299 
 
24300 
  def __eq__(self, other):
24301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24302 
 
24303 
  def __ne__(self, other):
24304 
    return not (self == other)
24305 
 
5481 phani.kuma 24306 
class getBilledOrders_result:
4875 varun.gupt 24307 
  """
24308 
  Attributes:
24309 
   - success
24310 
   - ex
24311 
  """
24312 
 
24313 
  thrift_spec = (
24314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24315 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24316 
  )
24317 
 
24318 
  def __init__(self, success=None, ex=None,):
24319 
    self.success = success
24320 
    self.ex = ex
24321 
 
24322 
  def read(self, iprot):
24323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24325 
      return
24326 
    iprot.readStructBegin()
24327 
    while True:
24328 
      (fname, ftype, fid) = iprot.readFieldBegin()
24329 
      if ftype == TType.STOP:
24330 
        break
24331 
      if fid == 0:
24332 
        if ftype == TType.LIST:
24333 
          self.success = []
6188 rajveer 24334 
          (_etype587, _size584) = iprot.readListBegin()
24335 
          for _i588 in xrange(_size584):
24336 
            _elem589 = Order()
24337 
            _elem589.read(iprot)
24338 
            self.success.append(_elem589)
4875 varun.gupt 24339 
          iprot.readListEnd()
24340 
        else:
24341 
          iprot.skip(ftype)
24342 
      elif fid == 1:
24343 
        if ftype == TType.STRUCT:
24344 
          self.ex = TransactionServiceException()
24345 
          self.ex.read(iprot)
24346 
        else:
24347 
          iprot.skip(ftype)
24348 
      else:
24349 
        iprot.skip(ftype)
24350 
      iprot.readFieldEnd()
24351 
    iprot.readStructEnd()
24352 
 
24353 
  def write(self, oprot):
24354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24356 
      return
5481 phani.kuma 24357 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24358 
    if self.success is not None:
24359 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24360 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24361 
      for iter590 in self.success:
24362 
        iter590.write(oprot)
4875 varun.gupt 24363 
      oprot.writeListEnd()
24364 
      oprot.writeFieldEnd()
24365 
    if self.ex is not None:
24366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24367 
      self.ex.write(oprot)
24368 
      oprot.writeFieldEnd()
24369 
    oprot.writeFieldStop()
24370 
    oprot.writeStructEnd()
24371 
 
24372 
  def validate(self):
24373 
    return
24374 
 
24375 
 
24376 
  def __repr__(self):
24377 
    L = ['%s=%r' % (key, value)
24378 
      for key, value in self.__dict__.iteritems()]
24379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24380 
 
24381 
  def __eq__(self, other):
24382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24383 
 
24384 
  def __ne__(self, other):
24385 
    return not (self == other)
5031 varun.gupt 24386 
 
24387 
class getStatusDistributionOfOrders_args:
24388 
  """
24389 
  Attributes:
24390 
   - startDate
24391 
   - endDate
24392 
  """
24393 
 
24394 
  thrift_spec = (
24395 
    None, # 0
24396 
    (1, TType.I64, 'startDate', None, None, ), # 1
24397 
    (2, TType.I64, 'endDate', None, None, ), # 2
24398 
  )
24399 
 
24400 
  def __init__(self, startDate=None, endDate=None,):
24401 
    self.startDate = startDate
24402 
    self.endDate = endDate
24403 
 
24404 
  def read(self, iprot):
24405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24407 
      return
24408 
    iprot.readStructBegin()
24409 
    while True:
24410 
      (fname, ftype, fid) = iprot.readFieldBegin()
24411 
      if ftype == TType.STOP:
24412 
        break
24413 
      if fid == 1:
24414 
        if ftype == TType.I64:
24415 
          self.startDate = iprot.readI64();
24416 
        else:
24417 
          iprot.skip(ftype)
24418 
      elif fid == 2:
24419 
        if ftype == TType.I64:
24420 
          self.endDate = iprot.readI64();
24421 
        else:
24422 
          iprot.skip(ftype)
24423 
      else:
24424 
        iprot.skip(ftype)
24425 
      iprot.readFieldEnd()
24426 
    iprot.readStructEnd()
24427 
 
24428 
  def write(self, oprot):
24429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24431 
      return
24432 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24433 
    if self.startDate is not None:
24434 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24435 
      oprot.writeI64(self.startDate)
24436 
      oprot.writeFieldEnd()
24437 
    if self.endDate is not None:
24438 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24439 
      oprot.writeI64(self.endDate)
24440 
      oprot.writeFieldEnd()
24441 
    oprot.writeFieldStop()
24442 
    oprot.writeStructEnd()
24443 
 
24444 
  def validate(self):
24445 
    return
24446 
 
24447 
 
24448 
  def __repr__(self):
24449 
    L = ['%s=%r' % (key, value)
24450 
      for key, value in self.__dict__.iteritems()]
24451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24452 
 
24453 
  def __eq__(self, other):
24454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24455 
 
24456 
  def __ne__(self, other):
24457 
    return not (self == other)
24458 
 
24459 
class getStatusDistributionOfOrders_result:
24460 
  """
24461 
  Attributes:
24462 
   - success
24463 
   - ex
24464 
  """
24465 
 
24466 
  thrift_spec = (
24467 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24469 
  )
24470 
 
24471 
  def __init__(self, success=None, ex=None,):
24472 
    self.success = success
24473 
    self.ex = ex
24474 
 
24475 
  def read(self, iprot):
24476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24478 
      return
24479 
    iprot.readStructBegin()
24480 
    while True:
24481 
      (fname, ftype, fid) = iprot.readFieldBegin()
24482 
      if ftype == TType.STOP:
24483 
        break
24484 
      if fid == 0:
24485 
        if ftype == TType.MAP:
24486 
          self.success = {}
6188 rajveer 24487 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24488 
          for _i595 in xrange(_size591):
24489 
            _key596 = iprot.readI64();
24490 
            _val597 = iprot.readI64();
24491 
            self.success[_key596] = _val597
5031 varun.gupt 24492 
          iprot.readMapEnd()
24493 
        else:
24494 
          iprot.skip(ftype)
24495 
      elif fid == 1:
24496 
        if ftype == TType.STRUCT:
24497 
          self.ex = TransactionServiceException()
24498 
          self.ex.read(iprot)
24499 
        else:
24500 
          iprot.skip(ftype)
24501 
      else:
24502 
        iprot.skip(ftype)
24503 
      iprot.readFieldEnd()
24504 
    iprot.readStructEnd()
24505 
 
24506 
  def write(self, oprot):
24507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24509 
      return
24510 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24511 
    if self.success is not None:
24512 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24513 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24514 
      for kiter598,viter599 in self.success.items():
24515 
        oprot.writeI64(kiter598)
24516 
        oprot.writeI64(viter599)
5031 varun.gupt 24517 
      oprot.writeMapEnd()
24518 
      oprot.writeFieldEnd()
24519 
    if self.ex is not None:
24520 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24521 
      self.ex.write(oprot)
24522 
      oprot.writeFieldEnd()
24523 
    oprot.writeFieldStop()
24524 
    oprot.writeStructEnd()
24525 
 
24526 
  def validate(self):
24527 
    return
24528 
 
24529 
 
24530 
  def __repr__(self):
24531 
    L = ['%s=%r' % (key, value)
24532 
      for key, value in self.__dict__.iteritems()]
24533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24534 
 
24535 
  def __eq__(self, other):
24536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24537 
 
24538 
  def __ne__(self, other):
24539 
    return not (self == other)
5067 varun.gupt 24540 
 
24541 
class getOrderIdsForStatus_args:
24542 
  """
24543 
  Attributes:
24544 
   - status
24545 
   - startDatetime
24546 
   - endDatetime
24547 
  """
24548 
 
24549 
  thrift_spec = (
24550 
    None, # 0
24551 
    (1, TType.I64, 'status', None, None, ), # 1
24552 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24553 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24554 
  )
24555 
 
24556 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24557 
    self.status = status
24558 
    self.startDatetime = startDatetime
24559 
    self.endDatetime = endDatetime
24560 
 
24561 
  def read(self, iprot):
24562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24564 
      return
24565 
    iprot.readStructBegin()
24566 
    while True:
24567 
      (fname, ftype, fid) = iprot.readFieldBegin()
24568 
      if ftype == TType.STOP:
24569 
        break
24570 
      if fid == 1:
24571 
        if ftype == TType.I64:
24572 
          self.status = iprot.readI64();
24573 
        else:
24574 
          iprot.skip(ftype)
24575 
      elif fid == 2:
24576 
        if ftype == TType.I64:
24577 
          self.startDatetime = iprot.readI64();
24578 
        else:
24579 
          iprot.skip(ftype)
24580 
      elif fid == 3:
24581 
        if ftype == TType.I64:
24582 
          self.endDatetime = iprot.readI64();
24583 
        else:
24584 
          iprot.skip(ftype)
24585 
      else:
24586 
        iprot.skip(ftype)
24587 
      iprot.readFieldEnd()
24588 
    iprot.readStructEnd()
24589 
 
24590 
  def write(self, oprot):
24591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24593 
      return
24594 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24595 
    if self.status is not None:
24596 
      oprot.writeFieldBegin('status', TType.I64, 1)
24597 
      oprot.writeI64(self.status)
24598 
      oprot.writeFieldEnd()
24599 
    if self.startDatetime is not None:
24600 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24601 
      oprot.writeI64(self.startDatetime)
24602 
      oprot.writeFieldEnd()
24603 
    if self.endDatetime is not None:
24604 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24605 
      oprot.writeI64(self.endDatetime)
24606 
      oprot.writeFieldEnd()
24607 
    oprot.writeFieldStop()
24608 
    oprot.writeStructEnd()
24609 
 
24610 
  def validate(self):
24611 
    return
24612 
 
24613 
 
24614 
  def __repr__(self):
24615 
    L = ['%s=%r' % (key, value)
24616 
      for key, value in self.__dict__.iteritems()]
24617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24618 
 
24619 
  def __eq__(self, other):
24620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24621 
 
24622 
  def __ne__(self, other):
24623 
    return not (self == other)
24624 
 
24625 
class getOrderIdsForStatus_result:
24626 
  """
24627 
  Attributes:
24628 
   - success
24629 
   - ex
24630 
  """
24631 
 
24632 
  thrift_spec = (
24633 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24634 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24635 
  )
24636 
 
24637 
  def __init__(self, success=None, ex=None,):
24638 
    self.success = success
24639 
    self.ex = ex
24640 
 
24641 
  def read(self, iprot):
24642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24644 
      return
24645 
    iprot.readStructBegin()
24646 
    while True:
24647 
      (fname, ftype, fid) = iprot.readFieldBegin()
24648 
      if ftype == TType.STOP:
24649 
        break
24650 
      if fid == 0:
24651 
        if ftype == TType.LIST:
24652 
          self.success = []
6188 rajveer 24653 
          (_etype603, _size600) = iprot.readListBegin()
24654 
          for _i604 in xrange(_size600):
24655 
            _elem605 = iprot.readI64();
24656 
            self.success.append(_elem605)
5067 varun.gupt 24657 
          iprot.readListEnd()
24658 
        else:
24659 
          iprot.skip(ftype)
24660 
      elif fid == 1:
24661 
        if ftype == TType.STRUCT:
24662 
          self.ex = TransactionServiceException()
24663 
          self.ex.read(iprot)
24664 
        else:
24665 
          iprot.skip(ftype)
24666 
      else:
24667 
        iprot.skip(ftype)
24668 
      iprot.readFieldEnd()
24669 
    iprot.readStructEnd()
24670 
 
24671 
  def write(self, oprot):
24672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24674 
      return
24675 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24676 
    if self.success is not None:
24677 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24678 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24679 
      for iter606 in self.success:
24680 
        oprot.writeI64(iter606)
5067 varun.gupt 24681 
      oprot.writeListEnd()
24682 
      oprot.writeFieldEnd()
24683 
    if self.ex is not None:
24684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24685 
      self.ex.write(oprot)
24686 
      oprot.writeFieldEnd()
24687 
    oprot.writeFieldStop()
24688 
    oprot.writeStructEnd()
24689 
 
24690 
  def validate(self):
24691 
    return
24692 
 
24693 
 
24694 
  def __repr__(self):
24695 
    L = ['%s=%r' % (key, value)
24696 
      for key, value in self.__dict__.iteritems()]
24697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24698 
 
24699 
  def __eq__(self, other):
24700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24701 
 
24702 
  def __ne__(self, other):
24703 
    return not (self == other)
5099 varun.gupt 24704 
 
5348 anupam.sin 24705 
class updateCODAgent_args:
24706 
  """
24707 
  Attributes:
24708 
   - agent
24709 
   - orderId
24710 
  """
24711 
 
24712 
  thrift_spec = (
24713 
    None, # 0
24714 
    (1, TType.STRING, 'agent', None, None, ), # 1
24715 
    (2, TType.I64, 'orderId', None, None, ), # 2
24716 
  )
24717 
 
24718 
  def __init__(self, agent=None, orderId=None,):
24719 
    self.agent = agent
24720 
    self.orderId = orderId
24721 
 
24722 
  def read(self, iprot):
24723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24725 
      return
24726 
    iprot.readStructBegin()
24727 
    while True:
24728 
      (fname, ftype, fid) = iprot.readFieldBegin()
24729 
      if ftype == TType.STOP:
24730 
        break
24731 
      if fid == 1:
24732 
        if ftype == TType.STRING:
24733 
          self.agent = iprot.readString();
24734 
        else:
24735 
          iprot.skip(ftype)
24736 
      elif fid == 2:
24737 
        if ftype == TType.I64:
24738 
          self.orderId = iprot.readI64();
24739 
        else:
24740 
          iprot.skip(ftype)
24741 
      else:
24742 
        iprot.skip(ftype)
24743 
      iprot.readFieldEnd()
24744 
    iprot.readStructEnd()
24745 
 
24746 
  def write(self, oprot):
24747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24749 
      return
24750 
    oprot.writeStructBegin('updateCODAgent_args')
24751 
    if self.agent is not None:
24752 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24753 
      oprot.writeString(self.agent)
24754 
      oprot.writeFieldEnd()
24755 
    if self.orderId is not None:
24756 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24757 
      oprot.writeI64(self.orderId)
24758 
      oprot.writeFieldEnd()
24759 
    oprot.writeFieldStop()
24760 
    oprot.writeStructEnd()
24761 
 
24762 
  def validate(self):
24763 
    return
24764 
 
24765 
 
24766 
  def __repr__(self):
24767 
    L = ['%s=%r' % (key, value)
24768 
      for key, value in self.__dict__.iteritems()]
24769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24770 
 
24771 
  def __eq__(self, other):
24772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24773 
 
24774 
  def __ne__(self, other):
24775 
    return not (self == other)
24776 
 
24777 
class updateCODAgent_result:
24778 
  """
24779 
  Attributes:
24780 
   - ex
24781 
  """
24782 
 
24783 
  thrift_spec = (
24784 
    None, # 0
24785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24786 
  )
24787 
 
24788 
  def __init__(self, ex=None,):
24789 
    self.ex = ex
24790 
 
24791 
  def read(self, iprot):
24792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24794 
      return
24795 
    iprot.readStructBegin()
24796 
    while True:
24797 
      (fname, ftype, fid) = iprot.readFieldBegin()
24798 
      if ftype == TType.STOP:
24799 
        break
24800 
      if fid == 1:
24801 
        if ftype == TType.STRUCT:
24802 
          self.ex = TransactionServiceException()
24803 
          self.ex.read(iprot)
24804 
        else:
24805 
          iprot.skip(ftype)
24806 
      else:
24807 
        iprot.skip(ftype)
24808 
      iprot.readFieldEnd()
24809 
    iprot.readStructEnd()
24810 
 
24811 
  def write(self, oprot):
24812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24814 
      return
24815 
    oprot.writeStructBegin('updateCODAgent_result')
24816 
    if self.ex is not None:
24817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24818 
      self.ex.write(oprot)
24819 
      oprot.writeFieldEnd()
24820 
    oprot.writeFieldStop()
24821 
    oprot.writeStructEnd()
24822 
 
24823 
  def validate(self):
24824 
    return
24825 
 
24826 
 
24827 
  def __repr__(self):
24828 
    L = ['%s=%r' % (key, value)
24829 
      for key, value in self.__dict__.iteritems()]
24830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24831 
 
24832 
  def __eq__(self, other):
24833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24834 
 
24835 
  def __ne__(self, other):
24836 
    return not (self == other)
24837 
 
5099 varun.gupt 24838 
class updateOrderAsPaidToVendor_args:
24839 
  """
24840 
  Attributes:
24841 
   - orderId
24842 
  """
24843 
 
24844 
  thrift_spec = (
24845 
    None, # 0
24846 
    (1, TType.I64, 'orderId', None, None, ), # 1
24847 
  )
24848 
 
24849 
  def __init__(self, orderId=None,):
24850 
    self.orderId = orderId
24851 
 
24852 
  def read(self, iprot):
24853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24855 
      return
24856 
    iprot.readStructBegin()
24857 
    while True:
24858 
      (fname, ftype, fid) = iprot.readFieldBegin()
24859 
      if ftype == TType.STOP:
24860 
        break
24861 
      if fid == 1:
24862 
        if ftype == TType.I64:
24863 
          self.orderId = iprot.readI64();
24864 
        else:
24865 
          iprot.skip(ftype)
24866 
      else:
24867 
        iprot.skip(ftype)
24868 
      iprot.readFieldEnd()
24869 
    iprot.readStructEnd()
24870 
 
24871 
  def write(self, oprot):
24872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24874 
      return
24875 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24876 
    if self.orderId is not None:
24877 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24878 
      oprot.writeI64(self.orderId)
24879 
      oprot.writeFieldEnd()
24880 
    oprot.writeFieldStop()
24881 
    oprot.writeStructEnd()
24882 
 
24883 
  def validate(self):
24884 
    return
24885 
 
24886 
 
24887 
  def __repr__(self):
24888 
    L = ['%s=%r' % (key, value)
24889 
      for key, value in self.__dict__.iteritems()]
24890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24891 
 
24892 
  def __eq__(self, other):
24893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24894 
 
24895 
  def __ne__(self, other):
24896 
    return not (self == other)
24897 
 
24898 
class updateOrderAsPaidToVendor_result:
24899 
  """
24900 
  Attributes:
24901 
   - ex
24902 
  """
24903 
 
24904 
  thrift_spec = (
24905 
    None, # 0
24906 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24907 
  )
24908 
 
24909 
  def __init__(self, ex=None,):
24910 
    self.ex = ex
24911 
 
24912 
  def read(self, iprot):
24913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24915 
      return
24916 
    iprot.readStructBegin()
24917 
    while True:
24918 
      (fname, ftype, fid) = iprot.readFieldBegin()
24919 
      if ftype == TType.STOP:
24920 
        break
24921 
      if fid == 1:
24922 
        if ftype == TType.STRUCT:
24923 
          self.ex = TransactionServiceException()
24924 
          self.ex.read(iprot)
24925 
        else:
24926 
          iprot.skip(ftype)
24927 
      else:
24928 
        iprot.skip(ftype)
24929 
      iprot.readFieldEnd()
24930 
    iprot.readStructEnd()
24931 
 
24932 
  def write(self, oprot):
24933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24935 
      return
24936 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24937 
    if self.ex is not None:
24938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24939 
      self.ex.write(oprot)
24940 
      oprot.writeFieldEnd()
24941 
    oprot.writeFieldStop()
24942 
    oprot.writeStructEnd()
24943 
 
24944 
  def validate(self):
24945 
    return
24946 
 
24947 
 
24948 
  def __repr__(self):
24949 
    L = ['%s=%r' % (key, value)
24950 
      for key, value in self.__dict__.iteritems()]
24951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24952 
 
24953 
  def __eq__(self, other):
24954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24955 
 
24956 
  def __ne__(self, other):
24957 
    return not (self == other)
5208 varun.gupt 24958 
 
5386 phani.kuma 24959 
class updateOrderOnlyAsPaidToVendor_args:
24960 
  """
24961 
  Attributes:
24962 
   - orderId
24963 
  """
24964 
 
24965 
  thrift_spec = (
24966 
    None, # 0
24967 
    (1, TType.I64, 'orderId', None, None, ), # 1
24968 
  )
24969 
 
24970 
  def __init__(self, orderId=None,):
24971 
    self.orderId = orderId
24972 
 
24973 
  def read(self, iprot):
24974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24976 
      return
24977 
    iprot.readStructBegin()
24978 
    while True:
24979 
      (fname, ftype, fid) = iprot.readFieldBegin()
24980 
      if ftype == TType.STOP:
24981 
        break
24982 
      if fid == 1:
24983 
        if ftype == TType.I64:
24984 
          self.orderId = iprot.readI64();
24985 
        else:
24986 
          iprot.skip(ftype)
24987 
      else:
24988 
        iprot.skip(ftype)
24989 
      iprot.readFieldEnd()
24990 
    iprot.readStructEnd()
24991 
 
24992 
  def write(self, oprot):
24993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24995 
      return
24996 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24997 
    if self.orderId is not None:
24998 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24999 
      oprot.writeI64(self.orderId)
25000 
      oprot.writeFieldEnd()
25001 
    oprot.writeFieldStop()
25002 
    oprot.writeStructEnd()
25003 
 
25004 
  def validate(self):
25005 
    return
25006 
 
25007 
 
25008 
  def __repr__(self):
25009 
    L = ['%s=%r' % (key, value)
25010 
      for key, value in self.__dict__.iteritems()]
25011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25012 
 
25013 
  def __eq__(self, other):
25014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25015 
 
25016 
  def __ne__(self, other):
25017 
    return not (self == other)
25018 
 
25019 
class updateOrderOnlyAsPaidToVendor_result:
25020 
  """
25021 
  Attributes:
25022 
   - ex
25023 
  """
25024 
 
25025 
  thrift_spec = (
25026 
    None, # 0
25027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25028 
  )
25029 
 
25030 
  def __init__(self, ex=None,):
25031 
    self.ex = ex
25032 
 
25033 
  def read(self, iprot):
25034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25036 
      return
25037 
    iprot.readStructBegin()
25038 
    while True:
25039 
      (fname, ftype, fid) = iprot.readFieldBegin()
25040 
      if ftype == TType.STOP:
25041 
        break
25042 
      if fid == 1:
25043 
        if ftype == TType.STRUCT:
25044 
          self.ex = TransactionServiceException()
25045 
          self.ex.read(iprot)
25046 
        else:
25047 
          iprot.skip(ftype)
25048 
      else:
25049 
        iprot.skip(ftype)
25050 
      iprot.readFieldEnd()
25051 
    iprot.readStructEnd()
25052 
 
25053 
  def write(self, oprot):
25054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25056 
      return
25057 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25058 
    if self.ex is not None:
25059 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25060 
      self.ex.write(oprot)
25061 
      oprot.writeFieldEnd()
25062 
    oprot.writeFieldStop()
25063 
    oprot.writeStructEnd()
25064 
 
25065 
  def validate(self):
25066 
    return
25067 
 
25068 
 
25069 
  def __repr__(self):
25070 
    L = ['%s=%r' % (key, value)
25071 
      for key, value in self.__dict__.iteritems()]
25072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25073 
 
25074 
  def __eq__(self, other):
25075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25076 
 
25077 
  def __ne__(self, other):
25078 
    return not (self == other)
25079 
 
5208 varun.gupt 25080 
class getRefundedOrdersMarkedPaid_args:
25081 
 
25082 
  thrift_spec = (
25083 
  )
25084 
 
25085 
  def read(self, iprot):
25086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25088 
      return
25089 
    iprot.readStructBegin()
25090 
    while True:
25091 
      (fname, ftype, fid) = iprot.readFieldBegin()
25092 
      if ftype == TType.STOP:
25093 
        break
25094 
      else:
25095 
        iprot.skip(ftype)
25096 
      iprot.readFieldEnd()
25097 
    iprot.readStructEnd()
25098 
 
25099 
  def write(self, oprot):
25100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25102 
      return
25103 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25104 
    oprot.writeFieldStop()
25105 
    oprot.writeStructEnd()
25106 
 
25107 
  def validate(self):
25108 
    return
25109 
 
25110 
 
25111 
  def __repr__(self):
25112 
    L = ['%s=%r' % (key, value)
25113 
      for key, value in self.__dict__.iteritems()]
25114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25115 
 
25116 
  def __eq__(self, other):
25117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25118 
 
25119 
  def __ne__(self, other):
25120 
    return not (self == other)
25121 
 
25122 
class getRefundedOrdersMarkedPaid_result:
25123 
  """
25124 
  Attributes:
25125 
   - success
25126 
   - ex
25127 
  """
25128 
 
25129 
  thrift_spec = (
25130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25132 
  )
25133 
 
25134 
  def __init__(self, success=None, ex=None,):
25135 
    self.success = success
25136 
    self.ex = ex
25137 
 
25138 
  def read(self, iprot):
25139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25141 
      return
25142 
    iprot.readStructBegin()
25143 
    while True:
25144 
      (fname, ftype, fid) = iprot.readFieldBegin()
25145 
      if ftype == TType.STOP:
25146 
        break
25147 
      if fid == 0:
25148 
        if ftype == TType.LIST:
25149 
          self.success = []
6188 rajveer 25150 
          (_etype610, _size607) = iprot.readListBegin()
25151 
          for _i611 in xrange(_size607):
25152 
            _elem612 = Order()
25153 
            _elem612.read(iprot)
25154 
            self.success.append(_elem612)
5208 varun.gupt 25155 
          iprot.readListEnd()
25156 
        else:
25157 
          iprot.skip(ftype)
25158 
      elif fid == 1:
25159 
        if ftype == TType.STRUCT:
25160 
          self.ex = TransactionServiceException()
25161 
          self.ex.read(iprot)
25162 
        else:
25163 
          iprot.skip(ftype)
25164 
      else:
25165 
        iprot.skip(ftype)
25166 
      iprot.readFieldEnd()
25167 
    iprot.readStructEnd()
25168 
 
25169 
  def write(self, oprot):
25170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25172 
      return
25173 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25174 
    if self.success is not None:
25175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25176 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25177 
      for iter613 in self.success:
25178 
        iter613.write(oprot)
5208 varun.gupt 25179 
      oprot.writeListEnd()
25180 
      oprot.writeFieldEnd()
25181 
    if self.ex is not None:
25182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25183 
      self.ex.write(oprot)
25184 
      oprot.writeFieldEnd()
25185 
    oprot.writeFieldStop()
25186 
    oprot.writeStructEnd()
25187 
 
25188 
  def validate(self):
25189 
    return
25190 
 
25191 
 
25192 
  def __repr__(self):
25193 
    L = ['%s=%r' % (key, value)
25194 
      for key, value in self.__dict__.iteritems()]
25195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25196 
 
25197 
  def __eq__(self, other):
25198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25199 
 
25200 
  def __ne__(self, other):
25201 
    return not (self == other)
5447 anupam.sin 25202 
 
25203 
class getAllVerificationAgents_args:
25204 
  """
25205 
  Attributes:
25206 
   - minOrderId
25207 
   - maxOrderId
25208 
  """
25209 
 
25210 
  thrift_spec = (
25211 
    None, # 0
25212 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25213 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25214 
  )
25215 
 
25216 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25217 
    self.minOrderId = minOrderId
25218 
    self.maxOrderId = maxOrderId
25219 
 
25220 
  def read(self, iprot):
25221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25223 
      return
25224 
    iprot.readStructBegin()
25225 
    while True:
25226 
      (fname, ftype, fid) = iprot.readFieldBegin()
25227 
      if ftype == TType.STOP:
25228 
        break
25229 
      if fid == 1:
25230 
        if ftype == TType.I64:
25231 
          self.minOrderId = iprot.readI64();
25232 
        else:
25233 
          iprot.skip(ftype)
25234 
      elif fid == 2:
25235 
        if ftype == TType.I64:
25236 
          self.maxOrderId = iprot.readI64();
25237 
        else:
25238 
          iprot.skip(ftype)
25239 
      else:
25240 
        iprot.skip(ftype)
25241 
      iprot.readFieldEnd()
25242 
    iprot.readStructEnd()
25243 
 
25244 
  def write(self, oprot):
25245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25247 
      return
25248 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25249 
    if self.minOrderId is not None:
25250 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25251 
      oprot.writeI64(self.minOrderId)
25252 
      oprot.writeFieldEnd()
25253 
    if self.maxOrderId is not None:
25254 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25255 
      oprot.writeI64(self.maxOrderId)
25256 
      oprot.writeFieldEnd()
25257 
    oprot.writeFieldStop()
25258 
    oprot.writeStructEnd()
25259 
 
25260 
  def validate(self):
25261 
    return
25262 
 
25263 
 
25264 
  def __repr__(self):
25265 
    L = ['%s=%r' % (key, value)
25266 
      for key, value in self.__dict__.iteritems()]
25267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25268 
 
25269 
  def __eq__(self, other):
25270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25271 
 
25272 
  def __ne__(self, other):
25273 
    return not (self == other)
25274 
 
25275 
class getAllVerificationAgents_result:
25276 
  """
25277 
  Attributes:
25278 
   - success
25279 
  """
25280 
 
25281 
  thrift_spec = (
25282 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25283 
  )
25284 
 
25285 
  def __init__(self, success=None,):
25286 
    self.success = success
25287 
 
25288 
  def read(self, iprot):
25289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25291 
      return
25292 
    iprot.readStructBegin()
25293 
    while True:
25294 
      (fname, ftype, fid) = iprot.readFieldBegin()
25295 
      if ftype == TType.STOP:
25296 
        break
25297 
      if fid == 0:
25298 
        if ftype == TType.LIST:
25299 
          self.success = []
6188 rajveer 25300 
          (_etype617, _size614) = iprot.readListBegin()
25301 
          for _i618 in xrange(_size614):
25302 
            _elem619 = CODVerificationAgent()
25303 
            _elem619.read(iprot)
25304 
            self.success.append(_elem619)
5447 anupam.sin 25305 
          iprot.readListEnd()
25306 
        else:
25307 
          iprot.skip(ftype)
25308 
      else:
25309 
        iprot.skip(ftype)
25310 
      iprot.readFieldEnd()
25311 
    iprot.readStructEnd()
25312 
 
25313 
  def write(self, oprot):
25314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25316 
      return
25317 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25318 
    if self.success is not None:
25319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25321 
      for iter620 in self.success:
25322 
        iter620.write(oprot)
5447 anupam.sin 25323 
      oprot.writeListEnd()
25324 
      oprot.writeFieldEnd()
25325 
    oprot.writeFieldStop()
25326 
    oprot.writeStructEnd()
25327 
 
25328 
  def validate(self):
25329 
    return
25330 
 
25331 
 
25332 
  def __repr__(self):
25333 
    L = ['%s=%r' % (key, value)
25334 
      for key, value in self.__dict__.iteritems()]
25335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25336 
 
25337 
  def __eq__(self, other):
25338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25339 
 
25340 
  def __ne__(self, other):
25341 
    return not (self == other)
5527 anupam.sin 25342 
 
25343 
class getAllAttributesForOrderId_args:
25344 
  """
25345 
  Attributes:
25346 
   - orderId
25347 
  """
25348 
 
25349 
  thrift_spec = (
25350 
    None, # 0
25351 
    (1, TType.I64, 'orderId', None, None, ), # 1
25352 
  )
25353 
 
25354 
  def __init__(self, orderId=None,):
25355 
    self.orderId = orderId
25356 
 
25357 
  def read(self, iprot):
25358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25360 
      return
25361 
    iprot.readStructBegin()
25362 
    while True:
25363 
      (fname, ftype, fid) = iprot.readFieldBegin()
25364 
      if ftype == TType.STOP:
25365 
        break
25366 
      if fid == 1:
25367 
        if ftype == TType.I64:
25368 
          self.orderId = iprot.readI64();
25369 
        else:
25370 
          iprot.skip(ftype)
25371 
      else:
25372 
        iprot.skip(ftype)
25373 
      iprot.readFieldEnd()
25374 
    iprot.readStructEnd()
25375 
 
25376 
  def write(self, oprot):
25377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25379 
      return
25380 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25381 
    if self.orderId is not None:
25382 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25383 
      oprot.writeI64(self.orderId)
25384 
      oprot.writeFieldEnd()
25385 
    oprot.writeFieldStop()
25386 
    oprot.writeStructEnd()
25387 
 
25388 
  def validate(self):
25389 
    return
25390 
 
25391 
 
25392 
  def __repr__(self):
25393 
    L = ['%s=%r' % (key, value)
25394 
      for key, value in self.__dict__.iteritems()]
25395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25396 
 
25397 
  def __eq__(self, other):
25398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25399 
 
25400 
  def __ne__(self, other):
25401 
    return not (self == other)
25402 
 
25403 
class getAllAttributesForOrderId_result:
25404 
  """
25405 
  Attributes:
25406 
   - success
25407 
  """
25408 
 
25409 
  thrift_spec = (
25410 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25411 
  )
25412 
 
25413 
  def __init__(self, success=None,):
25414 
    self.success = success
25415 
 
25416 
  def read(self, iprot):
25417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25419 
      return
25420 
    iprot.readStructBegin()
25421 
    while True:
25422 
      (fname, ftype, fid) = iprot.readFieldBegin()
25423 
      if ftype == TType.STOP:
25424 
        break
25425 
      if fid == 0:
25426 
        if ftype == TType.LIST:
25427 
          self.success = []
6188 rajveer 25428 
          (_etype624, _size621) = iprot.readListBegin()
25429 
          for _i625 in xrange(_size621):
25430 
            _elem626 = Attribute()
25431 
            _elem626.read(iprot)
25432 
            self.success.append(_elem626)
5527 anupam.sin 25433 
          iprot.readListEnd()
25434 
        else:
25435 
          iprot.skip(ftype)
25436 
      else:
25437 
        iprot.skip(ftype)
25438 
      iprot.readFieldEnd()
25439 
    iprot.readStructEnd()
25440 
 
25441 
  def write(self, oprot):
25442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25444 
      return
25445 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25446 
    if self.success is not None:
25447 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25448 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25449 
      for iter627 in self.success:
25450 
        iter627.write(oprot)
5527 anupam.sin 25451 
      oprot.writeListEnd()
25452 
      oprot.writeFieldEnd()
25453 
    oprot.writeFieldStop()
25454 
    oprot.writeStructEnd()
25455 
 
25456 
  def validate(self):
25457 
    return
25458 
 
25459 
 
25460 
  def __repr__(self):
25461 
    L = ['%s=%r' % (key, value)
25462 
      for key, value in self.__dict__.iteritems()]
25463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25464 
 
25465 
  def __eq__(self, other):
25466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25467 
 
25468 
  def __ne__(self, other):
25469 
    return not (self == other)
25470 
 
5676 rajveer 25471 
class setOrderAttributes_args:
25472 
  """
25473 
  Attributes:
25474 
   - orderId
25475 
   - attributes
25476 
  """
25477 
 
25478 
  thrift_spec = None
25479 
  def __init__(self, orderId=None, attributes=None,):
25480 
    self.orderId = orderId
25481 
    self.attributes = attributes
25482 
 
25483 
  def read(self, iprot):
25484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25486 
      return
25487 
    iprot.readStructBegin()
25488 
    while True:
25489 
      (fname, ftype, fid) = iprot.readFieldBegin()
25490 
      if ftype == TType.STOP:
25491 
        break
25492 
      if fid == 1:
25493 
        if ftype == TType.I64:
25494 
          self.orderId = iprot.readI64();
25495 
        else:
25496 
          iprot.skip(ftype)
25497 
      elif fid == -1:
25498 
        if ftype == TType.LIST:
25499 
          self.attributes = []
6188 rajveer 25500 
          (_etype631, _size628) = iprot.readListBegin()
25501 
          for _i632 in xrange(_size628):
25502 
            _elem633 = Attribute()
25503 
            _elem633.read(iprot)
25504 
            self.attributes.append(_elem633)
5676 rajveer 25505 
          iprot.readListEnd()
25506 
        else:
25507 
          iprot.skip(ftype)
25508 
      else:
25509 
        iprot.skip(ftype)
25510 
      iprot.readFieldEnd()
25511 
    iprot.readStructEnd()
25512 
 
25513 
  def write(self, oprot):
25514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25516 
      return
25517 
    oprot.writeStructBegin('setOrderAttributes_args')
25518 
    if self.attributes is not None:
25519 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25520 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25521 
      for iter634 in self.attributes:
25522 
        iter634.write(oprot)
5676 rajveer 25523 
      oprot.writeListEnd()
25524 
      oprot.writeFieldEnd()
25525 
    if self.orderId is not None:
25526 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25527 
      oprot.writeI64(self.orderId)
25528 
      oprot.writeFieldEnd()
25529 
    oprot.writeFieldStop()
25530 
    oprot.writeStructEnd()
25531 
 
25532 
  def validate(self):
25533 
    return
25534 
 
25535 
 
25536 
  def __repr__(self):
25537 
    L = ['%s=%r' % (key, value)
25538 
      for key, value in self.__dict__.iteritems()]
25539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25540 
 
25541 
  def __eq__(self, other):
25542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25543 
 
25544 
  def __ne__(self, other):
25545 
    return not (self == other)
25546 
 
25547 
class setOrderAttributes_result:
25548 
 
25549 
  thrift_spec = (
25550 
  )
25551 
 
25552 
  def read(self, iprot):
25553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25555 
      return
25556 
    iprot.readStructBegin()
25557 
    while True:
25558 
      (fname, ftype, fid) = iprot.readFieldBegin()
25559 
      if ftype == TType.STOP:
25560 
        break
25561 
      else:
25562 
        iprot.skip(ftype)
25563 
      iprot.readFieldEnd()
25564 
    iprot.readStructEnd()
25565 
 
25566 
  def write(self, oprot):
25567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25569 
      return
25570 
    oprot.writeStructBegin('setOrderAttributes_result')
25571 
    oprot.writeFieldStop()
25572 
    oprot.writeStructEnd()
25573 
 
25574 
  def validate(self):
25575 
    return
25576 
 
25577 
 
25578 
  def __repr__(self):
25579 
    L = ['%s=%r' % (key, value)
25580 
      for key, value in self.__dict__.iteritems()]
25581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25582 
 
25583 
  def __eq__(self, other):
25584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25585 
 
25586 
  def __ne__(self, other):
25587 
    return not (self == other)
25588 
 
5527 anupam.sin 25589 
class setOrderAttributeForTransaction_args:
25590 
  """
25591 
  Attributes:
25592 
   - transactionId
25593 
   - attribute
25594 
  """
25595 
 
25596 
  thrift_spec = None
25597 
  def __init__(self, transactionId=None, attribute=None,):
25598 
    self.transactionId = transactionId
25599 
    self.attribute = attribute
25600 
 
25601 
  def read(self, iprot):
25602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25604 
      return
25605 
    iprot.readStructBegin()
25606 
    while True:
25607 
      (fname, ftype, fid) = iprot.readFieldBegin()
25608 
      if ftype == TType.STOP:
25609 
        break
25610 
      if fid == 1:
25611 
        if ftype == TType.I64:
25612 
          self.transactionId = iprot.readI64();
25613 
        else:
25614 
          iprot.skip(ftype)
25615 
      elif fid == -1:
25616 
        if ftype == TType.STRUCT:
25617 
          self.attribute = Attribute()
25618 
          self.attribute.read(iprot)
25619 
        else:
25620 
          iprot.skip(ftype)
25621 
      else:
25622 
        iprot.skip(ftype)
25623 
      iprot.readFieldEnd()
25624 
    iprot.readStructEnd()
25625 
 
25626 
  def write(self, oprot):
25627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25629 
      return
25630 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25631 
    if self.attribute is not None:
25632 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25633 
      self.attribute.write(oprot)
25634 
      oprot.writeFieldEnd()
25635 
    if self.transactionId is not None:
25636 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25637 
      oprot.writeI64(self.transactionId)
25638 
      oprot.writeFieldEnd()
25639 
    oprot.writeFieldStop()
25640 
    oprot.writeStructEnd()
25641 
 
25642 
  def validate(self):
25643 
    return
25644 
 
25645 
 
25646 
  def __repr__(self):
25647 
    L = ['%s=%r' % (key, value)
25648 
      for key, value in self.__dict__.iteritems()]
25649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25650 
 
25651 
  def __eq__(self, other):
25652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25653 
 
25654 
  def __ne__(self, other):
25655 
    return not (self == other)
25656 
 
25657 
class setOrderAttributeForTransaction_result:
25658 
 
25659 
  thrift_spec = (
25660 
  )
25661 
 
25662 
  def read(self, iprot):
25663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25665 
      return
25666 
    iprot.readStructBegin()
25667 
    while True:
25668 
      (fname, ftype, fid) = iprot.readFieldBegin()
25669 
      if ftype == TType.STOP:
25670 
        break
25671 
      else:
25672 
        iprot.skip(ftype)
25673 
      iprot.readFieldEnd()
25674 
    iprot.readStructEnd()
25675 
 
25676 
  def write(self, oprot):
25677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25679 
      return
25680 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25681 
    oprot.writeFieldStop()
25682 
    oprot.writeStructEnd()
25683 
 
25684 
  def validate(self):
25685 
    return
25686 
 
25687 
 
25688 
  def __repr__(self):
25689 
    L = ['%s=%r' % (key, value)
25690 
      for key, value in self.__dict__.iteritems()]
25691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25692 
 
25693 
  def __eq__(self, other):
25694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25695 
 
25696 
  def __ne__(self, other):
25697 
    return not (self == other)
5553 rajveer 25698 
 
25699 
class getReceivePendingOrders_args:
25700 
  """
25701 
  Attributes:
25702 
   - storeId
25703 
  """
25704 
 
25705 
  thrift_spec = (
25706 
    None, # 0
25707 
    (1, TType.I64, 'storeId', None, None, ), # 1
25708 
  )
25709 
 
25710 
  def __init__(self, storeId=None,):
25711 
    self.storeId = storeId
25712 
 
25713 
  def read(self, iprot):
25714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25716 
      return
25717 
    iprot.readStructBegin()
25718 
    while True:
25719 
      (fname, ftype, fid) = iprot.readFieldBegin()
25720 
      if ftype == TType.STOP:
25721 
        break
25722 
      if fid == 1:
25723 
        if ftype == TType.I64:
25724 
          self.storeId = iprot.readI64();
25725 
        else:
25726 
          iprot.skip(ftype)
25727 
      else:
25728 
        iprot.skip(ftype)
25729 
      iprot.readFieldEnd()
25730 
    iprot.readStructEnd()
25731 
 
25732 
  def write(self, oprot):
25733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25735 
      return
25736 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25737 
    if self.storeId is not None:
25738 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25739 
      oprot.writeI64(self.storeId)
25740 
      oprot.writeFieldEnd()
25741 
    oprot.writeFieldStop()
25742 
    oprot.writeStructEnd()
25743 
 
25744 
  def validate(self):
25745 
    return
25746 
 
25747 
 
25748 
  def __repr__(self):
25749 
    L = ['%s=%r' % (key, value)
25750 
      for key, value in self.__dict__.iteritems()]
25751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25752 
 
25753 
  def __eq__(self, other):
25754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25755 
 
25756 
  def __ne__(self, other):
25757 
    return not (self == other)
25758 
 
25759 
class getReceivePendingOrders_result:
25760 
  """
25761 
  Attributes:
25762 
   - success
25763 
  """
25764 
 
25765 
  thrift_spec = (
25766 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25767 
  )
25768 
 
25769 
  def __init__(self, success=None,):
25770 
    self.success = success
25771 
 
25772 
  def read(self, iprot):
25773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25775 
      return
25776 
    iprot.readStructBegin()
25777 
    while True:
25778 
      (fname, ftype, fid) = iprot.readFieldBegin()
25779 
      if ftype == TType.STOP:
25780 
        break
25781 
      if fid == 0:
25782 
        if ftype == TType.LIST:
25783 
          self.success = []
6188 rajveer 25784 
          (_etype638, _size635) = iprot.readListBegin()
25785 
          for _i639 in xrange(_size635):
25786 
            _elem640 = Order()
25787 
            _elem640.read(iprot)
25788 
            self.success.append(_elem640)
5553 rajveer 25789 
          iprot.readListEnd()
25790 
        else:
25791 
          iprot.skip(ftype)
25792 
      else:
25793 
        iprot.skip(ftype)
25794 
      iprot.readFieldEnd()
25795 
    iprot.readStructEnd()
25796 
 
25797 
  def write(self, oprot):
25798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25800 
      return
25801 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25802 
    if self.success is not None:
25803 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25804 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25805 
      for iter641 in self.success:
25806 
        iter641.write(oprot)
5553 rajveer 25807 
      oprot.writeListEnd()
25808 
      oprot.writeFieldEnd()
25809 
    oprot.writeFieldStop()
25810 
    oprot.writeStructEnd()
25811 
 
25812 
  def validate(self):
25813 
    return
25814 
 
25815 
 
25816 
  def __repr__(self):
25817 
    L = ['%s=%r' % (key, value)
25818 
      for key, value in self.__dict__.iteritems()]
25819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25820 
 
25821 
  def __eq__(self, other):
25822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25823 
 
25824 
  def __ne__(self, other):
25825 
    return not (self == other)
25826 
 
25827 
class getReceivedAtStoreOrders_args:
25828 
  """
25829 
  Attributes:
25830 
   - storeId
25831 
  """
25832 
 
25833 
  thrift_spec = (
25834 
    None, # 0
25835 
    (1, TType.I64, 'storeId', None, None, ), # 1
25836 
  )
25837 
 
25838 
  def __init__(self, storeId=None,):
25839 
    self.storeId = storeId
25840 
 
25841 
  def read(self, iprot):
25842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25844 
      return
25845 
    iprot.readStructBegin()
25846 
    while True:
25847 
      (fname, ftype, fid) = iprot.readFieldBegin()
25848 
      if ftype == TType.STOP:
25849 
        break
25850 
      if fid == 1:
25851 
        if ftype == TType.I64:
25852 
          self.storeId = iprot.readI64();
25853 
        else:
25854 
          iprot.skip(ftype)
25855 
      else:
25856 
        iprot.skip(ftype)
25857 
      iprot.readFieldEnd()
25858 
    iprot.readStructEnd()
25859 
 
25860 
  def write(self, oprot):
25861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25863 
      return
25864 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25865 
    if self.storeId is not None:
25866 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25867 
      oprot.writeI64(self.storeId)
25868 
      oprot.writeFieldEnd()
25869 
    oprot.writeFieldStop()
25870 
    oprot.writeStructEnd()
25871 
 
25872 
  def validate(self):
25873 
    return
25874 
 
25875 
 
25876 
  def __repr__(self):
25877 
    L = ['%s=%r' % (key, value)
25878 
      for key, value in self.__dict__.iteritems()]
25879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25880 
 
25881 
  def __eq__(self, other):
25882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25883 
 
25884 
  def __ne__(self, other):
25885 
    return not (self == other)
25886 
 
25887 
class getReceivedAtStoreOrders_result:
25888 
  """
25889 
  Attributes:
25890 
   - success
25891 
  """
25892 
 
25893 
  thrift_spec = (
25894 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25895 
  )
25896 
 
25897 
  def __init__(self, success=None,):
25898 
    self.success = success
25899 
 
25900 
  def read(self, iprot):
25901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25903 
      return
25904 
    iprot.readStructBegin()
25905 
    while True:
25906 
      (fname, ftype, fid) = iprot.readFieldBegin()
25907 
      if ftype == TType.STOP:
25908 
        break
25909 
      if fid == 0:
25910 
        if ftype == TType.LIST:
25911 
          self.success = []
6188 rajveer 25912 
          (_etype645, _size642) = iprot.readListBegin()
25913 
          for _i646 in xrange(_size642):
25914 
            _elem647 = Order()
25915 
            _elem647.read(iprot)
25916 
            self.success.append(_elem647)
5553 rajveer 25917 
          iprot.readListEnd()
25918 
        else:
25919 
          iprot.skip(ftype)
25920 
      else:
25921 
        iprot.skip(ftype)
25922 
      iprot.readFieldEnd()
25923 
    iprot.readStructEnd()
25924 
 
25925 
  def write(self, oprot):
25926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25928 
      return
25929 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25930 
    if self.success is not None:
25931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25933 
      for iter648 in self.success:
25934 
        iter648.write(oprot)
5553 rajveer 25935 
      oprot.writeListEnd()
25936 
      oprot.writeFieldEnd()
25937 
    oprot.writeFieldStop()
25938 
    oprot.writeStructEnd()
25939 
 
25940 
  def validate(self):
25941 
    return
25942 
 
25943 
 
25944 
  def __repr__(self):
25945 
    L = ['%s=%r' % (key, value)
25946 
      for key, value in self.__dict__.iteritems()]
25947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25948 
 
25949 
  def __eq__(self, other):
25950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25951 
 
25952 
  def __ne__(self, other):
25953 
    return not (self == other)
5593 mandeep.dh 25954 
 
5713 rajveer 25955 
class getOrdersCollectionAtStore_args:
25956 
  """
25957 
  Attributes:
25958 
   - storeId
25959 
   - fromDate
25960 
   - toDate
25961 
   - onlyCod
25962 
  """
25963 
 
25964 
  thrift_spec = (
25965 
    None, # 0
25966 
    (1, TType.I64, 'storeId', None, None, ), # 1
25967 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25968 
    (3, TType.I64, 'toDate', None, None, ), # 3
25969 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25970 
  )
25971 
 
25972 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25973 
    self.storeId = storeId
25974 
    self.fromDate = fromDate
25975 
    self.toDate = toDate
25976 
    self.onlyCod = onlyCod
25977 
 
25978 
  def read(self, iprot):
25979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25981 
      return
25982 
    iprot.readStructBegin()
25983 
    while True:
25984 
      (fname, ftype, fid) = iprot.readFieldBegin()
25985 
      if ftype == TType.STOP:
25986 
        break
25987 
      if fid == 1:
25988 
        if ftype == TType.I64:
25989 
          self.storeId = iprot.readI64();
25990 
        else:
25991 
          iprot.skip(ftype)
25992 
      elif fid == 2:
25993 
        if ftype == TType.I64:
25994 
          self.fromDate = iprot.readI64();
25995 
        else:
25996 
          iprot.skip(ftype)
25997 
      elif fid == 3:
25998 
        if ftype == TType.I64:
25999 
          self.toDate = iprot.readI64();
26000 
        else:
26001 
          iprot.skip(ftype)
26002 
      elif fid == 4:
26003 
        if ftype == TType.BOOL:
26004 
          self.onlyCod = iprot.readBool();
26005 
        else:
26006 
          iprot.skip(ftype)
26007 
      else:
26008 
        iprot.skip(ftype)
26009 
      iprot.readFieldEnd()
26010 
    iprot.readStructEnd()
26011 
 
26012 
  def write(self, oprot):
26013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26015 
      return
26016 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26017 
    if self.storeId is not None:
26018 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26019 
      oprot.writeI64(self.storeId)
26020 
      oprot.writeFieldEnd()
26021 
    if self.fromDate is not None:
26022 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26023 
      oprot.writeI64(self.fromDate)
26024 
      oprot.writeFieldEnd()
26025 
    if self.toDate is not None:
26026 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26027 
      oprot.writeI64(self.toDate)
26028 
      oprot.writeFieldEnd()
26029 
    if self.onlyCod is not None:
26030 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26031 
      oprot.writeBool(self.onlyCod)
26032 
      oprot.writeFieldEnd()
26033 
    oprot.writeFieldStop()
26034 
    oprot.writeStructEnd()
26035 
 
26036 
  def validate(self):
26037 
    return
26038 
 
26039 
 
26040 
  def __repr__(self):
26041 
    L = ['%s=%r' % (key, value)
26042 
      for key, value in self.__dict__.iteritems()]
26043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26044 
 
26045 
  def __eq__(self, other):
26046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26047 
 
26048 
  def __ne__(self, other):
26049 
    return not (self == other)
26050 
 
26051 
class getOrdersCollectionAtStore_result:
26052 
  """
26053 
  Attributes:
26054 
   - success
26055 
  """
26056 
 
26057 
  thrift_spec = (
26058 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26059 
  )
26060 
 
26061 
  def __init__(self, success=None,):
26062 
    self.success = success
26063 
 
26064 
  def read(self, iprot):
26065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26067 
      return
26068 
    iprot.readStructBegin()
26069 
    while True:
26070 
      (fname, ftype, fid) = iprot.readFieldBegin()
26071 
      if ftype == TType.STOP:
26072 
        break
26073 
      if fid == 0:
26074 
        if ftype == TType.LIST:
26075 
          self.success = []
6188 rajveer 26076 
          (_etype652, _size649) = iprot.readListBegin()
26077 
          for _i653 in xrange(_size649):
26078 
            _elem654 = Order()
26079 
            _elem654.read(iprot)
26080 
            self.success.append(_elem654)
5713 rajveer 26081 
          iprot.readListEnd()
26082 
        else:
26083 
          iprot.skip(ftype)
26084 
      else:
26085 
        iprot.skip(ftype)
26086 
      iprot.readFieldEnd()
26087 
    iprot.readStructEnd()
26088 
 
26089 
  def write(self, oprot):
26090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26092 
      return
26093 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26094 
    if self.success is not None:
26095 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26096 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26097 
      for iter655 in self.success:
26098 
        iter655.write(oprot)
5713 rajveer 26099 
      oprot.writeListEnd()
26100 
      oprot.writeFieldEnd()
26101 
    oprot.writeFieldStop()
26102 
    oprot.writeStructEnd()
26103 
 
26104 
  def validate(self):
26105 
    return
26106 
 
26107 
 
26108 
  def __repr__(self):
26109 
    L = ['%s=%r' % (key, value)
26110 
      for key, value in self.__dict__.iteritems()]
26111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26112 
 
26113 
  def __eq__(self, other):
26114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26115 
 
26116 
  def __ne__(self, other):
26117 
    return not (self == other)
26118 
 
5833 rajveer 26119 
class getOrderAttributeValue_args:
26120 
  """
26121 
  Attributes:
26122 
   - orderId
26123 
   - attributeName
26124 
  """
26125 
 
26126 
  thrift_spec = None
26127 
  def __init__(self, orderId=None, attributeName=None,):
26128 
    self.orderId = orderId
26129 
    self.attributeName = attributeName
26130 
 
26131 
  def read(self, iprot):
26132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26134 
      return
26135 
    iprot.readStructBegin()
26136 
    while True:
26137 
      (fname, ftype, fid) = iprot.readFieldBegin()
26138 
      if ftype == TType.STOP:
26139 
        break
26140 
      if fid == 1:
26141 
        if ftype == TType.I64:
26142 
          self.orderId = iprot.readI64();
26143 
        else:
26144 
          iprot.skip(ftype)
26145 
      elif fid == -1:
26146 
        if ftype == TType.STRING:
26147 
          self.attributeName = iprot.readString();
26148 
        else:
26149 
          iprot.skip(ftype)
26150 
      else:
26151 
        iprot.skip(ftype)
26152 
      iprot.readFieldEnd()
26153 
    iprot.readStructEnd()
26154 
 
26155 
  def write(self, oprot):
26156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26158 
      return
26159 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26160 
    if self.attributeName is not None:
26161 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26162 
      oprot.writeString(self.attributeName)
26163 
      oprot.writeFieldEnd()
26164 
    if self.orderId is not None:
26165 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26166 
      oprot.writeI64(self.orderId)
26167 
      oprot.writeFieldEnd()
26168 
    oprot.writeFieldStop()
26169 
    oprot.writeStructEnd()
26170 
 
26171 
  def validate(self):
26172 
    return
26173 
 
26174 
 
26175 
  def __repr__(self):
26176 
    L = ['%s=%r' % (key, value)
26177 
      for key, value in self.__dict__.iteritems()]
26178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26179 
 
26180 
  def __eq__(self, other):
26181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26182 
 
26183 
  def __ne__(self, other):
26184 
    return not (self == other)
26185 
 
26186 
class getOrderAttributeValue_result:
26187 
  """
26188 
  Attributes:
26189 
   - success
26190 
  """
26191 
 
26192 
  thrift_spec = (
26193 
    (0, TType.STRING, 'success', None, None, ), # 0
26194 
  )
26195 
 
26196 
  def __init__(self, success=None,):
26197 
    self.success = success
26198 
 
26199 
  def read(self, iprot):
26200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26202 
      return
26203 
    iprot.readStructBegin()
26204 
    while True:
26205 
      (fname, ftype, fid) = iprot.readFieldBegin()
26206 
      if ftype == TType.STOP:
26207 
        break
26208 
      if fid == 0:
26209 
        if ftype == TType.STRING:
26210 
          self.success = iprot.readString();
26211 
        else:
26212 
          iprot.skip(ftype)
26213 
      else:
26214 
        iprot.skip(ftype)
26215 
      iprot.readFieldEnd()
26216 
    iprot.readStructEnd()
26217 
 
26218 
  def write(self, oprot):
26219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26221 
      return
26222 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26223 
    if self.success is not None:
26224 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26225 
      oprot.writeString(self.success)
26226 
      oprot.writeFieldEnd()
26227 
    oprot.writeFieldStop()
26228 
    oprot.writeStructEnd()
26229 
 
26230 
  def validate(self):
26231 
    return
26232 
 
26233 
 
26234 
  def __repr__(self):
26235 
    L = ['%s=%r' % (key, value)
26236 
      for key, value in self.__dict__.iteritems()]
26237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26238 
 
26239 
  def __eq__(self, other):
26240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26241 
 
26242 
  def __ne__(self, other):
26243 
    return not (self == other)
26244 
 
6019 rajveer 26245 
class changeJacketNumber_args:
26246 
  """
26247 
  Attributes:
26248 
   - orderId
26249 
   - jacketNumber
26250 
  """
26251 
 
26252 
  thrift_spec = (
26253 
    None, # 0
26254 
    (1, TType.I64, 'orderId', None, None, ), # 1
26255 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26256 
  )
26257 
 
26258 
  def __init__(self, orderId=None, jacketNumber=None,):
26259 
    self.orderId = orderId
26260 
    self.jacketNumber = jacketNumber
26261 
 
26262 
  def read(self, iprot):
26263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26265 
      return
26266 
    iprot.readStructBegin()
26267 
    while True:
26268 
      (fname, ftype, fid) = iprot.readFieldBegin()
26269 
      if ftype == TType.STOP:
26270 
        break
26271 
      if fid == 1:
26272 
        if ftype == TType.I64:
26273 
          self.orderId = iprot.readI64();
26274 
        else:
26275 
          iprot.skip(ftype)
26276 
      elif fid == 2:
26277 
        if ftype == TType.I64:
26278 
          self.jacketNumber = iprot.readI64();
26279 
        else:
26280 
          iprot.skip(ftype)
26281 
      else:
26282 
        iprot.skip(ftype)
26283 
      iprot.readFieldEnd()
26284 
    iprot.readStructEnd()
26285 
 
26286 
  def write(self, oprot):
26287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26289 
      return
26290 
    oprot.writeStructBegin('changeJacketNumber_args')
26291 
    if self.orderId is not None:
26292 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26293 
      oprot.writeI64(self.orderId)
26294 
      oprot.writeFieldEnd()
26295 
    if self.jacketNumber is not None:
26296 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26297 
      oprot.writeI64(self.jacketNumber)
26298 
      oprot.writeFieldEnd()
26299 
    oprot.writeFieldStop()
26300 
    oprot.writeStructEnd()
26301 
 
26302 
  def validate(self):
26303 
    return
26304 
 
26305 
 
26306 
  def __repr__(self):
26307 
    L = ['%s=%r' % (key, value)
26308 
      for key, value in self.__dict__.iteritems()]
26309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26310 
 
26311 
  def __eq__(self, other):
26312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26313 
 
26314 
  def __ne__(self, other):
26315 
    return not (self == other)
26316 
 
26317 
class changeJacketNumber_result:
26318 
  """
26319 
  Attributes:
26320 
   - success
26321 
  """
26322 
 
26323 
  thrift_spec = (
26324 
    (0, TType.BOOL, 'success', None, None, ), # 0
26325 
  )
26326 
 
26327 
  def __init__(self, success=None,):
26328 
    self.success = success
26329 
 
26330 
  def read(self, iprot):
26331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26333 
      return
26334 
    iprot.readStructBegin()
26335 
    while True:
26336 
      (fname, ftype, fid) = iprot.readFieldBegin()
26337 
      if ftype == TType.STOP:
26338 
        break
26339 
      if fid == 0:
26340 
        if ftype == TType.BOOL:
26341 
          self.success = iprot.readBool();
26342 
        else:
26343 
          iprot.skip(ftype)
26344 
      else:
26345 
        iprot.skip(ftype)
26346 
      iprot.readFieldEnd()
26347 
    iprot.readStructEnd()
26348 
 
26349 
  def write(self, oprot):
26350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26352 
      return
26353 
    oprot.writeStructBegin('changeJacketNumber_result')
26354 
    if self.success is not None:
26355 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26356 
      oprot.writeBool(self.success)
26357 
      oprot.writeFieldEnd()
26358 
    oprot.writeFieldStop()
26359 
    oprot.writeStructEnd()
26360 
 
26361 
  def validate(self):
26362 
    return
26363 
 
26364 
 
26365 
  def __repr__(self):
26366 
    L = ['%s=%r' % (key, value)
26367 
      for key, value in self.__dict__.iteritems()]
26368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26369 
 
26370 
  def __eq__(self, other):
26371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26372 
 
26373 
  def __ne__(self, other):
26374 
    return not (self == other)
26375 
 
26376 
class markOrderAsRtoInTransit_args:
26377 
  """
26378 
  Attributes:
26379 
   - orderId
26380 
  """
26381 
 
26382 
  thrift_spec = (
26383 
    None, # 0
26384 
    (1, TType.I64, 'orderId', None, None, ), # 1
26385 
  )
26386 
 
26387 
  def __init__(self, orderId=None,):
26388 
    self.orderId = orderId
26389 
 
26390 
  def read(self, iprot):
26391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26393 
      return
26394 
    iprot.readStructBegin()
26395 
    while True:
26396 
      (fname, ftype, fid) = iprot.readFieldBegin()
26397 
      if ftype == TType.STOP:
26398 
        break
26399 
      if fid == 1:
26400 
        if ftype == TType.I64:
26401 
          self.orderId = iprot.readI64();
26402 
        else:
26403 
          iprot.skip(ftype)
26404 
      else:
26405 
        iprot.skip(ftype)
26406 
      iprot.readFieldEnd()
26407 
    iprot.readStructEnd()
26408 
 
26409 
  def write(self, oprot):
26410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26412 
      return
26413 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26414 
    if self.orderId is not None:
26415 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26416 
      oprot.writeI64(self.orderId)
26417 
      oprot.writeFieldEnd()
26418 
    oprot.writeFieldStop()
26419 
    oprot.writeStructEnd()
26420 
 
26421 
  def validate(self):
26422 
    return
26423 
 
26424 
 
26425 
  def __repr__(self):
26426 
    L = ['%s=%r' % (key, value)
26427 
      for key, value in self.__dict__.iteritems()]
26428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26429 
 
26430 
  def __eq__(self, other):
26431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26432 
 
26433 
  def __ne__(self, other):
26434 
    return not (self == other)
26435 
 
26436 
class markOrderAsRtoInTransit_result:
26437 
  """
26438 
  Attributes:
26439 
   - success
26440 
  """
26441 
 
26442 
  thrift_spec = (
26443 
    (0, TType.BOOL, 'success', None, None, ), # 0
26444 
  )
26445 
 
26446 
  def __init__(self, success=None,):
26447 
    self.success = success
26448 
 
26449 
  def read(self, iprot):
26450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26452 
      return
26453 
    iprot.readStructBegin()
26454 
    while True:
26455 
      (fname, ftype, fid) = iprot.readFieldBegin()
26456 
      if ftype == TType.STOP:
26457 
        break
26458 
      if fid == 0:
26459 
        if ftype == TType.BOOL:
26460 
          self.success = iprot.readBool();
26461 
        else:
26462 
          iprot.skip(ftype)
26463 
      else:
26464 
        iprot.skip(ftype)
26465 
      iprot.readFieldEnd()
26466 
    iprot.readStructEnd()
26467 
 
26468 
  def write(self, oprot):
26469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26471 
      return
26472 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26473 
    if self.success is not None:
26474 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26475 
      oprot.writeBool(self.success)
26476 
      oprot.writeFieldEnd()
26477 
    oprot.writeFieldStop()
26478 
    oprot.writeStructEnd()
26479 
 
26480 
  def validate(self):
26481 
    return
26482 
 
26483 
 
26484 
  def __repr__(self):
26485 
    L = ['%s=%r' % (key, value)
26486 
      for key, value in self.__dict__.iteritems()]
26487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26488 
 
26489 
  def __eq__(self, other):
26490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26491 
 
26492 
  def __ne__(self, other):
26493 
    return not (self == other)
26494 
 
5593 mandeep.dh 26495 
class acceptOrderForItem_args:
26496 
  """
26497 
  Attributes:
26498 
   - itemId
26499 
   - quantity
26500 
   - fulfilmentWarehouseId
26501 
   - billingWarehouseId
26502 
  """
26503 
 
26504 
  thrift_spec = (
26505 
    None, # 0
26506 
    (1, TType.I64, 'itemId', None, None, ), # 1
26507 
    (2, TType.I64, 'quantity', None, None, ), # 2
26508 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26509 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26510 
  )
26511 
 
26512 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26513 
    self.itemId = itemId
26514 
    self.quantity = quantity
26515 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26516 
    self.billingWarehouseId = billingWarehouseId
26517 
 
26518 
  def read(self, iprot):
26519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26521 
      return
26522 
    iprot.readStructBegin()
26523 
    while True:
26524 
      (fname, ftype, fid) = iprot.readFieldBegin()
26525 
      if ftype == TType.STOP:
26526 
        break
26527 
      if fid == 1:
26528 
        if ftype == TType.I64:
26529 
          self.itemId = iprot.readI64();
26530 
        else:
26531 
          iprot.skip(ftype)
26532 
      elif fid == 2:
26533 
        if ftype == TType.I64:
26534 
          self.quantity = iprot.readI64();
26535 
        else:
26536 
          iprot.skip(ftype)
26537 
      elif fid == 3:
26538 
        if ftype == TType.I64:
26539 
          self.fulfilmentWarehouseId = iprot.readI64();
26540 
        else:
26541 
          iprot.skip(ftype)
26542 
      elif fid == 4:
26543 
        if ftype == TType.I64:
26544 
          self.billingWarehouseId = iprot.readI64();
26545 
        else:
26546 
          iprot.skip(ftype)
26547 
      else:
26548 
        iprot.skip(ftype)
26549 
      iprot.readFieldEnd()
26550 
    iprot.readStructEnd()
26551 
 
26552 
  def write(self, oprot):
26553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26555 
      return
26556 
    oprot.writeStructBegin('acceptOrderForItem_args')
26557 
    if self.itemId is not None:
26558 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26559 
      oprot.writeI64(self.itemId)
26560 
      oprot.writeFieldEnd()
26561 
    if self.quantity is not None:
26562 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26563 
      oprot.writeI64(self.quantity)
26564 
      oprot.writeFieldEnd()
26565 
    if self.fulfilmentWarehouseId is not None:
26566 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26567 
      oprot.writeI64(self.fulfilmentWarehouseId)
26568 
      oprot.writeFieldEnd()
26569 
    if self.billingWarehouseId is not None:
26570 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26571 
      oprot.writeI64(self.billingWarehouseId)
26572 
      oprot.writeFieldEnd()
26573 
    oprot.writeFieldStop()
26574 
    oprot.writeStructEnd()
26575 
 
26576 
  def validate(self):
26577 
    return
26578 
 
26579 
 
26580 
  def __repr__(self):
26581 
    L = ['%s=%r' % (key, value)
26582 
      for key, value in self.__dict__.iteritems()]
26583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26584 
 
26585 
  def __eq__(self, other):
26586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26587 
 
26588 
  def __ne__(self, other):
26589 
    return not (self == other)
26590 
 
26591 
class acceptOrderForItem_result:
26592 
 
26593 
  thrift_spec = (
26594 
  )
26595 
 
26596 
  def read(self, iprot):
26597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26599 
      return
26600 
    iprot.readStructBegin()
26601 
    while True:
26602 
      (fname, ftype, fid) = iprot.readFieldBegin()
26603 
      if ftype == TType.STOP:
26604 
        break
26605 
      else:
26606 
        iprot.skip(ftype)
26607 
      iprot.readFieldEnd()
26608 
    iprot.readStructEnd()
26609 
 
26610 
  def write(self, oprot):
26611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26613 
      return
26614 
    oprot.writeStructBegin('acceptOrderForItem_result')
26615 
    oprot.writeFieldStop()
26616 
    oprot.writeStructEnd()
26617 
 
26618 
  def validate(self):
26619 
    return
26620 
 
26621 
 
26622 
  def __repr__(self):
26623 
    L = ['%s=%r' % (key, value)
26624 
      for key, value in self.__dict__.iteritems()]
26625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26626 
 
26627 
  def __eq__(self, other):
26628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26629 
 
26630 
  def __ne__(self, other):
26631 
    return not (self == other)
6000 mandeep.dh 26632 
 
26633 
class createRechargeOrder_args:
26634 
  """
26635 
  Attributes:
26636 
   - rechargeOrder
26637 
  """
26638 
 
26639 
  thrift_spec = (
26640 
    None, # 0
26641 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26642 
  )
26643 
 
26644 
  def __init__(self, rechargeOrder=None,):
26645 
    self.rechargeOrder = rechargeOrder
26646 
 
26647 
  def read(self, iprot):
26648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26650 
      return
26651 
    iprot.readStructBegin()
26652 
    while True:
26653 
      (fname, ftype, fid) = iprot.readFieldBegin()
26654 
      if ftype == TType.STOP:
26655 
        break
26656 
      if fid == 1:
26657 
        if ftype == TType.STRUCT:
26658 
          self.rechargeOrder = RechargeOrder()
26659 
          self.rechargeOrder.read(iprot)
26660 
        else:
26661 
          iprot.skip(ftype)
26662 
      else:
26663 
        iprot.skip(ftype)
26664 
      iprot.readFieldEnd()
26665 
    iprot.readStructEnd()
26666 
 
26667 
  def write(self, oprot):
26668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26670 
      return
26671 
    oprot.writeStructBegin('createRechargeOrder_args')
26672 
    if self.rechargeOrder is not None:
26673 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26674 
      self.rechargeOrder.write(oprot)
26675 
      oprot.writeFieldEnd()
26676 
    oprot.writeFieldStop()
26677 
    oprot.writeStructEnd()
26678 
 
26679 
  def validate(self):
26680 
    return
26681 
 
26682 
 
26683 
  def __repr__(self):
26684 
    L = ['%s=%r' % (key, value)
26685 
      for key, value in self.__dict__.iteritems()]
26686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26687 
 
26688 
  def __eq__(self, other):
26689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26690 
 
26691 
  def __ne__(self, other):
26692 
    return not (self == other)
26693 
 
26694 
class createRechargeOrder_result:
26695 
  """
26696 
  Attributes:
26697 
   - success
26698 
   - ex
26699 
  """
26700 
 
26701 
  thrift_spec = (
26702 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26704 
  )
26705 
 
26706 
  def __init__(self, success=None, ex=None,):
26707 
    self.success = success
26708 
    self.ex = ex
26709 
 
26710 
  def read(self, iprot):
26711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26713 
      return
26714 
    iprot.readStructBegin()
26715 
    while True:
26716 
      (fname, ftype, fid) = iprot.readFieldBegin()
26717 
      if ftype == TType.STOP:
26718 
        break
26719 
      if fid == 0:
26720 
        if ftype == TType.STRUCT:
26721 
          self.success = RechargeOrder()
26722 
          self.success.read(iprot)
26723 
        else:
26724 
          iprot.skip(ftype)
26725 
      elif fid == 1:
26726 
        if ftype == TType.STRUCT:
26727 
          self.ex = TransactionServiceException()
26728 
          self.ex.read(iprot)
26729 
        else:
26730 
          iprot.skip(ftype)
26731 
      else:
26732 
        iprot.skip(ftype)
26733 
      iprot.readFieldEnd()
26734 
    iprot.readStructEnd()
26735 
 
26736 
  def write(self, oprot):
26737 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26738 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26739 
      return
26740 
    oprot.writeStructBegin('createRechargeOrder_result')
26741 
    if self.success is not None:
26742 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26743 
      self.success.write(oprot)
26744 
      oprot.writeFieldEnd()
26745 
    if self.ex is not None:
26746 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26747 
      self.ex.write(oprot)
26748 
      oprot.writeFieldEnd()
26749 
    oprot.writeFieldStop()
26750 
    oprot.writeStructEnd()
26751 
 
26752 
  def validate(self):
26753 
    return
26754 
 
26755 
 
26756 
  def __repr__(self):
26757 
    L = ['%s=%r' % (key, value)
26758 
      for key, value in self.__dict__.iteritems()]
26759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26760 
 
26761 
  def __eq__(self, other):
26762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26763 
 
26764 
  def __ne__(self, other):
26765 
    return not (self == other)
26766 
 
6031 rajveer 26767 
class getRechargeOrder_args:
26768 
  """
26769 
  Attributes:
26770 
   - rechargeRrderId
26771 
  """
26772 
 
26773 
  thrift_spec = (
26774 
    None, # 0
26775 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26776 
  )
26777 
 
26778 
  def __init__(self, rechargeRrderId=None,):
26779 
    self.rechargeRrderId = rechargeRrderId
26780 
 
26781 
  def read(self, iprot):
26782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26784 
      return
26785 
    iprot.readStructBegin()
26786 
    while True:
26787 
      (fname, ftype, fid) = iprot.readFieldBegin()
26788 
      if ftype == TType.STOP:
26789 
        break
26790 
      if fid == 1:
26791 
        if ftype == TType.I64:
26792 
          self.rechargeRrderId = iprot.readI64();
26793 
        else:
26794 
          iprot.skip(ftype)
26795 
      else:
26796 
        iprot.skip(ftype)
26797 
      iprot.readFieldEnd()
26798 
    iprot.readStructEnd()
26799 
 
26800 
  def write(self, oprot):
26801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26803 
      return
26804 
    oprot.writeStructBegin('getRechargeOrder_args')
26805 
    if self.rechargeRrderId is not None:
26806 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26807 
      oprot.writeI64(self.rechargeRrderId)
26808 
      oprot.writeFieldEnd()
26809 
    oprot.writeFieldStop()
26810 
    oprot.writeStructEnd()
26811 
 
26812 
  def validate(self):
26813 
    return
26814 
 
26815 
 
26816 
  def __repr__(self):
26817 
    L = ['%s=%r' % (key, value)
26818 
      for key, value in self.__dict__.iteritems()]
26819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26820 
 
26821 
  def __eq__(self, other):
26822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26823 
 
26824 
  def __ne__(self, other):
26825 
    return not (self == other)
26826 
 
26827 
class getRechargeOrder_result:
26828 
  """
26829 
  Attributes:
26830 
   - success
26831 
   - ex
26832 
  """
26833 
 
26834 
  thrift_spec = (
26835 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26836 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26837 
  )
26838 
 
26839 
  def __init__(self, success=None, ex=None,):
26840 
    self.success = success
26841 
    self.ex = ex
26842 
 
26843 
  def read(self, iprot):
26844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26846 
      return
26847 
    iprot.readStructBegin()
26848 
    while True:
26849 
      (fname, ftype, fid) = iprot.readFieldBegin()
26850 
      if ftype == TType.STOP:
26851 
        break
26852 
      if fid == 0:
26853 
        if ftype == TType.STRUCT:
26854 
          self.success = RechargeOrder()
26855 
          self.success.read(iprot)
26856 
        else:
26857 
          iprot.skip(ftype)
26858 
      elif fid == 1:
26859 
        if ftype == TType.STRUCT:
26860 
          self.ex = TransactionServiceException()
26861 
          self.ex.read(iprot)
26862 
        else:
26863 
          iprot.skip(ftype)
26864 
      else:
26865 
        iprot.skip(ftype)
26866 
      iprot.readFieldEnd()
26867 
    iprot.readStructEnd()
26868 
 
26869 
  def write(self, oprot):
26870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26872 
      return
26873 
    oprot.writeStructBegin('getRechargeOrder_result')
26874 
    if self.success is not None:
26875 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26876 
      self.success.write(oprot)
26877 
      oprot.writeFieldEnd()
26878 
    if self.ex is not None:
26879 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26880 
      self.ex.write(oprot)
26881 
      oprot.writeFieldEnd()
26882 
    oprot.writeFieldStop()
26883 
    oprot.writeStructEnd()
26884 
 
26885 
  def validate(self):
26886 
    return
26887 
 
26888 
 
26889 
  def __repr__(self):
26890 
    L = ['%s=%r' % (key, value)
26891 
      for key, value in self.__dict__.iteritems()]
26892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26893 
 
26894 
  def __eq__(self, other):
26895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26896 
 
26897 
  def __ne__(self, other):
26898 
    return not (self == other)
26899 
 
26900 
class getRechargeOrders_args:
26901 
  """
26902 
  Attributes:
26903 
   - userId
26904 
  """
26905 
 
26906 
  thrift_spec = (
26907 
    None, # 0
26908 
    (1, TType.I64, 'userId', None, None, ), # 1
26909 
  )
26910 
 
26911 
  def __init__(self, userId=None,):
26912 
    self.userId = userId
26913 
 
26914 
  def read(self, iprot):
26915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26917 
      return
26918 
    iprot.readStructBegin()
26919 
    while True:
26920 
      (fname, ftype, fid) = iprot.readFieldBegin()
26921 
      if ftype == TType.STOP:
26922 
        break
26923 
      if fid == 1:
26924 
        if ftype == TType.I64:
26925 
          self.userId = iprot.readI64();
26926 
        else:
26927 
          iprot.skip(ftype)
26928 
      else:
26929 
        iprot.skip(ftype)
26930 
      iprot.readFieldEnd()
26931 
    iprot.readStructEnd()
26932 
 
26933 
  def write(self, oprot):
26934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26936 
      return
26937 
    oprot.writeStructBegin('getRechargeOrders_args')
26938 
    if self.userId is not None:
26939 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26940 
      oprot.writeI64(self.userId)
26941 
      oprot.writeFieldEnd()
26942 
    oprot.writeFieldStop()
26943 
    oprot.writeStructEnd()
26944 
 
26945 
  def validate(self):
26946 
    return
26947 
 
26948 
 
26949 
  def __repr__(self):
26950 
    L = ['%s=%r' % (key, value)
26951 
      for key, value in self.__dict__.iteritems()]
26952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26953 
 
26954 
  def __eq__(self, other):
26955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26956 
 
26957 
  def __ne__(self, other):
26958 
    return not (self == other)
26959 
 
26960 
class getRechargeOrders_result:
26961 
  """
26962 
  Attributes:
26963 
   - success
26964 
  """
26965 
 
26966 
  thrift_spec = (
26967 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26968 
  )
26969 
 
26970 
  def __init__(self, success=None,):
26971 
    self.success = success
26972 
 
26973 
  def read(self, iprot):
26974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26976 
      return
26977 
    iprot.readStructBegin()
26978 
    while True:
26979 
      (fname, ftype, fid) = iprot.readFieldBegin()
26980 
      if ftype == TType.STOP:
26981 
        break
26982 
      if fid == 0:
26983 
        if ftype == TType.LIST:
26984 
          self.success = []
6188 rajveer 26985 
          (_etype659, _size656) = iprot.readListBegin()
26986 
          for _i660 in xrange(_size656):
26987 
            _elem661 = RechargeOrder()
26988 
            _elem661.read(iprot)
26989 
            self.success.append(_elem661)
6031 rajveer 26990 
          iprot.readListEnd()
26991 
        else:
26992 
          iprot.skip(ftype)
26993 
      else:
26994 
        iprot.skip(ftype)
26995 
      iprot.readFieldEnd()
26996 
    iprot.readStructEnd()
26997 
 
26998 
  def write(self, oprot):
26999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27001 
      return
27002 
    oprot.writeStructBegin('getRechargeOrders_result')
27003 
    if self.success is not None:
27004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27006 
      for iter662 in self.success:
27007 
        iter662.write(oprot)
6031 rajveer 27008 
      oprot.writeListEnd()
27009 
      oprot.writeFieldEnd()
27010 
    oprot.writeFieldStop()
27011 
    oprot.writeStructEnd()
27012 
 
27013 
  def validate(self):
27014 
    return
27015 
 
27016 
 
27017 
  def __repr__(self):
27018 
    L = ['%s=%r' % (key, value)
27019 
      for key, value in self.__dict__.iteritems()]
27020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27021 
 
27022 
  def __eq__(self, other):
27023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27024 
 
27025 
  def __ne__(self, other):
27026 
    return not (self == other)
27027 
 
6000 mandeep.dh 27028 
class updateRechargeOrderStatus_args:
27029 
  """
27030 
  Attributes:
27031 
   - rechargeOrderId
27032 
   - rechargeOrderStatus
27033 
  """
27034 
 
27035 
  thrift_spec = (
27036 
    None, # 0
27037 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27038 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27039 
  )
27040 
 
27041 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27042 
    self.rechargeOrderId = rechargeOrderId
27043 
    self.rechargeOrderStatus = rechargeOrderStatus
27044 
 
27045 
  def read(self, iprot):
27046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27048 
      return
27049 
    iprot.readStructBegin()
27050 
    while True:
27051 
      (fname, ftype, fid) = iprot.readFieldBegin()
27052 
      if ftype == TType.STOP:
27053 
        break
27054 
      if fid == 1:
27055 
        if ftype == TType.I64:
27056 
          self.rechargeOrderId = iprot.readI64();
27057 
        else:
27058 
          iprot.skip(ftype)
27059 
      elif fid == 2:
27060 
        if ftype == TType.I32:
27061 
          self.rechargeOrderStatus = iprot.readI32();
27062 
        else:
27063 
          iprot.skip(ftype)
27064 
      else:
27065 
        iprot.skip(ftype)
27066 
      iprot.readFieldEnd()
27067 
    iprot.readStructEnd()
27068 
 
27069 
  def write(self, oprot):
27070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27072 
      return
27073 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27074 
    if self.rechargeOrderId is not None:
27075 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27076 
      oprot.writeI64(self.rechargeOrderId)
27077 
      oprot.writeFieldEnd()
27078 
    if self.rechargeOrderStatus is not None:
27079 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27080 
      oprot.writeI32(self.rechargeOrderStatus)
27081 
      oprot.writeFieldEnd()
27082 
    oprot.writeFieldStop()
27083 
    oprot.writeStructEnd()
27084 
 
27085 
  def validate(self):
27086 
    return
27087 
 
27088 
 
27089 
  def __repr__(self):
27090 
    L = ['%s=%r' % (key, value)
27091 
      for key, value in self.__dict__.iteritems()]
27092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27093 
 
27094 
  def __eq__(self, other):
27095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27096 
 
27097 
  def __ne__(self, other):
27098 
    return not (self == other)
27099 
 
27100 
class updateRechargeOrderStatus_result:
27101 
  """
27102 
  Attributes:
6031 rajveer 27103 
   - success
6000 mandeep.dh 27104 
   - ex
27105 
  """
27106 
 
27107 
  thrift_spec = (
6031 rajveer 27108 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27110 
  )
27111 
 
6031 rajveer 27112 
  def __init__(self, success=None, ex=None,):
27113 
    self.success = success
6000 mandeep.dh 27114 
    self.ex = ex
27115 
 
27116 
  def read(self, iprot):
27117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27119 
      return
27120 
    iprot.readStructBegin()
27121 
    while True:
27122 
      (fname, ftype, fid) = iprot.readFieldBegin()
27123 
      if ftype == TType.STOP:
27124 
        break
6031 rajveer 27125 
      if fid == 0:
27126 
        if ftype == TType.BOOL:
27127 
          self.success = iprot.readBool();
27128 
        else:
27129 
          iprot.skip(ftype)
27130 
      elif fid == 1:
6000 mandeep.dh 27131 
        if ftype == TType.STRUCT:
27132 
          self.ex = TransactionServiceException()
27133 
          self.ex.read(iprot)
27134 
        else:
27135 
          iprot.skip(ftype)
27136 
      else:
27137 
        iprot.skip(ftype)
27138 
      iprot.readFieldEnd()
27139 
    iprot.readStructEnd()
27140 
 
27141 
  def write(self, oprot):
27142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27144 
      return
27145 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27146 
    if self.success is not None:
27147 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27148 
      oprot.writeBool(self.success)
27149 
      oprot.writeFieldEnd()
6000 mandeep.dh 27150 
    if self.ex is not None:
27151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27152 
      self.ex.write(oprot)
27153 
      oprot.writeFieldEnd()
27154 
    oprot.writeFieldStop()
27155 
    oprot.writeStructEnd()
27156 
 
27157 
  def validate(self):
27158 
    return
27159 
 
27160 
 
27161 
  def __repr__(self):
27162 
    L = ['%s=%r' % (key, value)
27163 
      for key, value in self.__dict__.iteritems()]
27164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27165 
 
27166 
  def __eq__(self, other):
27167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27168 
 
27169 
  def __ne__(self, other):
27170 
    return not (self == other)
27171 
 
27172 
class activateRechargeTxn_args:
27173 
  """
27174 
  Attributes:
6031 rajveer 27175 
   - rechargeOrderId
6000 mandeep.dh 27176 
  """
27177 
 
27178 
  thrift_spec = (
27179 
    None, # 0
6031 rajveer 27180 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27181 
  )
27182 
 
6031 rajveer 27183 
  def __init__(self, rechargeOrderId=None,):
27184 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27185 
 
27186 
  def read(self, iprot):
27187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27189 
      return
27190 
    iprot.readStructBegin()
27191 
    while True:
27192 
      (fname, ftype, fid) = iprot.readFieldBegin()
27193 
      if ftype == TType.STOP:
27194 
        break
27195 
      if fid == 1:
6031 rajveer 27196 
        if ftype == TType.I64:
27197 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27198 
        else:
27199 
          iprot.skip(ftype)
27200 
      else:
27201 
        iprot.skip(ftype)
27202 
      iprot.readFieldEnd()
27203 
    iprot.readStructEnd()
27204 
 
27205 
  def write(self, oprot):
27206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27208 
      return
27209 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27210 
    if self.rechargeOrderId is not None:
27211 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27212 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27213 
      oprot.writeFieldEnd()
27214 
    oprot.writeFieldStop()
27215 
    oprot.writeStructEnd()
27216 
 
27217 
  def validate(self):
27218 
    return
27219 
 
27220 
 
27221 
  def __repr__(self):
27222 
    L = ['%s=%r' % (key, value)
27223 
      for key, value in self.__dict__.iteritems()]
27224 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27225 
 
27226 
  def __eq__(self, other):
27227 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27228 
 
27229 
  def __ne__(self, other):
27230 
    return not (self == other)
27231 
 
27232 
class activateRechargeTxn_result:
27233 
  """
27234 
  Attributes:
27235 
   - success
27236 
   - ex
27237 
  """
27238 
 
27239 
  thrift_spec = (
6031 rajveer 27240 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27241 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27242 
  )
27243 
 
27244 
  def __init__(self, success=None, ex=None,):
27245 
    self.success = success
27246 
    self.ex = ex
27247 
 
27248 
  def read(self, iprot):
27249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27251 
      return
27252 
    iprot.readStructBegin()
27253 
    while True:
27254 
      (fname, ftype, fid) = iprot.readFieldBegin()
27255 
      if ftype == TType.STOP:
27256 
        break
27257 
      if fid == 0:
6031 rajveer 27258 
        if ftype == TType.BOOL:
27259 
          self.success = iprot.readBool();
6000 mandeep.dh 27260 
        else:
27261 
          iprot.skip(ftype)
27262 
      elif fid == 1:
27263 
        if ftype == TType.STRUCT:
27264 
          self.ex = TransactionServiceException()
27265 
          self.ex.read(iprot)
27266 
        else:
27267 
          iprot.skip(ftype)
27268 
      else:
27269 
        iprot.skip(ftype)
27270 
      iprot.readFieldEnd()
27271 
    iprot.readStructEnd()
27272 
 
27273 
  def write(self, oprot):
27274 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27275 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27276 
      return
27277 
    oprot.writeStructBegin('activateRechargeTxn_result')
27278 
    if self.success is not None:
6031 rajveer 27279 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27280 
      oprot.writeBool(self.success)
6000 mandeep.dh 27281 
      oprot.writeFieldEnd()
27282 
    if self.ex is not None:
27283 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27284 
      self.ex.write(oprot)
27285 
      oprot.writeFieldEnd()
27286 
    oprot.writeFieldStop()
27287 
    oprot.writeStructEnd()
27288 
 
27289 
  def validate(self):
27290 
    return
27291 
 
27292 
 
27293 
  def __repr__(self):
27294 
    L = ['%s=%r' % (key, value)
27295 
      for key, value in self.__dict__.iteritems()]
27296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27297 
 
27298 
  def __eq__(self, other):
27299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27300 
 
27301 
  def __ne__(self, other):
27302 
    return not (self == other)
27303 
 
6031 rajveer 27304 
class getUserWallet_args:
6000 mandeep.dh 27305 
  """
27306 
  Attributes:
6031 rajveer 27307 
   - userId
6000 mandeep.dh 27308 
  """
27309 
 
27310 
  thrift_spec = (
27311 
    None, # 0
6031 rajveer 27312 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27313 
  )
27314 
 
6031 rajveer 27315 
  def __init__(self, userId=None,):
27316 
    self.userId = userId
6000 mandeep.dh 27317 
 
27318 
  def read(self, iprot):
27319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27321 
      return
27322 
    iprot.readStructBegin()
27323 
    while True:
27324 
      (fname, ftype, fid) = iprot.readFieldBegin()
27325 
      if ftype == TType.STOP:
27326 
        break
27327 
      if fid == 1:
27328 
        if ftype == TType.I64:
6031 rajveer 27329 
          self.userId = iprot.readI64();
6000 mandeep.dh 27330 
        else:
27331 
          iprot.skip(ftype)
27332 
      else:
27333 
        iprot.skip(ftype)
27334 
      iprot.readFieldEnd()
27335 
    iprot.readStructEnd()
27336 
 
27337 
  def write(self, oprot):
27338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27340 
      return
6031 rajveer 27341 
    oprot.writeStructBegin('getUserWallet_args')
27342 
    if self.userId is not None:
27343 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27344 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27345 
      oprot.writeFieldEnd()
27346 
    oprot.writeFieldStop()
27347 
    oprot.writeStructEnd()
27348 
 
27349 
  def validate(self):
27350 
    return
27351 
 
27352 
 
27353 
  def __repr__(self):
27354 
    L = ['%s=%r' % (key, value)
27355 
      for key, value in self.__dict__.iteritems()]
27356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27357 
 
27358 
  def __eq__(self, other):
27359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27360 
 
27361 
  def __ne__(self, other):
27362 
    return not (self == other)
27363 
 
6031 rajveer 27364 
class getUserWallet_result:
6000 mandeep.dh 27365 
  """
27366 
  Attributes:
27367 
   - success
27368 
  """
27369 
 
27370 
  thrift_spec = (
6031 rajveer 27371 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27372 
  )
27373 
 
27374 
  def __init__(self, success=None,):
27375 
    self.success = success
27376 
 
27377 
  def read(self, iprot):
27378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27380 
      return
27381 
    iprot.readStructBegin()
27382 
    while True:
27383 
      (fname, ftype, fid) = iprot.readFieldBegin()
27384 
      if ftype == TType.STOP:
27385 
        break
27386 
      if fid == 0:
6031 rajveer 27387 
        if ftype == TType.STRUCT:
27388 
          self.success = UserWallet()
27389 
          self.success.read(iprot)
6000 mandeep.dh 27390 
        else:
27391 
          iprot.skip(ftype)
27392 
      else:
27393 
        iprot.skip(ftype)
27394 
      iprot.readFieldEnd()
27395 
    iprot.readStructEnd()
27396 
 
27397 
  def write(self, oprot):
27398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27400 
      return
6031 rajveer 27401 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27402 
    if self.success is not None:
6031 rajveer 27403 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27404 
      self.success.write(oprot)
6000 mandeep.dh 27405 
      oprot.writeFieldEnd()
27406 
    oprot.writeFieldStop()
27407 
    oprot.writeStructEnd()
27408 
 
27409 
  def validate(self):
27410 
    return
27411 
 
27412 
 
27413 
  def __repr__(self):
27414 
    L = ['%s=%r' % (key, value)
27415 
      for key, value in self.__dict__.iteritems()]
27416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27417 
 
27418 
  def __eq__(self, other):
27419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27420 
 
27421 
  def __ne__(self, other):
27422 
    return not (self == other)
27423 
 
6031 rajveer 27424 
class getUserWalletHistory_args:
6000 mandeep.dh 27425 
  """
27426 
  Attributes:
6031 rajveer 27427 
   - userId
6000 mandeep.dh 27428 
  """
27429 
 
27430 
  thrift_spec = (
27431 
    None, # 0
6031 rajveer 27432 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27433 
  )
27434 
 
6031 rajveer 27435 
  def __init__(self, userId=None,):
27436 
    self.userId = userId
6000 mandeep.dh 27437 
 
27438 
  def read(self, iprot):
27439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27441 
      return
27442 
    iprot.readStructBegin()
27443 
    while True:
27444 
      (fname, ftype, fid) = iprot.readFieldBegin()
27445 
      if ftype == TType.STOP:
27446 
        break
27447 
      if fid == 1:
27448 
        if ftype == TType.I64:
6031 rajveer 27449 
          self.userId = iprot.readI64();
6000 mandeep.dh 27450 
        else:
27451 
          iprot.skip(ftype)
27452 
      else:
27453 
        iprot.skip(ftype)
27454 
      iprot.readFieldEnd()
27455 
    iprot.readStructEnd()
27456 
 
27457 
  def write(self, oprot):
27458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27460 
      return
6031 rajveer 27461 
    oprot.writeStructBegin('getUserWalletHistory_args')
27462 
    if self.userId is not None:
27463 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27464 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27465 
      oprot.writeFieldEnd()
27466 
    oprot.writeFieldStop()
27467 
    oprot.writeStructEnd()
27468 
 
27469 
  def validate(self):
27470 
    return
27471 
 
27472 
 
27473 
  def __repr__(self):
27474 
    L = ['%s=%r' % (key, value)
27475 
      for key, value in self.__dict__.iteritems()]
27476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27477 
 
27478 
  def __eq__(self, other):
27479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27480 
 
27481 
  def __ne__(self, other):
27482 
    return not (self == other)
27483 
 
6031 rajveer 27484 
class getUserWalletHistory_result:
6000 mandeep.dh 27485 
  """
27486 
  Attributes:
27487 
   - success
27488 
  """
27489 
 
27490 
  thrift_spec = (
6031 rajveer 27491 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27492 
  )
27493 
 
27494 
  def __init__(self, success=None,):
27495 
    self.success = success
27496 
 
27497 
  def read(self, iprot):
27498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27500 
      return
27501 
    iprot.readStructBegin()
27502 
    while True:
27503 
      (fname, ftype, fid) = iprot.readFieldBegin()
27504 
      if ftype == TType.STOP:
27505 
        break
27506 
      if fid == 0:
27507 
        if ftype == TType.LIST:
27508 
          self.success = []
6188 rajveer 27509 
          (_etype666, _size663) = iprot.readListBegin()
27510 
          for _i667 in xrange(_size663):
27511 
            _elem668 = UserWalletHistory()
27512 
            _elem668.read(iprot)
27513 
            self.success.append(_elem668)
6000 mandeep.dh 27514 
          iprot.readListEnd()
27515 
        else:
27516 
          iprot.skip(ftype)
27517 
      else:
27518 
        iprot.skip(ftype)
27519 
      iprot.readFieldEnd()
27520 
    iprot.readStructEnd()
27521 
 
27522 
  def write(self, oprot):
27523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27525 
      return
6031 rajveer 27526 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27527 
    if self.success is not None:
27528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27529 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27530 
      for iter669 in self.success:
27531 
        iter669.write(oprot)
6000 mandeep.dh 27532 
      oprot.writeListEnd()
27533 
      oprot.writeFieldEnd()
27534 
    oprot.writeFieldStop()
27535 
    oprot.writeStructEnd()
27536 
 
27537 
  def validate(self):
27538 
    return
27539 
 
27540 
 
27541 
  def __repr__(self):
27542 
    L = ['%s=%r' % (key, value)
27543 
      for key, value in self.__dict__.iteritems()]
27544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27545 
 
27546 
  def __eq__(self, other):
27547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27548 
 
27549 
  def __ne__(self, other):
27550 
    return not (self == other)
6048 rajveer 27551 
 
6050 anupam.sin 27552 
class getRechargeOrdersForTransaction_args:
27553 
  """
27554 
  Attributes:
27555 
   - txnId
27556 
  """
27557 
 
27558 
  thrift_spec = (
27559 
    None, # 0
27560 
    (1, TType.I64, 'txnId', None, None, ), # 1
27561 
  )
27562 
 
27563 
  def __init__(self, txnId=None,):
27564 
    self.txnId = txnId
27565 
 
27566 
  def read(self, iprot):
27567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27569 
      return
27570 
    iprot.readStructBegin()
27571 
    while True:
27572 
      (fname, ftype, fid) = iprot.readFieldBegin()
27573 
      if ftype == TType.STOP:
27574 
        break
27575 
      if fid == 1:
27576 
        if ftype == TType.I64:
27577 
          self.txnId = iprot.readI64();
27578 
        else:
27579 
          iprot.skip(ftype)
27580 
      else:
27581 
        iprot.skip(ftype)
27582 
      iprot.readFieldEnd()
27583 
    iprot.readStructEnd()
27584 
 
27585 
  def write(self, oprot):
27586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27588 
      return
27589 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27590 
    if self.txnId is not None:
27591 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27592 
      oprot.writeI64(self.txnId)
27593 
      oprot.writeFieldEnd()
27594 
    oprot.writeFieldStop()
27595 
    oprot.writeStructEnd()
27596 
 
27597 
  def validate(self):
27598 
    return
27599 
 
27600 
 
27601 
  def __repr__(self):
27602 
    L = ['%s=%r' % (key, value)
27603 
      for key, value in self.__dict__.iteritems()]
27604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27605 
 
27606 
  def __eq__(self, other):
27607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27608 
 
27609 
  def __ne__(self, other):
27610 
    return not (self == other)
27611 
 
27612 
class getRechargeOrdersForTransaction_result:
27613 
  """
27614 
  Attributes:
27615 
   - success
27616 
   - ex
27617 
  """
27618 
 
27619 
  thrift_spec = (
27620 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27621 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27622 
  )
27623 
 
27624 
  def __init__(self, success=None, ex=None,):
27625 
    self.success = success
27626 
    self.ex = ex
27627 
 
27628 
  def read(self, iprot):
27629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27631 
      return
27632 
    iprot.readStructBegin()
27633 
    while True:
27634 
      (fname, ftype, fid) = iprot.readFieldBegin()
27635 
      if ftype == TType.STOP:
27636 
        break
27637 
      if fid == 0:
27638 
        if ftype == TType.STRUCT:
27639 
          self.success = RechargeOrder()
27640 
          self.success.read(iprot)
27641 
        else:
27642 
          iprot.skip(ftype)
27643 
      elif fid == 1:
27644 
        if ftype == TType.STRUCT:
27645 
          self.ex = TransactionServiceException()
27646 
          self.ex.read(iprot)
27647 
        else:
27648 
          iprot.skip(ftype)
27649 
      else:
27650 
        iprot.skip(ftype)
27651 
      iprot.readFieldEnd()
27652 
    iprot.readStructEnd()
27653 
 
27654 
  def write(self, oprot):
27655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27657 
      return
27658 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27659 
    if self.success is not None:
27660 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27661 
      self.success.write(oprot)
27662 
      oprot.writeFieldEnd()
27663 
    if self.ex is not None:
27664 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27665 
      self.ex.write(oprot)
27666 
      oprot.writeFieldEnd()
27667 
    oprot.writeFieldStop()
27668 
    oprot.writeStructEnd()
27669 
 
27670 
  def validate(self):
27671 
    return
27672 
 
27673 
 
27674 
  def __repr__(self):
27675 
    L = ['%s=%r' % (key, value)
27676 
      for key, value in self.__dict__.iteritems()]
27677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27678 
 
27679 
  def __eq__(self, other):
27680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27681 
 
27682 
  def __ne__(self, other):
27683 
    return not (self == other)
27684 
 
6048 rajveer 27685 
class getServiceProviders_args:
27686 
  """
27687 
  Attributes:
27688 
   - rechargeType
6206 rajveer 27689 
   - onlyActive
6048 rajveer 27690 
  """
27691 
 
27692 
  thrift_spec = (
27693 
    None, # 0
27694 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27695 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27696 
  )
27697 
 
6206 rajveer 27698 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27699 
    self.rechargeType = rechargeType
6206 rajveer 27700 
    self.onlyActive = onlyActive
6048 rajveer 27701 
 
27702 
  def read(self, iprot):
27703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27705 
      return
27706 
    iprot.readStructBegin()
27707 
    while True:
27708 
      (fname, ftype, fid) = iprot.readFieldBegin()
27709 
      if ftype == TType.STOP:
27710 
        break
27711 
      if fid == 1:
27712 
        if ftype == TType.I32:
27713 
          self.rechargeType = iprot.readI32();
27714 
        else:
27715 
          iprot.skip(ftype)
6206 rajveer 27716 
      elif fid == 2:
27717 
        if ftype == TType.BOOL:
27718 
          self.onlyActive = iprot.readBool();
27719 
        else:
27720 
          iprot.skip(ftype)
6048 rajveer 27721 
      else:
27722 
        iprot.skip(ftype)
27723 
      iprot.readFieldEnd()
27724 
    iprot.readStructEnd()
27725 
 
27726 
  def write(self, oprot):
27727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27729 
      return
27730 
    oprot.writeStructBegin('getServiceProviders_args')
27731 
    if self.rechargeType is not None:
27732 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27733 
      oprot.writeI32(self.rechargeType)
27734 
      oprot.writeFieldEnd()
6206 rajveer 27735 
    if self.onlyActive is not None:
27736 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27737 
      oprot.writeBool(self.onlyActive)
27738 
      oprot.writeFieldEnd()
6048 rajveer 27739 
    oprot.writeFieldStop()
27740 
    oprot.writeStructEnd()
27741 
 
27742 
  def validate(self):
27743 
    return
27744 
 
27745 
 
27746 
  def __repr__(self):
27747 
    L = ['%s=%r' % (key, value)
27748 
      for key, value in self.__dict__.iteritems()]
27749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27750 
 
27751 
  def __eq__(self, other):
27752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27753 
 
27754 
  def __ne__(self, other):
27755 
    return not (self == other)
27756 
 
27757 
class getServiceProviders_result:
27758 
  """
27759 
  Attributes:
27760 
   - success
27761 
  """
27762 
 
27763 
  thrift_spec = (
27764 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27765 
  )
27766 
 
27767 
  def __init__(self, success=None,):
27768 
    self.success = success
27769 
 
27770 
  def read(self, iprot):
27771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27773 
      return
27774 
    iprot.readStructBegin()
27775 
    while True:
27776 
      (fname, ftype, fid) = iprot.readFieldBegin()
27777 
      if ftype == TType.STOP:
27778 
        break
27779 
      if fid == 0:
27780 
        if ftype == TType.MAP:
27781 
          self.success = {}
6188 rajveer 27782 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27783 
          for _i674 in xrange(_size670):
27784 
            _key675 = iprot.readI64();
27785 
            _val676 = iprot.readString();
27786 
            self.success[_key675] = _val676
6048 rajveer 27787 
          iprot.readMapEnd()
27788 
        else:
27789 
          iprot.skip(ftype)
27790 
      else:
27791 
        iprot.skip(ftype)
27792 
      iprot.readFieldEnd()
27793 
    iprot.readStructEnd()
27794 
 
27795 
  def write(self, oprot):
27796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27798 
      return
27799 
    oprot.writeStructBegin('getServiceProviders_result')
27800 
    if self.success is not None:
27801 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27802 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27803 
      for kiter677,viter678 in self.success.items():
27804 
        oprot.writeI64(kiter677)
27805 
        oprot.writeString(viter678)
6048 rajveer 27806 
      oprot.writeMapEnd()
27807 
      oprot.writeFieldEnd()
27808 
    oprot.writeFieldStop()
27809 
    oprot.writeStructEnd()
27810 
 
27811 
  def validate(self):
27812 
    return
27813 
 
27814 
 
27815 
  def __repr__(self):
27816 
    L = ['%s=%r' % (key, value)
27817 
      for key, value in self.__dict__.iteritems()]
27818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27819 
 
27820 
  def __eq__(self, other):
27821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27822 
 
27823 
  def __ne__(self, other):
27824 
    return not (self == other)
27825 
 
27826 
class getServiceProviderForDevice_args:
27827 
  """
27828 
  Attributes:
6049 rajveer 27829 
   - rechargeType
6048 rajveer 27830 
   - deviceNumber
27831 
  """
27832 
 
27833 
  thrift_spec = (
27834 
    None, # 0
6049 rajveer 27835 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27836 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27837 
  )
27838 
 
6049 rajveer 27839 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27840 
    self.rechargeType = rechargeType
6048 rajveer 27841 
    self.deviceNumber = deviceNumber
27842 
 
27843 
  def read(self, iprot):
27844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27846 
      return
27847 
    iprot.readStructBegin()
27848 
    while True:
27849 
      (fname, ftype, fid) = iprot.readFieldBegin()
27850 
      if ftype == TType.STOP:
27851 
        break
27852 
      if fid == 1:
6049 rajveer 27853 
        if ftype == TType.I32:
27854 
          self.rechargeType = iprot.readI32();
27855 
        else:
27856 
          iprot.skip(ftype)
27857 
      elif fid == 2:
6048 rajveer 27858 
        if ftype == TType.STRING:
27859 
          self.deviceNumber = iprot.readString();
27860 
        else:
27861 
          iprot.skip(ftype)
27862 
      else:
27863 
        iprot.skip(ftype)
27864 
      iprot.readFieldEnd()
27865 
    iprot.readStructEnd()
27866 
 
27867 
  def write(self, oprot):
27868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27870 
      return
27871 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27872 
    if self.rechargeType is not None:
27873 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27874 
      oprot.writeI32(self.rechargeType)
27875 
      oprot.writeFieldEnd()
6048 rajveer 27876 
    if self.deviceNumber is not None:
6049 rajveer 27877 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27878 
      oprot.writeString(self.deviceNumber)
27879 
      oprot.writeFieldEnd()
27880 
    oprot.writeFieldStop()
27881 
    oprot.writeStructEnd()
27882 
 
27883 
  def validate(self):
27884 
    return
27885 
 
27886 
 
27887 
  def __repr__(self):
27888 
    L = ['%s=%r' % (key, value)
27889 
      for key, value in self.__dict__.iteritems()]
27890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27891 
 
27892 
  def __eq__(self, other):
27893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27894 
 
27895 
  def __ne__(self, other):
27896 
    return not (self == other)
27897 
 
27898 
class getServiceProviderForDevice_result:
27899 
  """
27900 
  Attributes:
27901 
   - success
27902 
  """
27903 
 
27904 
  thrift_spec = (
6289 anupam.sin 27905 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27906 
  )
27907 
 
27908 
  def __init__(self, success=None,):
27909 
    self.success = success
27910 
 
27911 
  def read(self, iprot):
27912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27914 
      return
27915 
    iprot.readStructBegin()
27916 
    while True:
27917 
      (fname, ftype, fid) = iprot.readFieldBegin()
27918 
      if ftype == TType.STOP:
27919 
        break
27920 
      if fid == 0:
6289 anupam.sin 27921 
        if ftype == TType.STRUCT:
27922 
          self.success = DeviceNumberInfo()
27923 
          self.success.read(iprot)
6048 rajveer 27924 
        else:
27925 
          iprot.skip(ftype)
27926 
      else:
27927 
        iprot.skip(ftype)
27928 
      iprot.readFieldEnd()
27929 
    iprot.readStructEnd()
27930 
 
27931 
  def write(self, oprot):
27932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27934 
      return
27935 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27936 
    if self.success is not None:
6289 anupam.sin 27937 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27938 
      self.success.write(oprot)
6048 rajveer 27939 
      oprot.writeFieldEnd()
27940 
    oprot.writeFieldStop()
27941 
    oprot.writeStructEnd()
27942 
 
27943 
  def validate(self):
27944 
    return
27945 
 
27946 
 
27947 
  def __repr__(self):
27948 
    L = ['%s=%r' % (key, value)
27949 
      for key, value in self.__dict__.iteritems()]
27950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27951 
 
27952 
  def __eq__(self, other):
27953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27954 
 
27955 
  def __ne__(self, other):
27956 
    return not (self == other)
6094 rajveer 27957 
 
6269 rajveer 27958 
class validateRecharge_args:
27959 
  """
27960 
  Attributes:
27961 
   - rechargeType
27962 
   - deviceNumber
6307 anupam.sin 27963 
   - userSelectedProviderId
6269 rajveer 27964 
  """
27965 
 
27966 
  thrift_spec = (
27967 
    None, # 0
27968 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27969 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 27970 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6269 rajveer 27971 
  )
27972 
 
6336 anupam.sin 27973 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None,):
6269 rajveer 27974 
    self.rechargeType = rechargeType
27975 
    self.deviceNumber = deviceNumber
6307 anupam.sin 27976 
    self.userSelectedProviderId = userSelectedProviderId
6269 rajveer 27977 
 
27978 
  def read(self, iprot):
27979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27981 
      return
27982 
    iprot.readStructBegin()
27983 
    while True:
27984 
      (fname, ftype, fid) = iprot.readFieldBegin()
27985 
      if ftype == TType.STOP:
27986 
        break
27987 
      if fid == 1:
27988 
        if ftype == TType.I32:
27989 
          self.rechargeType = iprot.readI32();
27990 
        else:
27991 
          iprot.skip(ftype)
27992 
      elif fid == 2:
27993 
        if ftype == TType.STRING:
27994 
          self.deviceNumber = iprot.readString();
27995 
        else:
27996 
          iprot.skip(ftype)
6307 anupam.sin 27997 
      elif fid == 3:
27998 
        if ftype == TType.I64:
27999 
          self.userSelectedProviderId = iprot.readI64();
28000 
        else:
28001 
          iprot.skip(ftype)
6269 rajveer 28002 
      else:
28003 
        iprot.skip(ftype)
28004 
      iprot.readFieldEnd()
28005 
    iprot.readStructEnd()
28006 
 
28007 
  def write(self, oprot):
28008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28010 
      return
28011 
    oprot.writeStructBegin('validateRecharge_args')
28012 
    if self.rechargeType is not None:
28013 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28014 
      oprot.writeI32(self.rechargeType)
28015 
      oprot.writeFieldEnd()
28016 
    if self.deviceNumber is not None:
28017 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28018 
      oprot.writeString(self.deviceNumber)
28019 
      oprot.writeFieldEnd()
6307 anupam.sin 28020 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28021 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28022 
      oprot.writeI64(self.userSelectedProviderId)
28023 
      oprot.writeFieldEnd()
6269 rajveer 28024 
    oprot.writeFieldStop()
28025 
    oprot.writeStructEnd()
28026 
 
28027 
  def validate(self):
28028 
    return
28029 
 
28030 
 
28031 
  def __repr__(self):
28032 
    L = ['%s=%r' % (key, value)
28033 
      for key, value in self.__dict__.iteritems()]
28034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28035 
 
28036 
  def __eq__(self, other):
28037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28038 
 
28039 
  def __ne__(self, other):
28040 
    return not (self == other)
28041 
 
28042 
class validateRecharge_result:
28043 
  """
28044 
  Attributes:
28045 
   - success
28046 
  """
28047 
 
28048 
  thrift_spec = (
28049 
    (0, TType.STRING, 'success', None, None, ), # 0
28050 
  )
28051 
 
28052 
  def __init__(self, success=None,):
28053 
    self.success = success
28054 
 
28055 
  def read(self, iprot):
28056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28058 
      return
28059 
    iprot.readStructBegin()
28060 
    while True:
28061 
      (fname, ftype, fid) = iprot.readFieldBegin()
28062 
      if ftype == TType.STOP:
28063 
        break
28064 
      if fid == 0:
28065 
        if ftype == TType.STRING:
28066 
          self.success = iprot.readString();
28067 
        else:
28068 
          iprot.skip(ftype)
28069 
      else:
28070 
        iprot.skip(ftype)
28071 
      iprot.readFieldEnd()
28072 
    iprot.readStructEnd()
28073 
 
28074 
  def write(self, oprot):
28075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28077 
      return
28078 
    oprot.writeStructBegin('validateRecharge_result')
28079 
    if self.success is not None:
28080 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28081 
      oprot.writeString(self.success)
28082 
      oprot.writeFieldEnd()
28083 
    oprot.writeFieldStop()
28084 
    oprot.writeStructEnd()
28085 
 
28086 
  def validate(self):
28087 
    return
28088 
 
28089 
 
28090 
  def __repr__(self):
28091 
    L = ['%s=%r' % (key, value)
28092 
      for key, value in self.__dict__.iteritems()]
28093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28094 
 
28095 
  def __eq__(self, other):
28096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28097 
 
28098 
  def __ne__(self, other):
28099 
    return not (self == other)
28100 
 
6094 rajveer 28101 
class getRechargeOrdersForDevice_args:
28102 
  """
28103 
  Attributes:
28104 
   - deviceNumber
28105 
  """
28106 
 
28107 
  thrift_spec = (
28108 
    None, # 0
28109 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28110 
  )
28111 
 
28112 
  def __init__(self, deviceNumber=None,):
28113 
    self.deviceNumber = deviceNumber
28114 
 
28115 
  def read(self, iprot):
28116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28118 
      return
28119 
    iprot.readStructBegin()
28120 
    while True:
28121 
      (fname, ftype, fid) = iprot.readFieldBegin()
28122 
      if ftype == TType.STOP:
28123 
        break
28124 
      if fid == 1:
28125 
        if ftype == TType.STRING:
28126 
          self.deviceNumber = iprot.readString();
28127 
        else:
28128 
          iprot.skip(ftype)
28129 
      else:
28130 
        iprot.skip(ftype)
28131 
      iprot.readFieldEnd()
28132 
    iprot.readStructEnd()
28133 
 
28134 
  def write(self, oprot):
28135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28137 
      return
28138 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28139 
    if self.deviceNumber is not None:
28140 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28141 
      oprot.writeString(self.deviceNumber)
28142 
      oprot.writeFieldEnd()
28143 
    oprot.writeFieldStop()
28144 
    oprot.writeStructEnd()
28145 
 
28146 
  def validate(self):
28147 
    return
28148 
 
28149 
 
28150 
  def __repr__(self):
28151 
    L = ['%s=%r' % (key, value)
28152 
      for key, value in self.__dict__.iteritems()]
28153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28154 
 
28155 
  def __eq__(self, other):
28156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28157 
 
28158 
  def __ne__(self, other):
28159 
    return not (self == other)
28160 
 
28161 
class getRechargeOrdersForDevice_result:
28162 
  """
28163 
  Attributes:
28164 
   - success
28165 
  """
28166 
 
28167 
  thrift_spec = (
28168 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28169 
  )
28170 
 
28171 
  def __init__(self, success=None,):
28172 
    self.success = success
28173 
 
28174 
  def read(self, iprot):
28175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28177 
      return
28178 
    iprot.readStructBegin()
28179 
    while True:
28180 
      (fname, ftype, fid) = iprot.readFieldBegin()
28181 
      if ftype == TType.STOP:
28182 
        break
28183 
      if fid == 0:
28184 
        if ftype == TType.LIST:
28185 
          self.success = []
6188 rajveer 28186 
          (_etype682, _size679) = iprot.readListBegin()
28187 
          for _i683 in xrange(_size679):
28188 
            _elem684 = RechargeOrder()
28189 
            _elem684.read(iprot)
28190 
            self.success.append(_elem684)
6094 rajveer 28191 
          iprot.readListEnd()
28192 
        else:
28193 
          iprot.skip(ftype)
28194 
      else:
28195 
        iprot.skip(ftype)
28196 
      iprot.readFieldEnd()
28197 
    iprot.readStructEnd()
28198 
 
28199 
  def write(self, oprot):
28200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28202 
      return
28203 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28204 
    if self.success is not None:
28205 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28206 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28207 
      for iter685 in self.success:
28208 
        iter685.write(oprot)
6094 rajveer 28209 
      oprot.writeListEnd()
28210 
      oprot.writeFieldEnd()
28211 
    oprot.writeFieldStop()
28212 
    oprot.writeStructEnd()
28213 
 
28214 
  def validate(self):
28215 
    return
28216 
 
28217 
 
28218 
  def __repr__(self):
28219 
    L = ['%s=%r' % (key, value)
28220 
      for key, value in self.__dict__.iteritems()]
28221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28222 
 
28223 
  def __eq__(self, other):
28224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28225 
 
28226 
  def __ne__(self, other):
28227 
    return not (self == other)
28228 
 
28229 
class addAmountToWallet_args:
28230 
  """
28231 
  Attributes:
28232 
   - userId
28233 
   - orderId
28234 
   - amount
28235 
  """
28236 
 
28237 
  thrift_spec = (
28238 
    None, # 0
28239 
    (1, TType.I64, 'userId', None, None, ), # 1
28240 
    (2, TType.I64, 'orderId', None, None, ), # 2
28241 
    (3, TType.I64, 'amount', None, None, ), # 3
28242 
  )
28243 
 
28244 
  def __init__(self, userId=None, orderId=None, amount=None,):
28245 
    self.userId = userId
28246 
    self.orderId = orderId
28247 
    self.amount = amount
28248 
 
28249 
  def read(self, iprot):
28250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28252 
      return
28253 
    iprot.readStructBegin()
28254 
    while True:
28255 
      (fname, ftype, fid) = iprot.readFieldBegin()
28256 
      if ftype == TType.STOP:
28257 
        break
28258 
      if fid == 1:
28259 
        if ftype == TType.I64:
28260 
          self.userId = iprot.readI64();
28261 
        else:
28262 
          iprot.skip(ftype)
28263 
      elif fid == 2:
28264 
        if ftype == TType.I64:
28265 
          self.orderId = iprot.readI64();
28266 
        else:
28267 
          iprot.skip(ftype)
28268 
      elif fid == 3:
28269 
        if ftype == TType.I64:
28270 
          self.amount = iprot.readI64();
28271 
        else:
28272 
          iprot.skip(ftype)
28273 
      else:
28274 
        iprot.skip(ftype)
28275 
      iprot.readFieldEnd()
28276 
    iprot.readStructEnd()
28277 
 
28278 
  def write(self, oprot):
28279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28281 
      return
28282 
    oprot.writeStructBegin('addAmountToWallet_args')
28283 
    if self.userId is not None:
28284 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28285 
      oprot.writeI64(self.userId)
28286 
      oprot.writeFieldEnd()
28287 
    if self.orderId is not None:
28288 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28289 
      oprot.writeI64(self.orderId)
28290 
      oprot.writeFieldEnd()
28291 
    if self.amount is not None:
28292 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28293 
      oprot.writeI64(self.amount)
28294 
      oprot.writeFieldEnd()
28295 
    oprot.writeFieldStop()
28296 
    oprot.writeStructEnd()
28297 
 
28298 
  def validate(self):
28299 
    return
28300 
 
28301 
 
28302 
  def __repr__(self):
28303 
    L = ['%s=%r' % (key, value)
28304 
      for key, value in self.__dict__.iteritems()]
28305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28306 
 
28307 
  def __eq__(self, other):
28308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28309 
 
28310 
  def __ne__(self, other):
28311 
    return not (self == other)
28312 
 
28313 
class addAmountToWallet_result:
28314 
 
28315 
  thrift_spec = (
28316 
  )
28317 
 
28318 
  def read(self, iprot):
28319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28321 
      return
28322 
    iprot.readStructBegin()
28323 
    while True:
28324 
      (fname, ftype, fid) = iprot.readFieldBegin()
28325 
      if ftype == TType.STOP:
28326 
        break
28327 
      else:
28328 
        iprot.skip(ftype)
28329 
      iprot.readFieldEnd()
28330 
    iprot.readStructEnd()
28331 
 
28332 
  def write(self, oprot):
28333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28335 
      return
28336 
    oprot.writeStructBegin('addAmountToWallet_result')
28337 
    oprot.writeFieldStop()
28338 
    oprot.writeStructEnd()
28339 
 
28340 
  def validate(self):
28341 
    return
28342 
 
28343 
 
28344 
  def __repr__(self):
28345 
    L = ['%s=%r' % (key, value)
28346 
      for key, value in self.__dict__.iteritems()]
28347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28348 
 
28349 
  def __eq__(self, other):
28350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28351 
 
28352 
  def __ne__(self, other):
28353 
    return not (self == other)
6154 rajveer 28354 
 
6188 rajveer 28355 
class getRechargeStatistics_args:
28356 
 
28357 
  thrift_spec = (
28358 
  )
28359 
 
28360 
  def read(self, iprot):
28361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28363 
      return
28364 
    iprot.readStructBegin()
28365 
    while True:
28366 
      (fname, ftype, fid) = iprot.readFieldBegin()
28367 
      if ftype == TType.STOP:
28368 
        break
28369 
      else:
28370 
        iprot.skip(ftype)
28371 
      iprot.readFieldEnd()
28372 
    iprot.readStructEnd()
28373 
 
28374 
  def write(self, oprot):
28375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28377 
      return
28378 
    oprot.writeStructBegin('getRechargeStatistics_args')
28379 
    oprot.writeFieldStop()
28380 
    oprot.writeStructEnd()
28381 
 
28382 
  def validate(self):
28383 
    return
28384 
 
28385 
 
28386 
  def __repr__(self):
28387 
    L = ['%s=%r' % (key, value)
28388 
      for key, value in self.__dict__.iteritems()]
28389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28390 
 
28391 
  def __eq__(self, other):
28392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28393 
 
28394 
  def __ne__(self, other):
28395 
    return not (self == other)
28396 
 
28397 
class getRechargeStatistics_result:
28398 
  """
28399 
  Attributes:
28400 
   - success
28401 
  """
28402 
 
28403 
  thrift_spec = (
28404 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28405 
  )
28406 
 
28407 
  def __init__(self, success=None,):
28408 
    self.success = success
28409 
 
28410 
  def read(self, iprot):
28411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28413 
      return
28414 
    iprot.readStructBegin()
28415 
    while True:
28416 
      (fname, ftype, fid) = iprot.readFieldBegin()
28417 
      if ftype == TType.STOP:
28418 
        break
28419 
      if fid == 0:
28420 
        if ftype == TType.STRUCT:
28421 
          self.success = RechargeStatistics()
28422 
          self.success.read(iprot)
28423 
        else:
28424 
          iprot.skip(ftype)
28425 
      else:
28426 
        iprot.skip(ftype)
28427 
      iprot.readFieldEnd()
28428 
    iprot.readStructEnd()
28429 
 
28430 
  def write(self, oprot):
28431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28433 
      return
28434 
    oprot.writeStructBegin('getRechargeStatistics_result')
28435 
    if self.success is not None:
28436 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28437 
      self.success.write(oprot)
28438 
      oprot.writeFieldEnd()
28439 
    oprot.writeFieldStop()
28440 
    oprot.writeStructEnd()
28441 
 
28442 
  def validate(self):
28443 
    return
28444 
 
28445 
 
28446 
  def __repr__(self):
28447 
    L = ['%s=%r' % (key, value)
28448 
      for key, value in self.__dict__.iteritems()]
28449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28450 
 
28451 
  def __eq__(self, other):
28452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28453 
 
28454 
  def __ne__(self, other):
28455 
    return not (self == other)
28456 
 
6154 rajveer 28457 
class getRechargeOrdersForStatus_args:
28458 
  """
28459 
  Attributes:
28460 
   - status
28461 
  """
28462 
 
28463 
  thrift_spec = (
28464 
    None, # 0
28465 
    (1, TType.I64, 'status', None, None, ), # 1
28466 
  )
28467 
 
28468 
  def __init__(self, status=None,):
28469 
    self.status = status
28470 
 
28471 
  def read(self, iprot):
28472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28474 
      return
28475 
    iprot.readStructBegin()
28476 
    while True:
28477 
      (fname, ftype, fid) = iprot.readFieldBegin()
28478 
      if ftype == TType.STOP:
28479 
        break
28480 
      if fid == 1:
28481 
        if ftype == TType.I64:
28482 
          self.status = iprot.readI64();
28483 
        else:
28484 
          iprot.skip(ftype)
28485 
      else:
28486 
        iprot.skip(ftype)
28487 
      iprot.readFieldEnd()
28488 
    iprot.readStructEnd()
28489 
 
28490 
  def write(self, oprot):
28491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28493 
      return
28494 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28495 
    if self.status is not None:
28496 
      oprot.writeFieldBegin('status', TType.I64, 1)
28497 
      oprot.writeI64(self.status)
28498 
      oprot.writeFieldEnd()
28499 
    oprot.writeFieldStop()
28500 
    oprot.writeStructEnd()
28501 
 
28502 
  def validate(self):
28503 
    return
28504 
 
28505 
 
28506 
  def __repr__(self):
28507 
    L = ['%s=%r' % (key, value)
28508 
      for key, value in self.__dict__.iteritems()]
28509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28510 
 
28511 
  def __eq__(self, other):
28512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28513 
 
28514 
  def __ne__(self, other):
28515 
    return not (self == other)
28516 
 
28517 
class getRechargeOrdersForStatus_result:
28518 
  """
28519 
  Attributes:
28520 
   - success
28521 
  """
28522 
 
28523 
  thrift_spec = (
28524 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28525 
  )
28526 
 
28527 
  def __init__(self, success=None,):
28528 
    self.success = success
28529 
 
28530 
  def read(self, iprot):
28531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28533 
      return
28534 
    iprot.readStructBegin()
28535 
    while True:
28536 
      (fname, ftype, fid) = iprot.readFieldBegin()
28537 
      if ftype == TType.STOP:
28538 
        break
28539 
      if fid == 0:
28540 
        if ftype == TType.LIST:
28541 
          self.success = []
6188 rajveer 28542 
          (_etype689, _size686) = iprot.readListBegin()
28543 
          for _i690 in xrange(_size686):
28544 
            _elem691 = RechargeOrder()
28545 
            _elem691.read(iprot)
28546 
            self.success.append(_elem691)
6154 rajveer 28547 
          iprot.readListEnd()
28548 
        else:
28549 
          iprot.skip(ftype)
28550 
      else:
28551 
        iprot.skip(ftype)
28552 
      iprot.readFieldEnd()
28553 
    iprot.readStructEnd()
28554 
 
28555 
  def write(self, oprot):
28556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28558 
      return
28559 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28560 
    if self.success is not None:
28561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28563 
      for iter692 in self.success:
28564 
        iter692.write(oprot)
6154 rajveer 28565 
      oprot.writeListEnd()
28566 
      oprot.writeFieldEnd()
28567 
    oprot.writeFieldStop()
28568 
    oprot.writeStructEnd()
28569 
 
28570 
  def validate(self):
28571 
    return
28572 
 
28573 
 
28574 
  def __repr__(self):
28575 
    L = ['%s=%r' % (key, value)
28576 
      for key, value in self.__dict__.iteritems()]
28577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28578 
 
28579 
  def __eq__(self, other):
28580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28581 
 
28582 
  def __ne__(self, other):
28583 
    return not (self == other)
6159 rajveer 28584 
 
28585 
class getPlansForOperator_args:
28586 
  """
28587 
  Attributes:
28588 
   - operatorId
28589 
  """
28590 
 
28591 
  thrift_spec = (
28592 
    None, # 0
28593 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28594 
  )
28595 
 
28596 
  def __init__(self, operatorId=None,):
28597 
    self.operatorId = operatorId
28598 
 
28599 
  def read(self, iprot):
28600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28602 
      return
28603 
    iprot.readStructBegin()
28604 
    while True:
28605 
      (fname, ftype, fid) = iprot.readFieldBegin()
28606 
      if ftype == TType.STOP:
28607 
        break
28608 
      if fid == 1:
28609 
        if ftype == TType.I64:
28610 
          self.operatorId = iprot.readI64();
28611 
        else:
28612 
          iprot.skip(ftype)
28613 
      else:
28614 
        iprot.skip(ftype)
28615 
      iprot.readFieldEnd()
28616 
    iprot.readStructEnd()
28617 
 
28618 
  def write(self, oprot):
28619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28621 
      return
28622 
    oprot.writeStructBegin('getPlansForOperator_args')
28623 
    if self.operatorId is not None:
28624 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28625 
      oprot.writeI64(self.operatorId)
28626 
      oprot.writeFieldEnd()
28627 
    oprot.writeFieldStop()
28628 
    oprot.writeStructEnd()
28629 
 
28630 
  def validate(self):
28631 
    return
28632 
 
28633 
 
28634 
  def __repr__(self):
28635 
    L = ['%s=%r' % (key, value)
28636 
      for key, value in self.__dict__.iteritems()]
28637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28638 
 
28639 
  def __eq__(self, other):
28640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28641 
 
28642 
  def __ne__(self, other):
28643 
    return not (self == other)
28644 
 
28645 
class getPlansForOperator_result:
28646 
  """
28647 
  Attributes:
28648 
   - success
28649 
  """
28650 
 
28651 
  thrift_spec = (
28652 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28653 
  )
28654 
 
28655 
  def __init__(self, success=None,):
28656 
    self.success = success
28657 
 
28658 
  def read(self, iprot):
28659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28661 
      return
28662 
    iprot.readStructBegin()
28663 
    while True:
28664 
      (fname, ftype, fid) = iprot.readFieldBegin()
28665 
      if ftype == TType.STOP:
28666 
        break
28667 
      if fid == 0:
28668 
        if ftype == TType.LIST:
28669 
          self.success = []
6188 rajveer 28670 
          (_etype696, _size693) = iprot.readListBegin()
28671 
          for _i697 in xrange(_size693):
28672 
            _elem698 = RechargePlan()
28673 
            _elem698.read(iprot)
28674 
            self.success.append(_elem698)
6159 rajveer 28675 
          iprot.readListEnd()
28676 
        else:
28677 
          iprot.skip(ftype)
28678 
      else:
28679 
        iprot.skip(ftype)
28680 
      iprot.readFieldEnd()
28681 
    iprot.readStructEnd()
28682 
 
28683 
  def write(self, oprot):
28684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28686 
      return
28687 
    oprot.writeStructBegin('getPlansForOperator_result')
28688 
    if self.success is not None:
28689 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28690 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28691 
      for iter699 in self.success:
28692 
        iter699.write(oprot)
6159 rajveer 28693 
      oprot.writeListEnd()
28694 
      oprot.writeFieldEnd()
28695 
    oprot.writeFieldStop()
28696 
    oprot.writeStructEnd()
28697 
 
28698 
  def validate(self):
28699 
    return
28700 
 
28701 
 
28702 
  def __repr__(self):
28703 
    L = ['%s=%r' % (key, value)
28704 
      for key, value in self.__dict__.iteritems()]
28705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28706 
 
28707 
  def __eq__(self, other):
28708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28709 
 
28710 
  def __ne__(self, other):
28711 
    return not (self == other)
6289 anupam.sin 28712 
 
28713 
class getRechargeDenominations_args:
28714 
  """
28715 
  Attributes:
28716 
   - operatorId
6307 anupam.sin 28717 
   - circleCode
6289 anupam.sin 28718 
   - denominationType
28719 
  """
28720 
 
28721 
  thrift_spec = (
28722 
    None, # 0
28723 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28724 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28725 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28726 
  )
28727 
 
6307 anupam.sin 28728 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28729 
    self.operatorId = operatorId
6307 anupam.sin 28730 
    self.circleCode = circleCode
6289 anupam.sin 28731 
    self.denominationType = denominationType
28732 
 
28733 
  def read(self, iprot):
28734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28736 
      return
28737 
    iprot.readStructBegin()
28738 
    while True:
28739 
      (fname, ftype, fid) = iprot.readFieldBegin()
28740 
      if ftype == TType.STOP:
28741 
        break
28742 
      if fid == 1:
28743 
        if ftype == TType.I64:
28744 
          self.operatorId = iprot.readI64();
28745 
        else:
28746 
          iprot.skip(ftype)
28747 
      elif fid == 2:
28748 
        if ftype == TType.STRING:
6307 anupam.sin 28749 
          self.circleCode = iprot.readString();
6289 anupam.sin 28750 
        else:
28751 
          iprot.skip(ftype)
28752 
      elif fid == 3:
28753 
        if ftype == TType.I32:
28754 
          self.denominationType = iprot.readI32();
28755 
        else:
28756 
          iprot.skip(ftype)
28757 
      else:
28758 
        iprot.skip(ftype)
28759 
      iprot.readFieldEnd()
28760 
    iprot.readStructEnd()
28761 
 
28762 
  def write(self, oprot):
28763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28765 
      return
28766 
    oprot.writeStructBegin('getRechargeDenominations_args')
28767 
    if self.operatorId is not None:
28768 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28769 
      oprot.writeI64(self.operatorId)
28770 
      oprot.writeFieldEnd()
6307 anupam.sin 28771 
    if self.circleCode is not None:
28772 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28773 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28774 
      oprot.writeFieldEnd()
28775 
    if self.denominationType is not None:
28776 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28777 
      oprot.writeI32(self.denominationType)
28778 
      oprot.writeFieldEnd()
28779 
    oprot.writeFieldStop()
28780 
    oprot.writeStructEnd()
28781 
 
28782 
  def validate(self):
28783 
    return
28784 
 
28785 
 
28786 
  def __repr__(self):
28787 
    L = ['%s=%r' % (key, value)
28788 
      for key, value in self.__dict__.iteritems()]
28789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28790 
 
28791 
  def __eq__(self, other):
28792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28793 
 
28794 
  def __ne__(self, other):
28795 
    return not (self == other)
28796 
 
28797 
class getRechargeDenominations_result:
28798 
  """
28799 
  Attributes:
28800 
   - success
28801 
   - ex
28802 
  """
28803 
 
28804 
  thrift_spec = (
28805 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28806 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28807 
  )
28808 
 
28809 
  def __init__(self, success=None, ex=None,):
28810 
    self.success = success
28811 
    self.ex = ex
28812 
 
28813 
  def read(self, iprot):
28814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28816 
      return
28817 
    iprot.readStructBegin()
28818 
    while True:
28819 
      (fname, ftype, fid) = iprot.readFieldBegin()
28820 
      if ftype == TType.STOP:
28821 
        break
28822 
      if fid == 0:
28823 
        if ftype == TType.LIST:
28824 
          self.success = []
28825 
          (_etype703, _size700) = iprot.readListBegin()
28826 
          for _i704 in xrange(_size700):
28827 
            _elem705 = RechargeDenomination()
28828 
            _elem705.read(iprot)
28829 
            self.success.append(_elem705)
28830 
          iprot.readListEnd()
28831 
        else:
28832 
          iprot.skip(ftype)
28833 
      elif fid == 1:
28834 
        if ftype == TType.STRUCT:
28835 
          self.ex = TransactionServiceException()
28836 
          self.ex.read(iprot)
28837 
        else:
28838 
          iprot.skip(ftype)
28839 
      else:
28840 
        iprot.skip(ftype)
28841 
      iprot.readFieldEnd()
28842 
    iprot.readStructEnd()
28843 
 
28844 
  def write(self, oprot):
28845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28847 
      return
28848 
    oprot.writeStructBegin('getRechargeDenominations_result')
28849 
    if self.success is not None:
28850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28852 
      for iter706 in self.success:
28853 
        iter706.write(oprot)
28854 
      oprot.writeListEnd()
28855 
      oprot.writeFieldEnd()
28856 
    if self.ex is not None:
28857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28858 
      self.ex.write(oprot)
28859 
      oprot.writeFieldEnd()
28860 
    oprot.writeFieldStop()
28861 
    oprot.writeStructEnd()
28862 
 
28863 
  def validate(self):
28864 
    return
28865 
 
28866 
 
28867 
  def __repr__(self):
28868 
    L = ['%s=%r' % (key, value)
28869 
      for key, value in self.__dict__.iteritems()]
28870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28871 
 
28872 
  def __eq__(self, other):
28873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28874 
 
28875 
  def __ne__(self, other):
28876 
    return not (self == other)
6371 rajveer 28877 
 
28878 
class updateAvailabilityStatus_args:
28879 
  """
28880 
  Attributes:
28881 
   - operatorId
28882 
   - circleId
28883 
   - isAvailable
28884 
  """
28885 
 
28886 
  thrift_spec = (
28887 
    None, # 0
28888 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28889 
    (2, TType.I64, 'circleId', None, None, ), # 2
28890 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
28891 
  )
28892 
 
28893 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
28894 
    self.operatorId = operatorId
28895 
    self.circleId = circleId
28896 
    self.isAvailable = isAvailable
28897 
 
28898 
  def read(self, iprot):
28899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28901 
      return
28902 
    iprot.readStructBegin()
28903 
    while True:
28904 
      (fname, ftype, fid) = iprot.readFieldBegin()
28905 
      if ftype == TType.STOP:
28906 
        break
28907 
      if fid == 1:
28908 
        if ftype == TType.I64:
28909 
          self.operatorId = iprot.readI64();
28910 
        else:
28911 
          iprot.skip(ftype)
28912 
      elif fid == 2:
28913 
        if ftype == TType.I64:
28914 
          self.circleId = iprot.readI64();
28915 
        else:
28916 
          iprot.skip(ftype)
28917 
      elif fid == 3:
28918 
        if ftype == TType.BOOL:
28919 
          self.isAvailable = iprot.readBool();
28920 
        else:
28921 
          iprot.skip(ftype)
28922 
      else:
28923 
        iprot.skip(ftype)
28924 
      iprot.readFieldEnd()
28925 
    iprot.readStructEnd()
28926 
 
28927 
  def write(self, oprot):
28928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28930 
      return
28931 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
28932 
    if self.operatorId is not None:
28933 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28934 
      oprot.writeI64(self.operatorId)
28935 
      oprot.writeFieldEnd()
28936 
    if self.circleId is not None:
28937 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
28938 
      oprot.writeI64(self.circleId)
28939 
      oprot.writeFieldEnd()
28940 
    if self.isAvailable is not None:
28941 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
28942 
      oprot.writeBool(self.isAvailable)
28943 
      oprot.writeFieldEnd()
28944 
    oprot.writeFieldStop()
28945 
    oprot.writeStructEnd()
28946 
 
28947 
  def validate(self):
28948 
    return
28949 
 
28950 
 
28951 
  def __repr__(self):
28952 
    L = ['%s=%r' % (key, value)
28953 
      for key, value in self.__dict__.iteritems()]
28954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28955 
 
28956 
  def __eq__(self, other):
28957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28958 
 
28959 
  def __ne__(self, other):
28960 
    return not (self == other)
28961 
 
28962 
class updateAvailabilityStatus_result:
28963 
 
28964 
  thrift_spec = (
28965 
  )
28966 
 
28967 
  def read(self, iprot):
28968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28970 
      return
28971 
    iprot.readStructBegin()
28972 
    while True:
28973 
      (fname, ftype, fid) = iprot.readFieldBegin()
28974 
      if ftype == TType.STOP:
28975 
        break
28976 
      else:
28977 
        iprot.skip(ftype)
28978 
      iprot.readFieldEnd()
28979 
    iprot.readStructEnd()
28980 
 
28981 
  def write(self, oprot):
28982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28984 
      return
28985 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
28986 
    oprot.writeFieldStop()
28987 
    oprot.writeStructEnd()
28988 
 
28989 
  def validate(self):
28990 
    return
28991 
 
28992 
 
28993 
  def __repr__(self):
28994 
    L = ['%s=%r' % (key, value)
28995 
      for key, value in self.__dict__.iteritems()]
28996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28997 
 
28998 
  def __eq__(self, other):
28999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29000 
 
29001 
  def __ne__(self, other):
29002 
    return not (self == other)
6389 rajveer 29003 
 
29004 
class getAvailableEmiSchemes_args:
29005 
 
29006 
  thrift_spec = (
29007 
  )
29008 
 
29009 
  def read(self, iprot):
29010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29012 
      return
29013 
    iprot.readStructBegin()
29014 
    while True:
29015 
      (fname, ftype, fid) = iprot.readFieldBegin()
29016 
      if ftype == TType.STOP:
29017 
        break
29018 
      else:
29019 
        iprot.skip(ftype)
29020 
      iprot.readFieldEnd()
29021 
    iprot.readStructEnd()
29022 
 
29023 
  def write(self, oprot):
29024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29026 
      return
29027 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29028 
    oprot.writeFieldStop()
29029 
    oprot.writeStructEnd()
29030 
 
29031 
  def validate(self):
29032 
    return
29033 
 
29034 
 
29035 
  def __repr__(self):
29036 
    L = ['%s=%r' % (key, value)
29037 
      for key, value in self.__dict__.iteritems()]
29038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29039 
 
29040 
  def __eq__(self, other):
29041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29042 
 
29043 
  def __ne__(self, other):
29044 
    return not (self == other)
29045 
 
29046 
class getAvailableEmiSchemes_result:
29047 
  """
29048 
  Attributes:
29049 
   - success
29050 
  """
29051 
 
29052 
  thrift_spec = (
29053 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29054 
  )
29055 
 
29056 
  def __init__(self, success=None,):
29057 
    self.success = success
29058 
 
29059 
  def read(self, iprot):
29060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29062 
      return
29063 
    iprot.readStructBegin()
29064 
    while True:
29065 
      (fname, ftype, fid) = iprot.readFieldBegin()
29066 
      if ftype == TType.STOP:
29067 
        break
29068 
      if fid == 0:
29069 
        if ftype == TType.LIST:
29070 
          self.success = []
29071 
          (_etype710, _size707) = iprot.readListBegin()
29072 
          for _i711 in xrange(_size707):
29073 
            _elem712 = EmiScheme()
29074 
            _elem712.read(iprot)
29075 
            self.success.append(_elem712)
29076 
          iprot.readListEnd()
29077 
        else:
29078 
          iprot.skip(ftype)
29079 
      else:
29080 
        iprot.skip(ftype)
29081 
      iprot.readFieldEnd()
29082 
    iprot.readStructEnd()
29083 
 
29084 
  def write(self, oprot):
29085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29087 
      return
29088 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29089 
    if self.success is not None:
29090 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29091 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29092 
      for iter713 in self.success:
29093 
        iter713.write(oprot)
29094 
      oprot.writeListEnd()
29095 
      oprot.writeFieldEnd()
29096 
    oprot.writeFieldStop()
29097 
    oprot.writeStructEnd()
29098 
 
29099 
  def validate(self):
29100 
    return
29101 
 
29102 
 
29103 
  def __repr__(self):
29104 
    L = ['%s=%r' % (key, value)
29105 
      for key, value in self.__dict__.iteritems()]
29106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29107 
 
29108 
  def __eq__(self, other):
29109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29110 
 
29111 
  def __ne__(self, other):
29112 
    return not (self == other)
29113 
 
29114 
class getMiscCharges_args:
29115 
  """
29116 
  Attributes:
29117 
   - transactionId
29118 
  """
29119 
 
29120 
  thrift_spec = (
29121 
    None, # 0
29122 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29123 
  )
29124 
 
29125 
  def __init__(self, transactionId=None,):
29126 
    self.transactionId = transactionId
29127 
 
29128 
  def read(self, iprot):
29129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29131 
      return
29132 
    iprot.readStructBegin()
29133 
    while True:
29134 
      (fname, ftype, fid) = iprot.readFieldBegin()
29135 
      if ftype == TType.STOP:
29136 
        break
29137 
      if fid == 1:
29138 
        if ftype == TType.I64:
29139 
          self.transactionId = iprot.readI64();
29140 
        else:
29141 
          iprot.skip(ftype)
29142 
      else:
29143 
        iprot.skip(ftype)
29144 
      iprot.readFieldEnd()
29145 
    iprot.readStructEnd()
29146 
 
29147 
  def write(self, oprot):
29148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29150 
      return
29151 
    oprot.writeStructBegin('getMiscCharges_args')
29152 
    if self.transactionId is not None:
29153 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29154 
      oprot.writeI64(self.transactionId)
29155 
      oprot.writeFieldEnd()
29156 
    oprot.writeFieldStop()
29157 
    oprot.writeStructEnd()
29158 
 
29159 
  def validate(self):
29160 
    return
29161 
 
29162 
 
29163 
  def __repr__(self):
29164 
    L = ['%s=%r' % (key, value)
29165 
      for key, value in self.__dict__.iteritems()]
29166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29167 
 
29168 
  def __eq__(self, other):
29169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29170 
 
29171 
  def __ne__(self, other):
29172 
    return not (self == other)
29173 
 
29174 
class getMiscCharges_result:
29175 
  """
29176 
  Attributes:
29177 
   - success
29178 
  """
29179 
 
29180 
  thrift_spec = (
29181 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
29182 
  )
29183 
 
29184 
  def __init__(self, success=None,):
29185 
    self.success = success
29186 
 
29187 
  def read(self, iprot):
29188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29190 
      return
29191 
    iprot.readStructBegin()
29192 
    while True:
29193 
      (fname, ftype, fid) = iprot.readFieldBegin()
29194 
      if ftype == TType.STOP:
29195 
        break
29196 
      if fid == 0:
29197 
        if ftype == TType.MAP:
29198 
          self.success = {}
29199 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29200 
          for _i718 in xrange(_size714):
29201 
            _key719 = iprot.readI64();
29202 
            _val720 = iprot.readI64();
29203 
            self.success[_key719] = _val720
29204 
          iprot.readMapEnd()
29205 
        else:
29206 
          iprot.skip(ftype)
29207 
      else:
29208 
        iprot.skip(ftype)
29209 
      iprot.readFieldEnd()
29210 
    iprot.readStructEnd()
29211 
 
29212 
  def write(self, oprot):
29213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29215 
      return
29216 
    oprot.writeStructBegin('getMiscCharges_result')
29217 
    if self.success is not None:
29218 
      oprot.writeFieldBegin('success', TType.MAP, 0)
29219 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
29220 
      for kiter721,viter722 in self.success.items():
29221 
        oprot.writeI64(kiter721)
29222 
        oprot.writeI64(viter722)
29223 
      oprot.writeMapEnd()
29224 
      oprot.writeFieldEnd()
29225 
    oprot.writeFieldStop()
29226 
    oprot.writeStructEnd()
29227 
 
29228 
  def validate(self):
29229 
    return
29230 
 
29231 
 
29232 
  def __repr__(self):
29233 
    L = ['%s=%r' % (key, value)
29234 
      for key, value in self.__dict__.iteritems()]
29235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29236 
 
29237 
  def __eq__(self, other):
29238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29239 
 
29240 
  def __ne__(self, other):
29241 
    return not (self == other)