Subversion Repositories SmartDukaan

Rev

Rev 6412 | Rev 6591 | 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 
 
6507 anupam.sin 1437 
  def refundRechargeOrder(self, rechargeOrderId):
1438 
    """
1439 
    Parameters:
1440 
     - rechargeOrderId
1441 
    """
1442 
    pass
6389 rajveer 1443 
 
6507 anupam.sin 1444 
 
3376 rajveer 1445 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1446 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1447 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1448 
 
1449 
  def createTransaction(self, transaction):
1450 
    """
1451 
    Parameters:
1452 
     - transaction
1453 
    """
1454 
    self.send_createTransaction(transaction)
132 ashish 1455 
    return self.recv_createTransaction()
94 ashish 1456 
 
1457 
  def send_createTransaction(self, transaction):
1458 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1459 
    args = createTransaction_args()
1460 
    args.transaction = transaction
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_createTransaction(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = createTransaction_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
3431 rajveer 1475 
    if result.success is not None:
132 ashish 1476 
      return result.success
3431 rajveer 1477 
    if result.ex is not None:
94 ashish 1478 
      raise result.ex
132 ashish 1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1480 
 
1481 
  def getTransaction(self, id):
1482 
    """
1483 
    Parameters:
1484 
     - id
1485 
    """
1486 
    self.send_getTransaction(id)
1487 
    return self.recv_getTransaction()
1488 
 
1489 
  def send_getTransaction(self, id):
1490 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1491 
    args = getTransaction_args()
1492 
    args.id = id
1493 
    args.write(self._oprot)
1494 
    self._oprot.writeMessageEnd()
1495 
    self._oprot.trans.flush()
1496 
 
1497 
  def recv_getTransaction(self, ):
1498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1499 
    if mtype == TMessageType.EXCEPTION:
1500 
      x = TApplicationException()
1501 
      x.read(self._iprot)
1502 
      self._iprot.readMessageEnd()
1503 
      raise x
1504 
    result = getTransaction_result()
1505 
    result.read(self._iprot)
1506 
    self._iprot.readMessageEnd()
3431 rajveer 1507 
    if result.success is not None:
94 ashish 1508 
      return result.success
3431 rajveer 1509 
    if result.ex is not None:
94 ashish 1510 
      raise result.ex
1511 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1512 
 
1513 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1514 
    """
1515 
    Parameters:
1516 
     - customerId
1517 
     - from_date
1518 
     - to_date
1519 
     - status
1520 
    """
1521 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1522 
    return self.recv_getTransactionsForCustomer()
1523 
 
1524 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1525 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1526 
    args = getTransactionsForCustomer_args()
1527 
    args.customerId = customerId
1528 
    args.from_date = from_date
1529 
    args.to_date = to_date
1530 
    args.status = status
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getTransactionsForCustomer(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getTransactionsForCustomer_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
3431 rajveer 1545 
    if result.success is not None:
94 ashish 1546 
      return result.success
3431 rajveer 1547 
    if result.ex is not None:
94 ashish 1548 
      raise result.ex
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1550 
 
132 ashish 1551 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1552 
    """
1553 
    Parameters:
1554 
     - shoppingCartId
1555 
    """
1556 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1557 
    return self.recv_getTransactionsForShoppingCartId()
1558 
 
1559 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1560 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1561 
    args = getTransactionsForShoppingCartId_args()
1562 
    args.shoppingCartId = shoppingCartId
1563 
    args.write(self._oprot)
1564 
    self._oprot.writeMessageEnd()
1565 
    self._oprot.trans.flush()
1566 
 
1567 
  def recv_getTransactionsForShoppingCartId(self, ):
1568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1569 
    if mtype == TMessageType.EXCEPTION:
1570 
      x = TApplicationException()
1571 
      x.read(self._iprot)
1572 
      self._iprot.readMessageEnd()
1573 
      raise x
1574 
    result = getTransactionsForShoppingCartId_result()
1575 
    result.read(self._iprot)
1576 
    self._iprot.readMessageEnd()
3431 rajveer 1577 
    if result.success is not None:
132 ashish 1578 
      return result.success
3431 rajveer 1579 
    if result.ex is not None:
132 ashish 1580 
      raise result.ex
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1582 
 
94 ashish 1583 
  def getTransactionStatus(self, transactionId):
1584 
    """
1585 
    Parameters:
1586 
     - transactionId
1587 
    """
1588 
    self.send_getTransactionStatus(transactionId)
1589 
    return self.recv_getTransactionStatus()
1590 
 
1591 
  def send_getTransactionStatus(self, transactionId):
1592 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1593 
    args = getTransactionStatus_args()
1594 
    args.transactionId = transactionId
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_getTransactionStatus(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = getTransactionStatus_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
3431 rajveer 1609 
    if result.success is not None:
94 ashish 1610 
      return result.success
3431 rajveer 1611 
    if result.ex is not None:
94 ashish 1612 
      raise result.ex
1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1614 
 
5527 anupam.sin 1615 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1616 
    """
1617 
    Parameters:
1618 
     - transactionId
1619 
     - status
1620 
     - description
5527 anupam.sin 1621 
     - pickUp
1622 
     - orderType
94 ashish 1623 
    """
5527 anupam.sin 1624 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1625 
    return self.recv_changeTransactionStatus()
1626 
 
5527 anupam.sin 1627 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1628 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1629 
    args = changeTransactionStatus_args()
1630 
    args.transactionId = transactionId
1631 
    args.status = status
1632 
    args.description = description
5527 anupam.sin 1633 
    args.pickUp = pickUp
1634 
    args.orderType = orderType
94 ashish 1635 
    args.write(self._oprot)
1636 
    self._oprot.writeMessageEnd()
1637 
    self._oprot.trans.flush()
1638 
 
1639 
  def recv_changeTransactionStatus(self, ):
1640 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1641 
    if mtype == TMessageType.EXCEPTION:
1642 
      x = TApplicationException()
1643 
      x.read(self._iprot)
1644 
      self._iprot.readMessageEnd()
1645 
      raise x
1646 
    result = changeTransactionStatus_result()
1647 
    result.read(self._iprot)
1648 
    self._iprot.readMessageEnd()
3431 rajveer 1649 
    if result.success is not None:
94 ashish 1650 
      return result.success
3431 rajveer 1651 
    if result.ex is not None:
94 ashish 1652 
      raise result.ex
1653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1654 
 
1398 varun.gupt 1655 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1656 
    """
1657 
    Parameters:
1658 
     - transactionId
1659 
    """
1398 varun.gupt 1660 
    self.send_enqueueTransactionInfoEmail(transactionId)
1661 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1662 
 
1398 varun.gupt 1663 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1664 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1665 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1666 
    args.transactionId = transactionId
1667 
    args.write(self._oprot)
1668 
    self._oprot.writeMessageEnd()
1669 
    self._oprot.trans.flush()
1670 
 
1398 varun.gupt 1671 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1673 
    if mtype == TMessageType.EXCEPTION:
1674 
      x = TApplicationException()
1675 
      x.read(self._iprot)
1676 
      self._iprot.readMessageEnd()
1677 
      raise x
1398 varun.gupt 1678 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1679 
    result.read(self._iprot)
1680 
    self._iprot.readMessageEnd()
3431 rajveer 1681 
    if result.success is not None:
1382 varun.gupt 1682 
      return result.success
3431 rajveer 1683 
    if result.ex is not None:
1382 varun.gupt 1684 
      raise result.ex
1398 varun.gupt 1685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1686 
 
4801 anupam.sin 1687 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1688 
    """
1689 
    Parameters:
4801 anupam.sin 1690 
     - statuses
483 rajveer 1691 
     - from_date
1692 
     - to_date
1693 
     - warehouse_id
94 ashish 1694 
    """
4801 anupam.sin 1695 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1696 
    return self.recv_getAllOrders()
94 ashish 1697 
 
4801 anupam.sin 1698 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1699 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1700 
    args = getAllOrders_args()
4801 anupam.sin 1701 
    args.statuses = statuses
483 rajveer 1702 
    args.from_date = from_date
1703 
    args.to_date = to_date
1704 
    args.warehouse_id = warehouse_id
94 ashish 1705 
    args.write(self._oprot)
1706 
    self._oprot.writeMessageEnd()
1707 
    self._oprot.trans.flush()
1708 
 
483 rajveer 1709 
  def recv_getAllOrders(self, ):
94 ashish 1710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1711 
    if mtype == TMessageType.EXCEPTION:
1712 
      x = TApplicationException()
1713 
      x.read(self._iprot)
1714 
      self._iprot.readMessageEnd()
1715 
      raise x
483 rajveer 1716 
    result = getAllOrders_result()
94 ashish 1717 
    result.read(self._iprot)
1718 
    self._iprot.readMessageEnd()
3431 rajveer 1719 
    if result.success is not None:
94 ashish 1720 
      return result.success
3431 rajveer 1721 
    if result.ex is not None:
94 ashish 1722 
      raise result.ex
483 rajveer 1723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1724 
 
4133 chandransh 1725 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1726 
    """
1727 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1728 
    Pass the status as null and the limit as 0 to ignore them.
1729 
 
1730 
    Parameters:
1731 
     - statuses
1732 
     - offset
1733 
     - limit
1734 
     - warehouse_id
1735 
    """
1736 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1737 
    return self.recv_getOrdersInBatch()
1738 
 
1739 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1740 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1741 
    args = getOrdersInBatch_args()
1742 
    args.statuses = statuses
1743 
    args.offset = offset
1744 
    args.limit = limit
1745 
    args.warehouse_id = warehouse_id
1746 
    args.write(self._oprot)
1747 
    self._oprot.writeMessageEnd()
1748 
    self._oprot.trans.flush()
1749 
 
1750 
  def recv_getOrdersInBatch(self, ):
1751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1752 
    if mtype == TMessageType.EXCEPTION:
1753 
      x = TApplicationException()
1754 
      x.read(self._iprot)
1755 
      self._iprot.readMessageEnd()
1756 
      raise x
1757 
    result = getOrdersInBatch_result()
1758 
    result.read(self._iprot)
1759 
    self._iprot.readMessageEnd()
1760 
    if result.success is not None:
1761 
      return result.success
1762 
    if result.ex is not None:
1763 
      raise result.ex
1764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1765 
 
1766 
  def getOrderCount(self, statuses, warehouseId):
1767 
    """
1768 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1769 
 
1770 
    Parameters:
1771 
     - statuses
1772 
     - warehouseId
1773 
    """
1774 
    self.send_getOrderCount(statuses, warehouseId)
1775 
    return self.recv_getOrderCount()
1776 
 
1777 
  def send_getOrderCount(self, statuses, warehouseId):
1778 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1779 
    args = getOrderCount_args()
1780 
    args.statuses = statuses
1781 
    args.warehouseId = warehouseId
1782 
    args.write(self._oprot)
1783 
    self._oprot.writeMessageEnd()
1784 
    self._oprot.trans.flush()
1785 
 
1786 
  def recv_getOrderCount(self, ):
1787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1788 
    if mtype == TMessageType.EXCEPTION:
1789 
      x = TApplicationException()
1790 
      x.read(self._iprot)
1791 
      self._iprot.readMessageEnd()
1792 
      raise x
1793 
    result = getOrderCount_result()
1794 
    result.read(self._iprot)
1795 
    self._iprot.readMessageEnd()
1796 
    if result.success is not None:
1797 
      return result.success
1798 
    if result.ex is not None:
1799 
      raise result.ex
1800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1801 
 
999 varun.gupt 1802 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1803 
    """
1132 chandransh 1804 
    Returns orders within a range of their billing dates
3431 rajveer 1805 
 
999 varun.gupt 1806 
    Parameters:
1807 
     - status
1808 
     - start_billing_date
1809 
     - end_billing_date
1810 
     - warehouse_id
1811 
    """
1812 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1813 
    return self.recv_getOrdersByBillingDate()
1814 
 
1815 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1816 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1817 
    args = getOrdersByBillingDate_args()
1818 
    args.status = status
1819 
    args.start_billing_date = start_billing_date
1820 
    args.end_billing_date = end_billing_date
1821 
    args.warehouse_id = warehouse_id
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_getOrdersByBillingDate(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = getOrdersByBillingDate_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
3431 rajveer 1836 
    if result.success is not None:
999 varun.gupt 1837 
      return result.success
3431 rajveer 1838 
    if result.ex is not None:
999 varun.gupt 1839 
      raise result.ex
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1841 
 
3451 chandransh 1842 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1843 
    """
1844 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1845 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1846 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1847 
 
3427 chandransh 1848 
    Parameters:
1849 
     - fromShippingDate
1850 
     - toShippingDate
1851 
     - providerId
1852 
     - warehouseId
3451 chandransh 1853 
     - cod
3427 chandransh 1854 
    """
3451 chandransh 1855 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1856 
    return self.recv_getOrdersByShippingDate()
1857 
 
3451 chandransh 1858 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1859 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1860 
    args = getOrdersByShippingDate_args()
1861 
    args.fromShippingDate = fromShippingDate
1862 
    args.toShippingDate = toShippingDate
1863 
    args.providerId = providerId
1864 
    args.warehouseId = warehouseId
3451 chandransh 1865 
    args.cod = cod
3427 chandransh 1866 
    args.write(self._oprot)
1867 
    self._oprot.writeMessageEnd()
1868 
    self._oprot.trans.flush()
1869 
 
1870 
  def recv_getOrdersByShippingDate(self, ):
1871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1872 
    if mtype == TMessageType.EXCEPTION:
1873 
      x = TApplicationException()
1874 
      x.read(self._iprot)
1875 
      self._iprot.readMessageEnd()
1876 
      raise x
1877 
    result = getOrdersByShippingDate_result()
1878 
    result.read(self._iprot)
1879 
    self._iprot.readMessageEnd()
3431 rajveer 1880 
    if result.success is not None:
3427 chandransh 1881 
      return result.success
3431 rajveer 1882 
    if result.ex is not None:
3427 chandransh 1883 
      raise result.ex
1884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1885 
 
1382 varun.gupt 1886 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1887 
    """
1888 
    Returns order ids for orders which can be returned
3431 rajveer 1889 
 
1382 varun.gupt 1890 
    Parameters:
1891 
     - customer_id
1892 
     - limit
1893 
    """
1894 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1895 
    return self.recv_getReturnableOrdersForCustomer()
1896 
 
1897 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1898 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1899 
    args = getReturnableOrdersForCustomer_args()
1900 
    args.customer_id = customer_id
1901 
    args.limit = limit
1902 
    args.write(self._oprot)
1903 
    self._oprot.writeMessageEnd()
1904 
    self._oprot.trans.flush()
1905 
 
1906 
  def recv_getReturnableOrdersForCustomer(self, ):
1907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1908 
    if mtype == TMessageType.EXCEPTION:
1909 
      x = TApplicationException()
1910 
      x.read(self._iprot)
1911 
      self._iprot.readMessageEnd()
1912 
      raise x
1913 
    result = getReturnableOrdersForCustomer_result()
1914 
    result.read(self._iprot)
1915 
    self._iprot.readMessageEnd()
3431 rajveer 1916 
    if result.success is not None:
1382 varun.gupt 1917 
      return result.success
3431 rajveer 1918 
    if result.ex is not None:
1382 varun.gupt 1919 
      raise result.ex
1920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1921 
 
1922 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1923 
    """
1924 
    Returns order ids for orders which can be cancelled
3431 rajveer 1925 
 
1382 varun.gupt 1926 
    Parameters:
1927 
     - customer_id
1928 
     - limit
1929 
    """
1930 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1931 
    return self.recv_getCancellableOrdersForCustomer()
1932 
 
1933 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1934 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1935 
    args = getCancellableOrdersForCustomer_args()
1936 
    args.customer_id = customer_id
1937 
    args.limit = limit
1938 
    args.write(self._oprot)
1939 
    self._oprot.writeMessageEnd()
1940 
    self._oprot.trans.flush()
1941 
 
1942 
  def recv_getCancellableOrdersForCustomer(self, ):
1943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1944 
    if mtype == TMessageType.EXCEPTION:
1945 
      x = TApplicationException()
1946 
      x.read(self._iprot)
1947 
      self._iprot.readMessageEnd()
1948 
      raise x
1949 
    result = getCancellableOrdersForCustomer_result()
1950 
    result.read(self._iprot)
1951 
    self._iprot.readMessageEnd()
3431 rajveer 1952 
    if result.success is not None:
1382 varun.gupt 1953 
      return result.success
3431 rajveer 1954 
    if result.ex is not None:
1382 varun.gupt 1955 
      raise result.ex
1956 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1957 
 
483 rajveer 1958 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1959 
    """
1960 
    Parameters:
483 rajveer 1961 
     - orderId
1962 
     - status
1963 
     - description
94 ashish 1964 
    """
483 rajveer 1965 
    self.send_changeOrderStatus(orderId, status, description)
1966 
    return self.recv_changeOrderStatus()
94 ashish 1967 
 
483 rajveer 1968 
  def send_changeOrderStatus(self, orderId, status, description):
1969 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1970 
    args = changeOrderStatus_args()
1971 
    args.orderId = orderId
1972 
    args.status = status
1973 
    args.description = description
94 ashish 1974 
    args.write(self._oprot)
1975 
    self._oprot.writeMessageEnd()
1976 
    self._oprot.trans.flush()
1977 
 
483 rajveer 1978 
  def recv_changeOrderStatus(self, ):
94 ashish 1979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1980 
    if mtype == TMessageType.EXCEPTION:
1981 
      x = TApplicationException()
1982 
      x.read(self._iprot)
1983 
      self._iprot.readMessageEnd()
1984 
      raise x
483 rajveer 1985 
    result = changeOrderStatus_result()
94 ashish 1986 
    result.read(self._iprot)
1987 
    self._iprot.readMessageEnd()
3431 rajveer 1988 
    if result.success is not None:
94 ashish 1989 
      return result.success
3431 rajveer 1990 
    if result.ex is not None:
94 ashish 1991 
      raise result.ex
483 rajveer 1992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1993 
 
1528 ankur.sing 1994 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1995 
    """
1528 ankur.sing 1996 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1997 
    only user who owns the transaction can view its order details.
3431 rajveer 1998 
 
94 ashish 1999 
    Parameters:
2000 
     - transactionId
1528 ankur.sing 2001 
     - customerId
94 ashish 2002 
    """
1528 ankur.sing 2003 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2004 
    return self.recv_getOrdersForTransaction()
94 ashish 2005 
 
1528 ankur.sing 2006 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2007 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2008 
    args = getOrdersForTransaction_args()
94 ashish 2009 
    args.transactionId = transactionId
1528 ankur.sing 2010 
    args.customerId = customerId
94 ashish 2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
483 rajveer 2015 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
483 rajveer 2022 
    result = getOrdersForTransaction_result()
94 ashish 2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
3431 rajveer 2025 
    if result.success is not None:
94 ashish 2026 
      return result.success
3431 rajveer 2027 
    if result.ex is not None:
94 ashish 2028 
      raise result.ex
483 rajveer 2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2030 
 
3014 chandransh 2031 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2032 
    """
3014 chandransh 2033 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2034 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2035 
 
94 ashish 2036 
    Parameters:
483 rajveer 2037 
     - customerId
2038 
     - from_date
2039 
     - to_date
3014 chandransh 2040 
     - statuses
94 ashish 2041 
    """
3014 chandransh 2042 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2043 
    return self.recv_getOrdersForCustomer()
94 ashish 2044 
 
3014 chandransh 2045 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2046 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2047 
    args = getOrdersForCustomer_args()
2048 
    args.customerId = customerId
2049 
    args.from_date = from_date
2050 
    args.to_date = to_date
3014 chandransh 2051 
    args.statuses = statuses
94 ashish 2052 
    args.write(self._oprot)
2053 
    self._oprot.writeMessageEnd()
2054 
    self._oprot.trans.flush()
2055 
 
483 rajveer 2056 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2058 
    if mtype == TMessageType.EXCEPTION:
2059 
      x = TApplicationException()
2060 
      x.read(self._iprot)
2061 
      self._iprot.readMessageEnd()
2062 
      raise x
483 rajveer 2063 
    result = getOrdersForCustomer_result()
94 ashish 2064 
    result.read(self._iprot)
2065 
    self._iprot.readMessageEnd()
3431 rajveer 2066 
    if result.success is not None:
94 ashish 2067 
      return result.success
3431 rajveer 2068 
    if result.ex is not None:
94 ashish 2069 
      raise result.ex
483 rajveer 2070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2071 
 
483 rajveer 2072 
  def createOrder(self, order):
94 ashish 2073 
    """
2074 
    Parameters:
483 rajveer 2075 
     - order
94 ashish 2076 
    """
483 rajveer 2077 
    self.send_createOrder(order)
2078 
    return self.recv_createOrder()
94 ashish 2079 
 
483 rajveer 2080 
  def send_createOrder(self, order):
2081 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2082 
    args = createOrder_args()
2083 
    args.order = order
94 ashish 2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
483 rajveer 2088 
  def recv_createOrder(self, ):
94 ashish 2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
483 rajveer 2095 
    result = createOrder_result()
94 ashish 2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
3431 rajveer 2098 
    if result.success is not None:
94 ashish 2099 
      return result.success
3431 rajveer 2100 
    if result.ex is not None:
94 ashish 2101 
      raise result.ex
483 rajveer 2102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2103 
 
483 rajveer 2104 
  def getOrder(self, id):
94 ashish 2105 
    """
2106 
    Parameters:
483 rajveer 2107 
     - id
94 ashish 2108 
    """
483 rajveer 2109 
    self.send_getOrder(id)
2110 
    return self.recv_getOrder()
94 ashish 2111 
 
483 rajveer 2112 
  def send_getOrder(self, id):
2113 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2114 
    args = getOrder_args()
2115 
    args.id = id
94 ashish 2116 
    args.write(self._oprot)
2117 
    self._oprot.writeMessageEnd()
2118 
    self._oprot.trans.flush()
2119 
 
483 rajveer 2120 
  def recv_getOrder(self, ):
94 ashish 2121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2122 
    if mtype == TMessageType.EXCEPTION:
2123 
      x = TApplicationException()
2124 
      x.read(self._iprot)
2125 
      self._iprot.readMessageEnd()
2126 
      raise x
483 rajveer 2127 
    result = getOrder_result()
94 ashish 2128 
    result.read(self._iprot)
2129 
    self._iprot.readMessageEnd()
3431 rajveer 2130 
    if result.success is not None:
94 ashish 2131 
      return result.success
3431 rajveer 2132 
    if result.ex is not None:
94 ashish 2133 
      raise result.ex
483 rajveer 2134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2135 
 
483 rajveer 2136 
  def getLineItemsForOrder(self, orderId):
94 ashish 2137 
    """
2138 
    Parameters:
483 rajveer 2139 
     - orderId
94 ashish 2140 
    """
483 rajveer 2141 
    self.send_getLineItemsForOrder(orderId)
2142 
    return self.recv_getLineItemsForOrder()
94 ashish 2143 
 
483 rajveer 2144 
  def send_getLineItemsForOrder(self, orderId):
2145 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2146 
    args = getLineItemsForOrder_args()
2147 
    args.orderId = orderId
94 ashish 2148 
    args.write(self._oprot)
2149 
    self._oprot.writeMessageEnd()
2150 
    self._oprot.trans.flush()
2151 
 
483 rajveer 2152 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2154 
    if mtype == TMessageType.EXCEPTION:
2155 
      x = TApplicationException()
2156 
      x.read(self._iprot)
2157 
      self._iprot.readMessageEnd()
2158 
      raise x
483 rajveer 2159 
    result = getLineItemsForOrder_result()
94 ashish 2160 
    result.read(self._iprot)
2161 
    self._iprot.readMessageEnd()
3431 rajveer 2162 
    if result.success is not None:
94 ashish 2163 
      return result.success
3431 rajveer 2164 
    if result.ex is not None:
94 ashish 2165 
      raise result.ex
483 rajveer 2166 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2167 
 
4999 phani.kuma 2168 
  def getOrderList(self, order_ids):
2169 
    """
2170 
    Parameters:
2171 
     - order_ids
2172 
    """
2173 
    self.send_getOrderList(order_ids)
2174 
    return self.recv_getOrderList()
2175 
 
2176 
  def send_getOrderList(self, order_ids):
2177 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2178 
    args = getOrderList_args()
2179 
    args.order_ids = order_ids
2180 
    args.write(self._oprot)
2181 
    self._oprot.writeMessageEnd()
2182 
    self._oprot.trans.flush()
2183 
 
2184 
  def recv_getOrderList(self, ):
2185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2186 
    if mtype == TMessageType.EXCEPTION:
2187 
      x = TApplicationException()
2188 
      x.read(self._iprot)
2189 
      self._iprot.readMessageEnd()
2190 
      raise x
2191 
    result = getOrderList_result()
2192 
    result.read(self._iprot)
2193 
    self._iprot.readMessageEnd()
2194 
    if result.success is not None:
2195 
      return result.success
2196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2197 
 
5386 phani.kuma 2198 
  def getOrderListForVendor(self, order_ids, vendorId):
2199 
    """
2200 
    Parameters:
2201 
     - order_ids
2202 
     - vendorId
2203 
    """
2204 
    self.send_getOrderListForVendor(order_ids, vendorId)
2205 
    return self.recv_getOrderListForVendor()
2206 
 
2207 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2208 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2209 
    args = getOrderListForVendor_args()
2210 
    args.order_ids = order_ids
2211 
    args.vendorId = vendorId
2212 
    args.write(self._oprot)
2213 
    self._oprot.writeMessageEnd()
2214 
    self._oprot.trans.flush()
2215 
 
2216 
  def recv_getOrderListForVendor(self, ):
2217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2218 
    if mtype == TMessageType.EXCEPTION:
2219 
      x = TApplicationException()
2220 
      x.read(self._iprot)
2221 
      self._iprot.readMessageEnd()
2222 
      raise x
2223 
    result = getOrderListForVendor_result()
2224 
    result.read(self._iprot)
2225 
    self._iprot.readMessageEnd()
2226 
    if result.success is not None:
2227 
      return result.success
2228 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2229 
 
1528 ankur.sing 2230 
  def getOrderForCustomer(self, orderId, customerId):
2231 
    """
2232 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2233 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2234 
 
1528 ankur.sing 2235 
    Parameters:
2236 
     - orderId
2237 
     - customerId
2238 
    """
2239 
    self.send_getOrderForCustomer(orderId, customerId)
2240 
    return self.recv_getOrderForCustomer()
2241 
 
2242 
  def send_getOrderForCustomer(self, orderId, customerId):
2243 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2244 
    args = getOrderForCustomer_args()
2245 
    args.orderId = orderId
2246 
    args.customerId = customerId
2247 
    args.write(self._oprot)
2248 
    self._oprot.writeMessageEnd()
2249 
    self._oprot.trans.flush()
2250 
 
2251 
  def recv_getOrderForCustomer(self, ):
2252 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2253 
    if mtype == TMessageType.EXCEPTION:
2254 
      x = TApplicationException()
2255 
      x.read(self._iprot)
2256 
      self._iprot.readMessageEnd()
2257 
      raise x
2258 
    result = getOrderForCustomer_result()
2259 
    result.read(self._iprot)
2260 
    self._iprot.readMessageEnd()
3431 rajveer 2261 
    if result.success is not None:
1528 ankur.sing 2262 
      return result.success
3431 rajveer 2263 
    if result.ex is not None:
1528 ankur.sing 2264 
      raise result.ex
2265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2266 
 
4444 rajveer 2267 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2268 
    """
2269 
    Parameters:
4394 rajveer 2270 
     - type
4444 rajveer 2271 
     - warehouseId
4394 rajveer 2272 
     - status
2273 
     - timestamp
3064 chandransh 2274 
    """
4444 rajveer 2275 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2276 
    return self.recv_getAlerts()
2277 
 
4444 rajveer 2278 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2279 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2280 
    args = getAlerts_args()
4394 rajveer 2281 
    args.type = type
4444 rajveer 2282 
    args.warehouseId = warehouseId
4394 rajveer 2283 
    args.status = status
2284 
    args.timestamp = timestamp
3064 chandransh 2285 
    args.write(self._oprot)
2286 
    self._oprot.writeMessageEnd()
2287 
    self._oprot.trans.flush()
2288 
 
2289 
  def recv_getAlerts(self, ):
2290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2291 
    if mtype == TMessageType.EXCEPTION:
2292 
      x = TApplicationException()
2293 
      x.read(self._iprot)
2294 
      self._iprot.readMessageEnd()
2295 
      raise x
2296 
    result = getAlerts_result()
2297 
    result.read(self._iprot)
2298 
    self._iprot.readMessageEnd()
3431 rajveer 2299 
    if result.success is not None:
3064 chandransh 2300 
      return result.success
2301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2302 
 
4444 rajveer 2303 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2304 
    """
2305 
    Parameters:
2306 
     - type
4444 rajveer 2307 
     - warehouseId
4394 rajveer 2308 
     - description
3064 chandransh 2309 
    """
4444 rajveer 2310 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2311 
    self.recv_addAlert()
3064 chandransh 2312 
 
4444 rajveer 2313 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2314 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2315 
    args = addAlert_args()
3064 chandransh 2316 
    args.type = type
4444 rajveer 2317 
    args.warehouseId = warehouseId
4394 rajveer 2318 
    args.description = description
3064 chandransh 2319 
    args.write(self._oprot)
2320 
    self._oprot.writeMessageEnd()
2321 
    self._oprot.trans.flush()
2322 
 
4394 rajveer 2323 
  def recv_addAlert(self, ):
3064 chandransh 2324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2325 
    if mtype == TMessageType.EXCEPTION:
2326 
      x = TApplicationException()
2327 
      x.read(self._iprot)
2328 
      self._iprot.readMessageEnd()
2329 
      raise x
4394 rajveer 2330 
    result = addAlert_result()
3064 chandransh 2331 
    result.read(self._iprot)
2332 
    self._iprot.readMessageEnd()
2333 
    return
2334 
 
4444 rajveer 2335 
  def markAlertsAsSeen(self, warehouseId):
2336 
    """
2337 
    Parameters:
2338 
     - warehouseId
2339 
    """
2340 
    self.send_markAlertsAsSeen(warehouseId)
2341 
    self.recv_markAlertsAsSeen()
2342 
 
2343 
  def send_markAlertsAsSeen(self, warehouseId):
2344 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2345 
    args = markAlertsAsSeen_args()
2346 
    args.warehouseId = warehouseId
2347 
    args.write(self._oprot)
2348 
    self._oprot.writeMessageEnd()
2349 
    self._oprot.trans.flush()
2350 
 
2351 
  def recv_markAlertsAsSeen(self, ):
2352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2353 
    if mtype == TMessageType.EXCEPTION:
2354 
      x = TApplicationException()
2355 
      x.read(self._iprot)
2356 
      self._iprot.readMessageEnd()
2357 
      raise x
2358 
    result = markAlertsAsSeen_result()
2359 
    result.read(self._iprot)
2360 
    self._iprot.readMessageEnd()
2361 
    return
2362 
 
3064 chandransh 2363 
  def getValidOrderCount(self, ):
2364 
    """
2365 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2366 
    """
2367 
    self.send_getValidOrderCount()
2368 
    return self.recv_getValidOrderCount()
2369 
 
2370 
  def send_getValidOrderCount(self, ):
2371 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2372 
    args = getValidOrderCount_args()
2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
2377 
  def recv_getValidOrderCount(self, ):
2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
2384 
    result = getValidOrderCount_result()
2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
3431 rajveer 2387 
    if result.success is not None:
3064 chandransh 2388 
      return result.success
2389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2390 
 
2391 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2392 
    """
2393 
    Returns the number of distinct customers who have done successful transactions
2394 
    """
2395 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2396 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2397 
 
2398 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2399 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2400 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2401 
    args.write(self._oprot)
2402 
    self._oprot.writeMessageEnd()
2403 
    self._oprot.trans.flush()
2404 
 
2405 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2407 
    if mtype == TMessageType.EXCEPTION:
2408 
      x = TApplicationException()
2409 
      x.read(self._iprot)
2410 
      self._iprot.readMessageEnd()
2411 
      raise x
2412 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2413 
    result.read(self._iprot)
2414 
    self._iprot.readMessageEnd()
3431 rajveer 2415 
    if result.success is not None:
3064 chandransh 2416 
      return result.success
2417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2418 
 
2419 
  def getValidOrdersAmountRange(self, ):
2420 
    """
2421 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2422 
    List contains two values, first minimum amount and second maximum amount.
2423 
    """
2424 
    self.send_getValidOrdersAmountRange()
2425 
    return self.recv_getValidOrdersAmountRange()
2426 
 
2427 
  def send_getValidOrdersAmountRange(self, ):
2428 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2429 
    args = getValidOrdersAmountRange_args()
2430 
    args.write(self._oprot)
2431 
    self._oprot.writeMessageEnd()
2432 
    self._oprot.trans.flush()
2433 
 
2434 
  def recv_getValidOrdersAmountRange(self, ):
2435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2436 
    if mtype == TMessageType.EXCEPTION:
2437 
      x = TApplicationException()
2438 
      x.read(self._iprot)
2439 
      self._iprot.readMessageEnd()
2440 
      raise x
2441 
    result = getValidOrdersAmountRange_result()
2442 
    result.read(self._iprot)
2443 
    self._iprot.readMessageEnd()
3431 rajveer 2444 
    if result.success is not None:
3064 chandransh 2445 
      return result.success
2446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2447 
 
5874 rajveer 2448 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2449 
    """
2450 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2451 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2452 
 
3064 chandransh 2453 
    Parameters:
2454 
     - limit
5874 rajveer 2455 
     - onlyStore
3064 chandransh 2456 
    """
5874 rajveer 2457 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2458 
    return self.recv_getValidOrders()
2459 
 
5874 rajveer 2460 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2461 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2462 
    args = getValidOrders_args()
2463 
    args.limit = limit
5874 rajveer 2464 
    args.onlyStore = onlyStore
3064 chandransh 2465 
    args.write(self._oprot)
2466 
    self._oprot.writeMessageEnd()
2467 
    self._oprot.trans.flush()
2468 
 
2469 
  def recv_getValidOrders(self, ):
2470 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2471 
    if mtype == TMessageType.EXCEPTION:
2472 
      x = TApplicationException()
2473 
      x.read(self._iprot)
2474 
      self._iprot.readMessageEnd()
2475 
      raise x
2476 
    result = getValidOrders_result()
2477 
    result.read(self._iprot)
2478 
    self._iprot.readMessageEnd()
3431 rajveer 2479 
    if result.success is not None:
3064 chandransh 2480 
      return result.success
2481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2482 
 
1220 chandransh 2483 
  def batchOrders(self, warehouseId):
2484 
    """
2485 
    Create a batch of all the pending orders for the given warehouse.
2486 
    The returned list is orderd by created_timestamp.
2487 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2488 
 
1220 chandransh 2489 
    Parameters:
2490 
     - warehouseId
2491 
    """
2492 
    self.send_batchOrders(warehouseId)
2493 
    return self.recv_batchOrders()
2494 
 
2495 
  def send_batchOrders(self, warehouseId):
2496 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2497 
    args = batchOrders_args()
2498 
    args.warehouseId = warehouseId
2499 
    args.write(self._oprot)
2500 
    self._oprot.writeMessageEnd()
2501 
    self._oprot.trans.flush()
2502 
 
2503 
  def recv_batchOrders(self, ):
2504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2505 
    if mtype == TMessageType.EXCEPTION:
2506 
      x = TApplicationException()
2507 
      x.read(self._iprot)
2508 
      self._iprot.readMessageEnd()
2509 
      raise x
2510 
    result = batchOrders_result()
2511 
    result.read(self._iprot)
2512 
    self._iprot.readMessageEnd()
3431 rajveer 2513 
    if result.success is not None:
1220 chandransh 2514 
      return result.success
3431 rajveer 2515 
    if result.ex is not None:
1220 chandransh 2516 
      raise result.ex
2517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2518 
 
1208 chandransh 2519 
  def markOrderAsOutOfStock(self, orderId):
2520 
    """
2521 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2522 
 
1208 chandransh 2523 
    Parameters:
2524 
     - orderId
2525 
    """
2526 
    self.send_markOrderAsOutOfStock(orderId)
2527 
    return self.recv_markOrderAsOutOfStock()
2528 
 
2529 
  def send_markOrderAsOutOfStock(self, orderId):
2530 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2531 
    args = markOrderAsOutOfStock_args()
2532 
    args.orderId = orderId
2533 
    args.write(self._oprot)
2534 
    self._oprot.writeMessageEnd()
2535 
    self._oprot.trans.flush()
2536 
 
2537 
  def recv_markOrderAsOutOfStock(self, ):
2538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2539 
    if mtype == TMessageType.EXCEPTION:
2540 
      x = TApplicationException()
2541 
      x.read(self._iprot)
2542 
      self._iprot.readMessageEnd()
2543 
      raise x
2544 
    result = markOrderAsOutOfStock_result()
2545 
    result.read(self._iprot)
2546 
    self._iprot.readMessageEnd()
3431 rajveer 2547 
    if result.success is not None:
1208 chandransh 2548 
      return result.success
3431 rajveer 2549 
    if result.ex is not None:
1208 chandransh 2550 
      raise result.ex
2551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2552 
 
3064 chandransh 2553 
  def verifyOrder(self, orderId):
759 chandransh 2554 
    """
3064 chandransh 2555 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2556 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2557 
    used for all other orders as well.
2558 
    Throws an exception if no such order exists.
3431 rajveer 2559 
 
759 chandransh 2560 
    Parameters:
3064 chandransh 2561 
     - orderId
759 chandransh 2562 
    """
3064 chandransh 2563 
    self.send_verifyOrder(orderId)
2564 
    return self.recv_verifyOrder()
759 chandransh 2565 
 
3064 chandransh 2566 
  def send_verifyOrder(self, orderId):
2567 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2568 
    args = verifyOrder_args()
2569 
    args.orderId = orderId
759 chandransh 2570 
    args.write(self._oprot)
2571 
    self._oprot.writeMessageEnd()
2572 
    self._oprot.trans.flush()
2573 
 
3064 chandransh 2574 
  def recv_verifyOrder(self, ):
759 chandransh 2575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2576 
    if mtype == TMessageType.EXCEPTION:
2577 
      x = TApplicationException()
2578 
      x.read(self._iprot)
2579 
      self._iprot.readMessageEnd()
2580 
      raise x
3064 chandransh 2581 
    result = verifyOrder_result()
759 chandransh 2582 
    result.read(self._iprot)
2583 
    self._iprot.readMessageEnd()
3431 rajveer 2584 
    if result.success is not None:
759 chandransh 2585 
      return result.success
3431 rajveer 2586 
    if result.ex is not None:
759 chandransh 2587 
      raise result.ex
3064 chandransh 2588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2589 
 
3064 chandransh 2590 
  def acceptOrder(self, orderId):
1113 chandransh 2591 
    """
3064 chandransh 2592 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2593 
    given order is not a COD order, it also captures the payment if the same has
2594 
    not been captured.
2595 
    Throws an exception if no such order exists.
3431 rajveer 2596 
 
1113 chandransh 2597 
    Parameters:
3064 chandransh 2598 
     - orderId
1113 chandransh 2599 
    """
3064 chandransh 2600 
    self.send_acceptOrder(orderId)
2601 
    return self.recv_acceptOrder()
1113 chandransh 2602 
 
3064 chandransh 2603 
  def send_acceptOrder(self, orderId):
2604 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2605 
    args = acceptOrder_args()
2606 
    args.orderId = orderId
1113 chandransh 2607 
    args.write(self._oprot)
2608 
    self._oprot.writeMessageEnd()
2609 
    self._oprot.trans.flush()
2610 
 
3064 chandransh 2611 
  def recv_acceptOrder(self, ):
1113 chandransh 2612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2613 
    if mtype == TMessageType.EXCEPTION:
2614 
      x = TApplicationException()
2615 
      x.read(self._iprot)
2616 
      self._iprot.readMessageEnd()
2617 
      raise x
3064 chandransh 2618 
    result = acceptOrder_result()
1113 chandransh 2619 
    result.read(self._iprot)
2620 
    self._iprot.readMessageEnd()
3431 rajveer 2621 
    if result.success is not None:
1113 chandransh 2622 
      return result.success
3431 rajveer 2623 
    if result.ex is not None:
1113 chandransh 2624 
      raise result.ex
3064 chandransh 2625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2626 
 
5110 mandeep.dh 2627 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2628 
    """
3064 chandransh 2629 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2630 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2631 
    the IMEI no. if a -1 is supplied.
2632 
    Also, it generates an invoice number for the order, marks the order as
2633 
    BILLED and sets the billing timestamp.
2634 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2635 
 
1135 chandransh 2636 
    Parameters:
3064 chandransh 2637 
     - orderId
2638 
     - invoice_number
4658 mandeep.dh 2639 
     - serialNumber
4283 anupam.sin 2640 
     - itemNumber
3064 chandransh 2641 
     - billed_by
4264 rajveer 2642 
     - jacketNumber
4283 anupam.sin 2643 
     - billingType
5110 mandeep.dh 2644 
     - fulfilmentWarehouseId
4763 rajveer 2645 
     - authorize
1135 chandransh 2646 
    """
5110 mandeep.dh 2647 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2648 
    return self.recv_addBillingDetails()
1135 chandransh 2649 
 
5110 mandeep.dh 2650 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2651 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2652 
    args = addBillingDetails_args()
2653 
    args.orderId = orderId
2654 
    args.invoice_number = invoice_number
4658 mandeep.dh 2655 
    args.serialNumber = serialNumber
4283 anupam.sin 2656 
    args.itemNumber = itemNumber
3064 chandransh 2657 
    args.billed_by = billed_by
4264 rajveer 2658 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2659 
    args.billingType = billingType
5110 mandeep.dh 2660 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2661 
    args.authorize = authorize
1135 chandransh 2662 
    args.write(self._oprot)
2663 
    self._oprot.writeMessageEnd()
2664 
    self._oprot.trans.flush()
2665 
 
3064 chandransh 2666 
  def recv_addBillingDetails(self, ):
1135 chandransh 2667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2668 
    if mtype == TMessageType.EXCEPTION:
2669 
      x = TApplicationException()
2670 
      x.read(self._iprot)
2671 
      self._iprot.readMessageEnd()
2672 
      raise x
3064 chandransh 2673 
    result = addBillingDetails_result()
1135 chandransh 2674 
    result.read(self._iprot)
2675 
    self._iprot.readMessageEnd()
3431 rajveer 2676 
    if result.success is not None:
3064 chandransh 2677 
      return result.success
3431 rajveer 2678 
    if result.ex is not None:
1135 chandransh 2679 
      raise result.ex
3064 chandransh 2680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2681 
 
4763 rajveer 2682 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2683 
    """
2684 
    Add the invoice number to the order.
2685 
 
2686 
    Parameters:
2687 
     - orderId
2688 
     - invoiceNumber
4763 rajveer 2689 
     - color
4579 rajveer 2690 
    """
4763 rajveer 2691 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2692 
    self.recv_addInvoiceNumber()
2693 
 
4763 rajveer 2694 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2695 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2696 
    args = addInvoiceNumber_args()
2697 
    args.orderId = orderId
2698 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2699 
    args.color = color
4579 rajveer 2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
2704 
  def recv_addInvoiceNumber(self, ):
2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
2711 
    result = addInvoiceNumber_result()
2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
2714 
    if result.ex is not None:
2715 
      raise result.ex
2716 
    return
2717 
 
4910 phani.kuma 2718 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2719 
    """
3064 chandransh 2720 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2721 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2722 
 
1408 ankur.sing 2723 
    Parameters:
3064 chandransh 2724 
     - warehouseId
1408 ankur.sing 2725 
     - providerId
3064 chandransh 2726 
     - cod
4910 phani.kuma 2727 
     - orderIds
1408 ankur.sing 2728 
    """
4910 phani.kuma 2729 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2730 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2731 
 
4910 phani.kuma 2732 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2733 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2734 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2735 
    args.warehouseId = warehouseId
1408 ankur.sing 2736 
    args.providerId = providerId
3064 chandransh 2737 
    args.cod = cod
4910 phani.kuma 2738 
    args.orderIds = orderIds
1408 ankur.sing 2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
4910 phani.kuma 2743 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
4910 phani.kuma 2750 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
3431 rajveer 2753 
    if result.success is not None:
1408 ankur.sing 2754 
      return result.success
3431 rajveer 2755 
    if result.ex is not None:
3064 chandransh 2756 
      raise result.ex
4910 phani.kuma 2757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2758 
 
5713 rajveer 2759 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2760 
    """
2761 
    Parameters:
2762 
     - providerId
2763 
     - orderIds
5713 rajveer 2764 
     - awbs
5676 rajveer 2765 
    """
5713 rajveer 2766 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2767 
    return self.recv_markOrdersAsReturnedFromStore()
2768 
 
5713 rajveer 2769 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2770 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2771 
    args = markOrdersAsReturnedFromStore_args()
2772 
    args.providerId = providerId
2773 
    args.orderIds = orderIds
5713 rajveer 2774 
    args.awbs = awbs
5676 rajveer 2775 
    args.write(self._oprot)
2776 
    self._oprot.writeMessageEnd()
2777 
    self._oprot.trans.flush()
2778 
 
2779 
  def recv_markOrdersAsReturnedFromStore(self, ):
2780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2781 
    if mtype == TMessageType.EXCEPTION:
2782 
      x = TApplicationException()
2783 
      x.read(self._iprot)
2784 
      self._iprot.readMessageEnd()
2785 
      raise x
2786 
    result = markOrdersAsReturnedFromStore_result()
2787 
    result.read(self._iprot)
2788 
    self._iprot.readMessageEnd()
2789 
    if result.success is not None:
2790 
      return result.success
2791 
    if result.ex is not None:
2792 
      raise result.ex
2793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2794 
 
4910 phani.kuma 2795 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2796 
    """
4910 phani.kuma 2797 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2798 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2799 
 
2800 
    Parameters:
2801 
     - providerId
4910 phani.kuma 2802 
     - pickupDetails
4410 rajveer 2803 
    """
4910 phani.kuma 2804 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2805 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2806 
 
4910 phani.kuma 2807 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2808 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2809 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2810 
    args.providerId = providerId
4910 phani.kuma 2811 
    args.pickupDetails = pickupDetails
4410 rajveer 2812 
    args.write(self._oprot)
2813 
    self._oprot.writeMessageEnd()
2814 
    self._oprot.trans.flush()
2815 
 
4910 phani.kuma 2816 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2817 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2818 
    if mtype == TMessageType.EXCEPTION:
2819 
      x = TApplicationException()
2820 
      x.read(self._iprot)
2821 
      self._iprot.readMessageEnd()
2822 
      raise x
4910 phani.kuma 2823 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2824 
    result.read(self._iprot)
2825 
    self._iprot.readMessageEnd()
2826 
    if result.ex is not None:
2827 
      raise result.ex
4910 phani.kuma 2828 
    return
4410 rajveer 2829 
 
4910 phani.kuma 2830 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2831 
    """
3064 chandransh 2832 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2833 
 
94 ashish 2834 
    Parameters:
3064 chandransh 2835 
     - providerId
304 ashish 2836 
    """
4910 phani.kuma 2837 
    self.send_getOrdersNotPickedUp(providerId)
2838 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2839 
 
4910 phani.kuma 2840 
  def send_getOrdersNotPickedUp(self, providerId):
2841 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2842 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2843 
    args.providerId = providerId
304 ashish 2844 
    args.write(self._oprot)
2845 
    self._oprot.writeMessageEnd()
2846 
    self._oprot.trans.flush()
2847 
 
4910 phani.kuma 2848 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2850 
    if mtype == TMessageType.EXCEPTION:
2851 
      x = TApplicationException()
2852 
      x.read(self._iprot)
2853 
      self._iprot.readMessageEnd()
2854 
      raise x
4910 phani.kuma 2855 
    result = getOrdersNotPickedUp_result()
304 ashish 2856 
    result.read(self._iprot)
2857 
    self._iprot.readMessageEnd()
3431 rajveer 2858 
    if result.success is not None:
304 ashish 2859 
      return result.success
4910 phani.kuma 2860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2861 
 
3064 chandransh 2862 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2863 
    """
3064 chandransh 2864 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2865 
    the name of the receiver.
2866 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2867 
 
304 ashish 2868 
    Parameters:
3064 chandransh 2869 
     - providerId
2870 
     - deliveredOrders
304 ashish 2871 
    """
3064 chandransh 2872 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2873 
    self.recv_markOrdersAsDelivered()
304 ashish 2874 
 
3064 chandransh 2875 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2876 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2877 
    args = markOrdersAsDelivered_args()
2878 
    args.providerId = providerId
2879 
    args.deliveredOrders = deliveredOrders
304 ashish 2880 
    args.write(self._oprot)
2881 
    self._oprot.writeMessageEnd()
2882 
    self._oprot.trans.flush()
2883 
 
3064 chandransh 2884 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2886 
    if mtype == TMessageType.EXCEPTION:
2887 
      x = TApplicationException()
2888 
      x.read(self._iprot)
2889 
      self._iprot.readMessageEnd()
2890 
      raise x
3064 chandransh 2891 
    result = markOrdersAsDelivered_result()
304 ashish 2892 
    result.read(self._iprot)
2893 
    self._iprot.readMessageEnd()
3431 rajveer 2894 
    if result.ex is not None:
3064 chandransh 2895 
      raise result.ex
304 ashish 2896 
    return
2897 
 
4910 phani.kuma 2898 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2899 
    """
4910 phani.kuma 2900 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2901 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2902 
 
3064 chandransh 2903 
    Parameters:
2904 
     - providerId
2905 
     - returnedOrders
1596 ankur.sing 2906 
    """
4910 phani.kuma 2907 
    self.send_markAsRTOrders(providerId, returnedOrders)
2908 
    self.recv_markAsRTOrders()
304 ashish 2909 
 
4910 phani.kuma 2910 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2911 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2912 
    args = markAsRTOrders_args()
3064 chandransh 2913 
    args.providerId = providerId
2914 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
4910 phani.kuma 2919 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
4910 phani.kuma 2926 
    result = markAsRTOrders_result()
1596 ankur.sing 2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
3431 rajveer 2929 
    if result.ex is not None:
3064 chandransh 2930 
      raise result.ex
2931 
    return
1596 ankur.sing 2932 
 
4910 phani.kuma 2933 
  def getRTOrders(self, providerId):
2934 
    """
2935 
    Returns a list of orders that were returned by courier.
2936 
 
2937 
    Parameters:
2938 
     - providerId
2939 
    """
2940 
    self.send_getRTOrders(providerId)
2941 
    return self.recv_getRTOrders()
2942 
 
2943 
  def send_getRTOrders(self, providerId):
2944 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2945 
    args = getRTOrders_args()
2946 
    args.providerId = providerId
2947 
    args.write(self._oprot)
2948 
    self._oprot.writeMessageEnd()
2949 
    self._oprot.trans.flush()
2950 
 
2951 
  def recv_getRTOrders(self, ):
2952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2953 
    if mtype == TMessageType.EXCEPTION:
2954 
      x = TApplicationException()
2955 
      x.read(self._iprot)
2956 
      self._iprot.readMessageEnd()
2957 
      raise x
2958 
    result = getRTOrders_result()
2959 
    result.read(self._iprot)
2960 
    self._iprot.readMessageEnd()
2961 
    if result.success is not None:
2962 
      return result.success
2963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2964 
 
3064 chandransh 2965 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2966 
    """
3064 chandransh 2967 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2968 
 
3064 chandransh 2969 
    Parameters:
2970 
     - providerId
2971 
     - undeliveredOrders
1627 ankur.sing 2972 
    """
3064 chandransh 2973 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2974 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2975 
 
3064 chandransh 2976 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2977 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2978 
    args = updateNonDeliveryReason_args()
2979 
    args.providerId = providerId
2980 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2981 
    args.write(self._oprot)
2982 
    self._oprot.writeMessageEnd()
2983 
    self._oprot.trans.flush()
2984 
 
3064 chandransh 2985 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2987 
    if mtype == TMessageType.EXCEPTION:
2988 
      x = TApplicationException()
2989 
      x.read(self._iprot)
2990 
      self._iprot.readMessageEnd()
2991 
      raise x
3064 chandransh 2992 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2993 
    result.read(self._iprot)
2994 
    self._iprot.readMessageEnd()
4910 phani.kuma 2995 
    if result.ex is not None:
2996 
      raise result.ex
2997 
    return
2998 
 
2999 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3000 
    """
3001 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3002 
 
3003 
    Parameters:
3004 
     - providerId
3005 
    """
3006 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3007 
    return self.recv_getNonDeliveredOrdersbyCourier()
3008 
 
3009 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3010 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3011 
    args = getNonDeliveredOrdersbyCourier_args()
3012 
    args.providerId = providerId
3013 
    args.write(self._oprot)
3014 
    self._oprot.writeMessageEnd()
3015 
    self._oprot.trans.flush()
3016 
 
3017 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3018 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3019 
    if mtype == TMessageType.EXCEPTION:
3020 
      x = TApplicationException()
3021 
      x.read(self._iprot)
3022 
      self._iprot.readMessageEnd()
3023 
      raise x
3024 
    result = getNonDeliveredOrdersbyCourier_result()
3025 
    result.read(self._iprot)
3026 
    self._iprot.readMessageEnd()
4581 phani.kuma 3027 
    if result.success is not None:
3028 
      return result.success
4910 phani.kuma 3029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3030 
 
3031 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3032 
    """
3033 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3034 
 
3035 
    Parameters:
3036 
     - providerId
3037 
     - local_connected_orders
3038 
    """
3039 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3040 
    self.recv_markOrdersAsLocalConnected()
3041 
 
3042 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3043 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3044 
    args = markOrdersAsLocalConnected_args()
3045 
    args.providerId = providerId
3046 
    args.local_connected_orders = local_connected_orders
3047 
    args.write(self._oprot)
3048 
    self._oprot.writeMessageEnd()
3049 
    self._oprot.trans.flush()
3050 
 
3051 
  def recv_markOrdersAsLocalConnected(self, ):
3052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3053 
    if mtype == TMessageType.EXCEPTION:
3054 
      x = TApplicationException()
3055 
      x.read(self._iprot)
3056 
      self._iprot.readMessageEnd()
3057 
      raise x
3058 
    result = markOrdersAsLocalConnected_result()
3059 
    result.read(self._iprot)
3060 
    self._iprot.readMessageEnd()
3431 rajveer 3061 
    if result.ex is not None:
3064 chandransh 3062 
      raise result.ex
4910 phani.kuma 3063 
    return
1627 ankur.sing 3064 
 
4910 phani.kuma 3065 
  def getOrdersNotLocalConnected(self, providerId):
3066 
    """
3067 
    Returns a list of orders that were picked up or shipped but pending local connection.
3068 
 
3069 
    Parameters:
3070 
     - providerId
3071 
    """
3072 
    self.send_getOrdersNotLocalConnected(providerId)
3073 
    return self.recv_getOrdersNotLocalConnected()
3074 
 
3075 
  def send_getOrdersNotLocalConnected(self, providerId):
3076 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3077 
    args = getOrdersNotLocalConnected_args()
3078 
    args.providerId = providerId
3079 
    args.write(self._oprot)
3080 
    self._oprot.writeMessageEnd()
3081 
    self._oprot.trans.flush()
3082 
 
3083 
  def recv_getOrdersNotLocalConnected(self, ):
3084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3085 
    if mtype == TMessageType.EXCEPTION:
3086 
      x = TApplicationException()
3087 
      x.read(self._iprot)
3088 
      self._iprot.readMessageEnd()
3089 
      raise x
3090 
    result = getOrdersNotLocalConnected_result()
3091 
    result.read(self._iprot)
3092 
    self._iprot.readMessageEnd()
3093 
    if result.success is not None:
3094 
      return result.success
3095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3096 
 
3097 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3098 
    """
3099 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3100 
 
3101 
    Parameters:
3102 
     - providerId
3103 
     - destination_city_reached_orders
3104 
    """
3105 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3106 
    self.recv_markOrdersAsDestinationCityReached()
3107 
 
3108 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3109 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3110 
    args = markOrdersAsDestinationCityReached_args()
3111 
    args.providerId = providerId
3112 
    args.destination_city_reached_orders = destination_city_reached_orders
3113 
    args.write(self._oprot)
3114 
    self._oprot.writeMessageEnd()
3115 
    self._oprot.trans.flush()
3116 
 
3117 
  def recv_markOrdersAsDestinationCityReached(self, ):
3118 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3119 
    if mtype == TMessageType.EXCEPTION:
3120 
      x = TApplicationException()
3121 
      x.read(self._iprot)
3122 
      self._iprot.readMessageEnd()
3123 
      raise x
3124 
    result = markOrdersAsDestinationCityReached_result()
3125 
    result.read(self._iprot)
3126 
    self._iprot.readMessageEnd()
3127 
    if result.ex is not None:
3128 
      raise result.ex
3129 
    return
3130 
 
3131 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3132 
    """
3133 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3134 
 
3135 
    Parameters:
3136 
     - providerId
3137 
     - first_atdl_orders
3138 
    """
3139 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3140 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3141 
 
3142 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3143 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3144 
    args = markOrdersAsFirstDeliveryAttempted_args()
3145 
    args.providerId = providerId
3146 
    args.first_atdl_orders = first_atdl_orders
3147 
    args.write(self._oprot)
3148 
    self._oprot.writeMessageEnd()
3149 
    self._oprot.trans.flush()
3150 
 
3151 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3153 
    if mtype == TMessageType.EXCEPTION:
3154 
      x = TApplicationException()
3155 
      x.read(self._iprot)
3156 
      self._iprot.readMessageEnd()
3157 
      raise x
3158 
    result = markOrdersAsFirstDeliveryAttempted_result()
3159 
    result.read(self._iprot)
3160 
    self._iprot.readMessageEnd()
3161 
    if result.ex is not None:
3162 
      raise result.ex
3163 
    return
3164 
 
3064 chandransh 3165 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3166 
    """
3064 chandransh 3167 
    Returns the list of orders whose delivery time has passed but have not been
3168 
    delivered yet for the given provider and warehouse. To get a complete list of
3169 
    undelivered orders, pass them as -1.
3170 
    Returns an empty list if no such orders exist.
3431 rajveer 3171 
 
1886 ankur.sing 3172 
    Parameters:
3064 chandransh 3173 
     - providerId
3174 
     - warehouseId
1886 ankur.sing 3175 
    """
3064 chandransh 3176 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3177 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3178 
 
3064 chandransh 3179 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3180 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3181 
    args = getUndeliveredOrders_args()
3182 
    args.providerId = providerId
3183 
    args.warehouseId = warehouseId
1886 ankur.sing 3184 
    args.write(self._oprot)
3185 
    self._oprot.writeMessageEnd()
3186 
    self._oprot.trans.flush()
3187 
 
3064 chandransh 3188 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3190 
    if mtype == TMessageType.EXCEPTION:
3191 
      x = TApplicationException()
3192 
      x.read(self._iprot)
3193 
      self._iprot.readMessageEnd()
3194 
      raise x
3064 chandransh 3195 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3196 
    result.read(self._iprot)
3197 
    self._iprot.readMessageEnd()
3431 rajveer 3198 
    if result.success is not None:
1886 ankur.sing 3199 
      return result.success
3064 chandransh 3200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3201 
 
4783 phani.kuma 3202 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3203 
    """
3204 
    Returns the list of orders whose expected delivery date has passed but have not been
3205 
    delivered yet.
3206 
    Returns an empty list if no such orders exist.
3207 
    """
3208 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3209 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3210 
 
3211 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3212 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3213 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3214 
    args.write(self._oprot)
3215 
    self._oprot.writeMessageEnd()
3216 
    self._oprot.trans.flush()
3217 
 
3218 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3220 
    if mtype == TMessageType.EXCEPTION:
3221 
      x = TApplicationException()
3222 
      x.read(self._iprot)
3223 
      self._iprot.readMessageEnd()
3224 
      raise x
3225 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3226 
    result.read(self._iprot)
3227 
    self._iprot.readMessageEnd()
3228 
    if result.success is not None:
3229 
      return result.success
3230 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3231 
 
2536 chandransh 3232 
  def toggleDOAFlag(self, orderId):
3233 
    """
3234 
    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.
3235 
    Returns the final flag status.
3236 
    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 3237 
 
2536 chandransh 3238 
    Parameters:
3239 
     - orderId
3240 
    """
3241 
    self.send_toggleDOAFlag(orderId)
3242 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3243 
 
2536 chandransh 3244 
  def send_toggleDOAFlag(self, orderId):
3245 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3246 
    args = toggleDOAFlag_args()
3247 
    args.orderId = orderId
3248 
    args.write(self._oprot)
3249 
    self._oprot.writeMessageEnd()
3250 
    self._oprot.trans.flush()
3251 
 
3252 
  def recv_toggleDOAFlag(self, ):
3253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3254 
    if mtype == TMessageType.EXCEPTION:
3255 
      x = TApplicationException()
3256 
      x.read(self._iprot)
3257 
      self._iprot.readMessageEnd()
3258 
      raise x
3259 
    result = toggleDOAFlag_result()
3260 
    result.read(self._iprot)
3261 
    self._iprot.readMessageEnd()
3431 rajveer 3262 
    if result.success is not None:
2536 chandransh 3263 
      return result.success
3431 rajveer 3264 
    if result.ex is not None:
2536 chandransh 3265 
      raise result.ex
3266 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3267 
 
4712 rajveer 3268 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3269 
    """
3270 
    Parameters:
3271 
     - orderId
3272 
     - deliveryTimestamp
3273 
     - receiver
3274 
    """
3275 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3276 
    self.recv_markOrderAsDelivered()
3277 
 
3278 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3279 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3280 
    args = markOrderAsDelivered_args()
3281 
    args.orderId = orderId
3282 
    args.deliveryTimestamp = deliveryTimestamp
3283 
    args.receiver = receiver
3284 
    args.write(self._oprot)
3285 
    self._oprot.writeMessageEnd()
3286 
    self._oprot.trans.flush()
3287 
 
3288 
  def recv_markOrderAsDelivered(self, ):
3289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3290 
    if mtype == TMessageType.EXCEPTION:
3291 
      x = TApplicationException()
3292 
      x.read(self._iprot)
3293 
      self._iprot.readMessageEnd()
3294 
      raise x
3295 
    result = markOrderAsDelivered_result()
3296 
    result.read(self._iprot)
3297 
    self._iprot.readMessageEnd()
3298 
    if result.ex is not None:
3299 
      raise result.ex
3300 
    return
3301 
 
5553 rajveer 3302 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3303 
    """
3304 
    Parameters:
3305 
     - orderId
3306 
     - deliveryTimestamp
3307 
    """
3308 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3309 
    self.recv_markOrderAsReceivedAtStore()
3310 
 
3311 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3312 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3313 
    args = markOrderAsReceivedAtStore_args()
3314 
    args.orderId = orderId
3315 
    args.deliveryTimestamp = deliveryTimestamp
3316 
    args.write(self._oprot)
3317 
    self._oprot.writeMessageEnd()
3318 
    self._oprot.trans.flush()
3319 
 
3320 
  def recv_markOrderAsReceivedAtStore(self, ):
3321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3322 
    if mtype == TMessageType.EXCEPTION:
3323 
      x = TApplicationException()
3324 
      x.read(self._iprot)
3325 
      self._iprot.readMessageEnd()
3326 
      raise x
3327 
    result = markOrderAsReceivedAtStore_result()
3328 
    result.read(self._iprot)
3329 
    self._iprot.readMessageEnd()
3330 
    if result.ex is not None:
3331 
      raise result.ex
3332 
    return
3333 
 
4454 rajveer 3334 
  def markOrderDoaRequestReceived(self, orderId):
3335 
    """
3336 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3337 
 
3338 
    Parameters:
3339 
     - orderId
3340 
    """
3341 
    self.send_markOrderDoaRequestReceived(orderId)
3342 
    return self.recv_markOrderDoaRequestReceived()
3343 
 
3344 
  def send_markOrderDoaRequestReceived(self, orderId):
3345 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3346 
    args = markOrderDoaRequestReceived_args()
3347 
    args.orderId = orderId
3348 
    args.write(self._oprot)
3349 
    self._oprot.writeMessageEnd()
3350 
    self._oprot.trans.flush()
3351 
 
3352 
  def recv_markOrderDoaRequestReceived(self, ):
3353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3354 
    if mtype == TMessageType.EXCEPTION:
3355 
      x = TApplicationException()
3356 
      x.read(self._iprot)
3357 
      self._iprot.readMessageEnd()
3358 
      raise x
3359 
    result = markOrderDoaRequestReceived_result()
3360 
    result.read(self._iprot)
3361 
    self._iprot.readMessageEnd()
3362 
    if result.success is not None:
3363 
      return result.success
3364 
    if result.ex is not None:
3365 
      raise result.ex
3366 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3367 
 
3368 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3369 
    """
3370 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3371 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3372 
 
3373 
    Parameters:
3374 
     - orderId
3375 
     - isAuthorized
3376 
    """
3377 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3378 
    return self.recv_markOrderDoaRequestAuthorized()
3379 
 
3380 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3381 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3382 
    args = markOrderDoaRequestAuthorized_args()
3383 
    args.orderId = orderId
3384 
    args.isAuthorized = isAuthorized
3385 
    args.write(self._oprot)
3386 
    self._oprot.writeMessageEnd()
3387 
    self._oprot.trans.flush()
3388 
 
3389 
  def recv_markOrderDoaRequestAuthorized(self, ):
3390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3391 
    if mtype == TMessageType.EXCEPTION:
3392 
      x = TApplicationException()
3393 
      x.read(self._iprot)
3394 
      self._iprot.readMessageEnd()
3395 
      raise x
3396 
    result = markOrderDoaRequestAuthorized_result()
3397 
    result.read(self._iprot)
3398 
    self._iprot.readMessageEnd()
3399 
    if result.success is not None:
3400 
      return result.success
3401 
    if result.ex is not None:
3402 
      raise result.ex
3403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3404 
 
4488 rajveer 3405 
  def markOrderReturnRequestReceived(self, orderId):
3406 
    """
3407 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3408 
 
3409 
    Parameters:
3410 
     - orderId
3411 
    """
3412 
    self.send_markOrderReturnRequestReceived(orderId)
3413 
    return self.recv_markOrderReturnRequestReceived()
3414 
 
3415 
  def send_markOrderReturnRequestReceived(self, orderId):
3416 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3417 
    args = markOrderReturnRequestReceived_args()
3418 
    args.orderId = orderId
3419 
    args.write(self._oprot)
3420 
    self._oprot.writeMessageEnd()
3421 
    self._oprot.trans.flush()
3422 
 
3423 
  def recv_markOrderReturnRequestReceived(self, ):
3424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3425 
    if mtype == TMessageType.EXCEPTION:
3426 
      x = TApplicationException()
3427 
      x.read(self._iprot)
3428 
      self._iprot.readMessageEnd()
3429 
      raise x
3430 
    result = markOrderReturnRequestReceived_result()
3431 
    result.read(self._iprot)
3432 
    self._iprot.readMessageEnd()
3433 
    if result.success is not None:
3434 
      return result.success
3435 
    if result.ex is not None:
3436 
      raise result.ex
3437 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3438 
 
3439 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3440 
    """
3441 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3442 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3443 
 
3444 
    Parameters:
3445 
     - orderId
3446 
     - isAuthorized
3447 
    """
3448 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3449 
    return self.recv_markOrderReturnRequestAuthorized()
3450 
 
3451 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3452 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3453 
    args = markOrderReturnRequestAuthorized_args()
3454 
    args.orderId = orderId
3455 
    args.isAuthorized = isAuthorized
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_markOrderReturnRequestAuthorized(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = markOrderReturnRequestAuthorized_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    if result.success is not None:
3471 
      return result.success
3472 
    if result.ex is not None:
3473 
      raise result.ex
3474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3475 
 
4579 rajveer 3476 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3477 
    """
3478 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3479 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3480 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3481 
    For any other status, it returns false.
3482 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3483 
 
2536 chandransh 3484 
    Parameters:
3485 
     - orderId
4579 rajveer 3486 
     - providerId
2536 chandransh 3487 
    """
4579 rajveer 3488 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3489 
    return self.recv_requestPickupNumber()
3490 
 
4579 rajveer 3491 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3492 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3493 
    args = requestPickupNumber_args()
3494 
    args.orderId = orderId
4579 rajveer 3495 
    args.providerId = providerId
2536 chandransh 3496 
    args.write(self._oprot)
3497 
    self._oprot.writeMessageEnd()
3498 
    self._oprot.trans.flush()
3499 
 
3500 
  def recv_requestPickupNumber(self, ):
3501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3502 
    if mtype == TMessageType.EXCEPTION:
3503 
      x = TApplicationException()
3504 
      x.read(self._iprot)
3505 
      self._iprot.readMessageEnd()
3506 
      raise x
3507 
    result = requestPickupNumber_result()
3508 
    result.read(self._iprot)
3509 
    self._iprot.readMessageEnd()
3431 rajveer 3510 
    if result.success is not None:
2536 chandransh 3511 
      return result.success
3431 rajveer 3512 
    if result.ex is not None:
2536 chandransh 3513 
      raise result.ex
3514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3515 
 
4602 rajveer 3516 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3517 
    """
4452 rajveer 3518 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3519 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3520 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3521 
    	3. Returns true
2591 chandransh 3522 
    If the order is in any other status, it returns false.
2536 chandransh 3523 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3524 
 
2536 chandransh 3525 
    Parameters:
3526 
     - orderId
3527 
     - pickupNumber
4602 rajveer 3528 
     - providerId
2536 chandransh 3529 
    """
4602 rajveer 3530 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3531 
    return self.recv_authorizePickup()
3532 
 
4602 rajveer 3533 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3534 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3535 
    args = authorizePickup_args()
3536 
    args.orderId = orderId
3537 
    args.pickupNumber = pickupNumber
4602 rajveer 3538 
    args.providerId = providerId
2536 chandransh 3539 
    args.write(self._oprot)
3540 
    self._oprot.writeMessageEnd()
3541 
    self._oprot.trans.flush()
3542 
 
3543 
  def recv_authorizePickup(self, ):
3544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3545 
    if mtype == TMessageType.EXCEPTION:
3546 
      x = TApplicationException()
3547 
      x.read(self._iprot)
3548 
      self._iprot.readMessageEnd()
3549 
      raise x
3550 
    result = authorizePickup_result()
3551 
    result.read(self._iprot)
3552 
    self._iprot.readMessageEnd()
3431 rajveer 3553 
    if result.success is not None:
2536 chandransh 3554 
      return result.success
3431 rajveer 3555 
    if result.ex is not None:
2536 chandransh 3556 
      raise result.ex
3557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3558 
 
2764 chandransh 3559 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3560 
    """
3561 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3562 
 
2764 chandransh 3563 
    Parameters:
3564 
     - providerId
3565 
     - pickupDetails
3566 
    """
3567 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3568 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3569 
 
3570 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3571 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3572 
    args = markDoasAsPickedUp_args()
3573 
    args.providerId = providerId
3574 
    args.pickupDetails = pickupDetails
3575 
    args.write(self._oprot)
3576 
    self._oprot.writeMessageEnd()
3577 
    self._oprot.trans.flush()
3578 
 
3579 
  def recv_markDoasAsPickedUp(self, ):
3580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3581 
    if mtype == TMessageType.EXCEPTION:
3582 
      x = TApplicationException()
3583 
      x.read(self._iprot)
3584 
      self._iprot.readMessageEnd()
3585 
      raise x
3586 
    result = markDoasAsPickedUp_result()
3587 
    result.read(self._iprot)
3588 
    self._iprot.readMessageEnd()
4910 phani.kuma 3589 
    return
3590 
 
3591 
  def getDoasNotPickedUp(self, providerId):
3592 
    """
3593 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3594 
 
3595 
    Parameters:
3596 
     - providerId
3597 
    """
3598 
    self.send_getDoasNotPickedUp(providerId)
3599 
    return self.recv_getDoasNotPickedUp()
3600 
 
3601 
  def send_getDoasNotPickedUp(self, providerId):
3602 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3603 
    args = getDoasNotPickedUp_args()
3604 
    args.providerId = providerId
3605 
    args.write(self._oprot)
3606 
    self._oprot.writeMessageEnd()
3607 
    self._oprot.trans.flush()
3608 
 
3609 
  def recv_getDoasNotPickedUp(self, ):
3610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3611 
    if mtype == TMessageType.EXCEPTION:
3612 
      x = TApplicationException()
3613 
      x.read(self._iprot)
3614 
      self._iprot.readMessageEnd()
3615 
      raise x
3616 
    result = getDoasNotPickedUp_result()
3617 
    result.read(self._iprot)
3618 
    self._iprot.readMessageEnd()
3431 rajveer 3619 
    if result.success is not None:
2764 chandransh 3620 
      return result.success
4910 phani.kuma 3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3622 
 
4741 phani.kuma 3623 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3624 
    """
3625 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3626 
 
3627 
    Parameters:
3628 
     - providerId
3629 
     - pickupDetails
3630 
    """
3631 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3632 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3633 
 
3634 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3635 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3636 
    args = markReturnOrdersAsPickedUp_args()
3637 
    args.providerId = providerId
3638 
    args.pickupDetails = pickupDetails
3639 
    args.write(self._oprot)
3640 
    self._oprot.writeMessageEnd()
3641 
    self._oprot.trans.flush()
3642 
 
3643 
  def recv_markReturnOrdersAsPickedUp(self, ):
3644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3645 
    if mtype == TMessageType.EXCEPTION:
3646 
      x = TApplicationException()
3647 
      x.read(self._iprot)
3648 
      self._iprot.readMessageEnd()
3649 
      raise x
3650 
    result = markReturnOrdersAsPickedUp_result()
3651 
    result.read(self._iprot)
3652 
    self._iprot.readMessageEnd()
4910 phani.kuma 3653 
    return
3654 
 
3655 
  def getReturnOrdersNotPickedUp(self, providerId):
3656 
    """
3657 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3658 
 
3659 
    Parameters:
3660 
     - providerId
3661 
    """
3662 
    self.send_getReturnOrdersNotPickedUp(providerId)
3663 
    return self.recv_getReturnOrdersNotPickedUp()
3664 
 
3665 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3666 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3667 
    args = getReturnOrdersNotPickedUp_args()
3668 
    args.providerId = providerId
3669 
    args.write(self._oprot)
3670 
    self._oprot.writeMessageEnd()
3671 
    self._oprot.trans.flush()
3672 
 
3673 
  def recv_getReturnOrdersNotPickedUp(self, ):
3674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3675 
    if mtype == TMessageType.EXCEPTION:
3676 
      x = TApplicationException()
3677 
      x.read(self._iprot)
3678 
      self._iprot.readMessageEnd()
3679 
      raise x
3680 
    result = getReturnOrdersNotPickedUp_result()
3681 
    result.read(self._iprot)
3682 
    self._iprot.readMessageEnd()
4741 phani.kuma 3683 
    if result.success is not None:
3684 
      return result.success
4910 phani.kuma 3685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3686 
 
4479 rajveer 3687 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3688 
    """
4452 rajveer 3689 
    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 3690 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3691 
    If the order is in any other state, it returns false.
3692 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3693 
 
2591 chandransh 3694 
    Parameters:
3695 
     - orderId
4479 rajveer 3696 
     - receiveCondition
2591 chandransh 3697 
    """
4479 rajveer 3698 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3699 
    return self.recv_receiveReturn()
2536 chandransh 3700 
 
4479 rajveer 3701 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3702 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3703 
    args = receiveReturn_args()
2591 chandransh 3704 
    args.orderId = orderId
4479 rajveer 3705 
    args.receiveCondition = receiveCondition
2591 chandransh 3706 
    args.write(self._oprot)
3707 
    self._oprot.writeMessageEnd()
3708 
    self._oprot.trans.flush()
3709 
 
2616 chandransh 3710 
  def recv_receiveReturn(self, ):
2591 chandransh 3711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3712 
    if mtype == TMessageType.EXCEPTION:
3713 
      x = TApplicationException()
3714 
      x.read(self._iprot)
3715 
      self._iprot.readMessageEnd()
3716 
      raise x
2616 chandransh 3717 
    result = receiveReturn_result()
2591 chandransh 3718 
    result.read(self._iprot)
3719 
    self._iprot.readMessageEnd()
3431 rajveer 3720 
    if result.success is not None:
2591 chandransh 3721 
      return result.success
3431 rajveer 3722 
    if result.ex is not None:
2591 chandransh 3723 
      raise result.ex
2616 chandransh 3724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3725 
 
3726 
  def validateDoa(self, orderId, isValid):
3727 
    """
4452 rajveer 3728 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3729 
    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 3730 
    If the order is in any other state, it returns false.
3731 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3732 
 
2591 chandransh 3733 
    Parameters:
3734 
     - orderId
3735 
     - isValid
3736 
    """
3737 
    self.send_validateDoa(orderId, isValid)
3738 
    return self.recv_validateDoa()
3739 
 
3740 
  def send_validateDoa(self, orderId, isValid):
3741 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3742 
    args = validateDoa_args()
3743 
    args.orderId = orderId
3744 
    args.isValid = isValid
3745 
    args.write(self._oprot)
3746 
    self._oprot.writeMessageEnd()
3747 
    self._oprot.trans.flush()
3748 
 
3749 
  def recv_validateDoa(self, ):
3750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3751 
    if mtype == TMessageType.EXCEPTION:
3752 
      x = TApplicationException()
3753 
      x.read(self._iprot)
3754 
      self._iprot.readMessageEnd()
3755 
      raise x
3756 
    result = validateDoa_result()
3757 
    result.read(self._iprot)
3758 
    self._iprot.readMessageEnd()
3431 rajveer 3759 
    if result.success is not None:
2591 chandransh 3760 
      return result.success
3431 rajveer 3761 
    if result.ex is not None:
2591 chandransh 3762 
      raise result.ex
3763 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3764 
 
4495 rajveer 3765 
  def validateReturnProduct(self, orderId, isUsable):
3766 
    """
3767 
    Parameters:
3768 
     - orderId
3769 
     - isUsable
3770 
    """
3771 
    self.send_validateReturnProduct(orderId, isUsable)
3772 
    return self.recv_validateReturnProduct()
3773 
 
3774 
  def send_validateReturnProduct(self, orderId, isUsable):
3775 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3776 
    args = validateReturnProduct_args()
3777 
    args.orderId = orderId
3778 
    args.isUsable = isUsable
3779 
    args.write(self._oprot)
3780 
    self._oprot.writeMessageEnd()
3781 
    self._oprot.trans.flush()
3782 
 
3783 
  def recv_validateReturnProduct(self, ):
3784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3785 
    if mtype == TMessageType.EXCEPTION:
3786 
      x = TApplicationException()
3787 
      x.read(self._iprot)
3788 
      self._iprot.readMessageEnd()
3789 
      raise x
3790 
    result = validateReturnProduct_result()
3791 
    result.read(self._iprot)
3792 
    self._iprot.readMessageEnd()
3793 
    if result.success is not None:
3794 
      return result.success
3795 
    if result.ex is not None:
3796 
      raise result.ex
3797 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3798 
 
2616 chandransh 3799 
  def reshipOrder(self, orderId):
3800 
    """
4484 rajveer 3801 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3802 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3803 
    	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 3804 
 
3805 
    If the order is in DOA_CERT_VALID state, it does the following:
3806 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3807 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3808 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3809 
 
2616 chandransh 3810 
    Returns the id of the newly created order.
3431 rajveer 3811 
 
2616 chandransh 3812 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3813 
 
2616 chandransh 3814 
    Parameters:
3815 
     - orderId
3816 
    """
3817 
    self.send_reshipOrder(orderId)
3818 
    return self.recv_reshipOrder()
2591 chandransh 3819 
 
2616 chandransh 3820 
  def send_reshipOrder(self, orderId):
3821 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3822 
    args = reshipOrder_args()
3823 
    args.orderId = orderId
3824 
    args.write(self._oprot)
3825 
    self._oprot.writeMessageEnd()
3826 
    self._oprot.trans.flush()
3827 
 
3828 
  def recv_reshipOrder(self, ):
3829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3830 
    if mtype == TMessageType.EXCEPTION:
3831 
      x = TApplicationException()
3832 
      x.read(self._iprot)
3833 
      self._iprot.readMessageEnd()
3834 
      raise x
3835 
    result = reshipOrder_result()
3836 
    result.read(self._iprot)
3837 
    self._iprot.readMessageEnd()
3431 rajveer 3838 
    if result.success is not None:
2616 chandransh 3839 
      return result.success
3431 rajveer 3840 
    if result.ex is not None:
2616 chandransh 3841 
      raise result.ex
3842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3843 
 
3226 chandransh 3844 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3845 
    """
4484 rajveer 3846 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3847 
    	1. Creates a refund request for batch processing.
3848 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3849 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3850 
 
2616 chandransh 3851 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3852 
    	1. Creates a refund request for batch processing.
3226 chandransh 3853 
    	2. Cancels the reservation of the item in the warehouse.
3854 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3855 
 
3226 chandransh 3856 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3857 
    	1. Cancels the reservation of the item in the warehouse.
3858 
    	2. Marks the current order as CANCELED.
3859 
 
3860 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3861 
 
2616 chandransh 3862 
    Returns True if it is successful, False otherwise.
3431 rajveer 3863 
 
2616 chandransh 3864 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3865 
 
2616 chandransh 3866 
    Parameters:
3867 
     - orderId
3226 chandransh 3868 
     - refundedBy
3869 
     - reason
2616 chandransh 3870 
    """
3226 chandransh 3871 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3872 
    return self.recv_refundOrder()
3873 
 
3226 chandransh 3874 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3875 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3876 
    args = refundOrder_args()
3877 
    args.orderId = orderId
3226 chandransh 3878 
    args.refundedBy = refundedBy
3879 
    args.reason = reason
2616 chandransh 3880 
    args.write(self._oprot)
3881 
    self._oprot.writeMessageEnd()
3882 
    self._oprot.trans.flush()
3883 
 
3884 
  def recv_refundOrder(self, ):
3885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3886 
    if mtype == TMessageType.EXCEPTION:
3887 
      x = TApplicationException()
3888 
      x.read(self._iprot)
3889 
      self._iprot.readMessageEnd()
3890 
      raise x
3891 
    result = refundOrder_result()
3892 
    result.read(self._iprot)
3893 
    self._iprot.readMessageEnd()
3431 rajveer 3894 
    if result.success is not None:
2616 chandransh 3895 
      return result.success
3431 rajveer 3896 
    if result.ex is not None:
2616 chandransh 3897 
      raise result.ex
3898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3899 
 
2690 chandransh 3900 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3901 
    """
3902 
    Get all return orders created between the from and to dates for the given warehouse.
3903 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3904 
 
2690 chandransh 3905 
    Parameters:
3906 
     - warehouseId
3907 
     - fromDate
3908 
     - toDate
3909 
    """
3910 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3911 
    return self.recv_getReturnOrders()
2616 chandransh 3912 
 
2690 chandransh 3913 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3914 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3915 
    args = getReturnOrders_args()
3916 
    args.warehouseId = warehouseId
3917 
    args.fromDate = fromDate
3918 
    args.toDate = toDate
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_getReturnOrders(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = getReturnOrders_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3431 rajveer 3933 
    if result.success is not None:
2690 chandransh 3934 
      return result.success
3935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3936 
 
5481 phani.kuma 3937 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3938 
    """
3939 
    Get all return orders created between the from and to dates.
3940 
 
3941 
    Parameters:
3942 
     - onlyNotProcessed
3943 
     - fromDate
3944 
     - toDate
3945 
    """
3946 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3947 
    return self.recv_getAllReturnOrders()
3948 
 
3949 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3950 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3951 
    args = getAllReturnOrders_args()
3952 
    args.onlyNotProcessed = onlyNotProcessed
3953 
    args.fromDate = fromDate
3954 
    args.toDate = toDate
3955 
    args.write(self._oprot)
3956 
    self._oprot.writeMessageEnd()
3957 
    self._oprot.trans.flush()
3958 
 
3959 
  def recv_getAllReturnOrders(self, ):
3960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3961 
    if mtype == TMessageType.EXCEPTION:
3962 
      x = TApplicationException()
3963 
      x.read(self._iprot)
3964 
      self._iprot.readMessageEnd()
3965 
      raise x
3966 
    result = getAllReturnOrders_result()
3967 
    result.read(self._iprot)
3968 
    self._iprot.readMessageEnd()
3969 
    if result.success is not None:
3970 
      return result.success
3971 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3972 
 
2700 chandransh 3973 
  def getReturnOrder(self, id):
3974 
    """
3975 
    Returns the ReturnOrder corresponding to the given id.
3976 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3977 
 
2700 chandransh 3978 
    Parameters:
3979 
     - id
3980 
    """
3981 
    self.send_getReturnOrder(id)
3982 
    return self.recv_getReturnOrder()
3983 
 
3984 
  def send_getReturnOrder(self, id):
3985 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3986 
    args = getReturnOrder_args()
3987 
    args.id = id
3988 
    args.write(self._oprot)
3989 
    self._oprot.writeMessageEnd()
3990 
    self._oprot.trans.flush()
3991 
 
3992 
  def recv_getReturnOrder(self, ):
3993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3994 
    if mtype == TMessageType.EXCEPTION:
3995 
      x = TApplicationException()
3996 
      x.read(self._iprot)
3997 
      self._iprot.readMessageEnd()
3998 
      raise x
3999 
    result = getReturnOrder_result()
4000 
    result.read(self._iprot)
4001 
    self._iprot.readMessageEnd()
3431 rajveer 4002 
    if result.success is not None:
2700 chandransh 4003 
      return result.success
3431 rajveer 4004 
    if result.ex is not None:
2700 chandransh 4005 
      raise result.ex
4006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4007 
 
2690 chandransh 4008 
  def processReturn(self, returnOrderId):
4009 
    """
4010 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4011 
 
2690 chandransh 4012 
    Parameters:
4013 
     - returnOrderId
4014 
    """
4015 
    self.send_processReturn(returnOrderId)
4016 
    self.recv_processReturn()
4017 
 
4018 
  def send_processReturn(self, returnOrderId):
4019 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4020 
    args = processReturn_args()
4021 
    args.returnOrderId = returnOrderId
4022 
    args.write(self._oprot)
4023 
    self._oprot.writeMessageEnd()
4024 
    self._oprot.trans.flush()
4025 
 
4026 
  def recv_processReturn(self, ):
4027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4028 
    if mtype == TMessageType.EXCEPTION:
4029 
      x = TApplicationException()
4030 
      x.read(self._iprot)
4031 
      self._iprot.readMessageEnd()
4032 
      raise x
4033 
    result = processReturn_result()
4034 
    result.read(self._iprot)
4035 
    self._iprot.readMessageEnd()
3431 rajveer 4036 
    if result.ex is not None:
2690 chandransh 4037 
      raise result.ex
4038 
    return
4039 
 
3451 chandransh 4040 
  def updateWeight(self, orderId, weight):
4041 
    """
4042 
    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 4043 
 
3451 chandransh 4044 
    Parameters:
4045 
     - orderId
4046 
     - weight
4047 
    """
4048 
    self.send_updateWeight(orderId, weight)
4049 
    return self.recv_updateWeight()
4050 
 
4051 
  def send_updateWeight(self, orderId, weight):
4052 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4053 
    args = updateWeight_args()
4054 
    args.orderId = orderId
4055 
    args.weight = weight
4056 
    args.write(self._oprot)
4057 
    self._oprot.writeMessageEnd()
4058 
    self._oprot.trans.flush()
4059 
 
4060 
  def recv_updateWeight(self, ):
4061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4062 
    if mtype == TMessageType.EXCEPTION:
4063 
      x = TApplicationException()
4064 
      x.read(self._iprot)
4065 
      self._iprot.readMessageEnd()
4066 
      raise x
4067 
    result = updateWeight_result()
4068 
    result.read(self._iprot)
4069 
    self._iprot.readMessageEnd()
4070 
    if result.success is not None:
4071 
      return result.success
4072 
    if result.ex is not None:
4073 
      raise result.ex
4074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4075 
 
3469 chandransh 4076 
  def changeItem(self, orderId, itemId):
4077 
    """
4078 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4079 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4080 
 
3469 chandransh 4081 
    Parameters:
4082 
     - orderId
4083 
     - itemId
4084 
    """
4085 
    self.send_changeItem(orderId, itemId)
4086 
    return self.recv_changeItem()
4087 
 
4088 
  def send_changeItem(self, orderId, itemId):
4089 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4090 
    args = changeItem_args()
4091 
    args.orderId = orderId
4092 
    args.itemId = itemId
4093 
    args.write(self._oprot)
4094 
    self._oprot.writeMessageEnd()
4095 
    self._oprot.trans.flush()
4096 
 
4097 
  def recv_changeItem(self, ):
4098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4099 
    if mtype == TMessageType.EXCEPTION:
4100 
      x = TApplicationException()
4101 
      x.read(self._iprot)
4102 
      self._iprot.readMessageEnd()
4103 
      raise x
4104 
    result = changeItem_result()
4105 
    result.read(self._iprot)
4106 
    self._iprot.readMessageEnd()
4107 
    if result.success is not None:
4108 
      return result.success
4109 
    if result.ex is not None:
4110 
      raise result.ex
4111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4112 
 
4113 
  def shiftToWarehouse(self, orderId, warehouseId):
4114 
    """
4115 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4116 
 
4117 
    Parameters:
4118 
     - orderId
4119 
     - warehouseId
4120 
    """
4121 
    self.send_shiftToWarehouse(orderId, warehouseId)
4122 
    return self.recv_shiftToWarehouse()
4123 
 
4124 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4125 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4126 
    args = shiftToWarehouse_args()
4127 
    args.orderId = orderId
4128 
    args.warehouseId = warehouseId
4129 
    args.write(self._oprot)
4130 
    self._oprot.writeMessageEnd()
4131 
    self._oprot.trans.flush()
4132 
 
4133 
  def recv_shiftToWarehouse(self, ):
4134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4135 
    if mtype == TMessageType.EXCEPTION:
4136 
      x = TApplicationException()
4137 
      x.read(self._iprot)
4138 
      self._iprot.readMessageEnd()
4139 
      raise x
4140 
    result = shiftToWarehouse_result()
4141 
    result.read(self._iprot)
4142 
    self._iprot.readMessageEnd()
4143 
    if result.success is not None:
4144 
      return result.success
4145 
    if result.ex is not None:
4146 
      raise result.ex
4147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4148 
 
4647 rajveer 4149 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4150 
    """
4151 
    Adds the given delay reason to the given order.
3986 chandransh 4152 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4153 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4154 
 
3553 chandransh 4155 
    Parameters:
4156 
     - orderId
4157 
     - delayReason
3986 chandransh 4158 
     - furtherDelay
4647 rajveer 4159 
     - delayReasonText
3553 chandransh 4160 
    """
4647 rajveer 4161 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4162 
    return self.recv_addDelayReason()
4163 
 
4647 rajveer 4164 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4165 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4166 
    args = addDelayReason_args()
4167 
    args.orderId = orderId
4168 
    args.delayReason = delayReason
3986 chandransh 4169 
    args.furtherDelay = furtherDelay
4647 rajveer 4170 
    args.delayReasonText = delayReasonText
3553 chandransh 4171 
    args.write(self._oprot)
4172 
    self._oprot.writeMessageEnd()
4173 
    self._oprot.trans.flush()
4174 
 
4175 
  def recv_addDelayReason(self, ):
4176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4177 
    if mtype == TMessageType.EXCEPTION:
4178 
      x = TApplicationException()
4179 
      x.read(self._iprot)
4180 
      self._iprot.readMessageEnd()
4181 
      raise x
4182 
    result = addDelayReason_result()
4183 
    result.read(self._iprot)
4184 
    self._iprot.readMessageEnd()
4185 
    if result.success is not None:
4186 
      return result.success
4187 
    if result.ex is not None:
4188 
      raise result.ex
4189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4190 
 
3956 chandransh 4191 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4192 
    """
4193 
    Marks the COD orders with given AWB nos. as having been processed.
4194 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4195 
 
3956 chandransh 4196 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4197 
    1. There is no order corresponding to an AWB number.
4198 
    2. The captured amount for a payment exceeds the total payment.
4199 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4200 
 
4201 
    Parameters:
4202 
     - collectedAmountMap
4203 
     - xferBy
4204 
     - xferTxnId
4205 
     - xferDate
4206 
    """
4207 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4208 
    return self.recv_reconcileCodCollection()
4209 
 
4210 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4211 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4212 
    args = reconcileCodCollection_args()
4213 
    args.collectedAmountMap = collectedAmountMap
4214 
    args.xferBy = xferBy
4215 
    args.xferTxnId = xferTxnId
4216 
    args.xferDate = xferDate
4217 
    args.write(self._oprot)
4218 
    self._oprot.writeMessageEnd()
4219 
    self._oprot.trans.flush()
4220 
 
4221 
  def recv_reconcileCodCollection(self, ):
4222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4223 
    if mtype == TMessageType.EXCEPTION:
4224 
      x = TApplicationException()
4225 
      x.read(self._iprot)
4226 
      self._iprot.readMessageEnd()
4227 
      raise x
4228 
    result = reconcileCodCollection_result()
4229 
    result.read(self._iprot)
4230 
    self._iprot.readMessageEnd()
4231 
    if result.success is not None:
4232 
      return result.success
4233 
    if result.ex is not None:
4234 
      raise result.ex
4235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4236 
 
4008 mandeep.dh 4237 
  def getTransactionsRequiringExtraProcessing(self, category):
4238 
    """
4065 mandeep.dh 4239 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4240 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4241 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4242 
 
4008 mandeep.dh 4243 
    Parameters:
4244 
     - category
4245 
    """
4246 
    self.send_getTransactionsRequiringExtraProcessing(category)
4247 
    return self.recv_getTransactionsRequiringExtraProcessing()
4248 
 
4249 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4250 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4251 
    args = getTransactionsRequiringExtraProcessing_args()
4252 
    args.category = category
4253 
    args.write(self._oprot)
4254 
    self._oprot.writeMessageEnd()
4255 
    self._oprot.trans.flush()
4256 
 
4257 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4259 
    if mtype == TMessageType.EXCEPTION:
4260 
      x = TApplicationException()
4261 
      x.read(self._iprot)
4262 
      self._iprot.readMessageEnd()
4263 
      raise x
4264 
    result = getTransactionsRequiringExtraProcessing_result()
4265 
    result.read(self._iprot)
4266 
    self._iprot.readMessageEnd()
4267 
    if result.success is not None:
4268 
      return result.success
4269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4270 
 
4271 
  def markTransactionAsProcessed(self, transactionId, category):
4272 
    """
4273 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4274 
    It essentially deletes the transaction id record for a particular
4275 
    processing type category (if present) from DB.
4276 
    This is currently used by CRM application.
4008 mandeep.dh 4277 
 
4278 
    Parameters:
4279 
     - transactionId
4280 
     - category
4281 
    """
4282 
    self.send_markTransactionAsProcessed(transactionId, category)
4283 
    self.recv_markTransactionAsProcessed()
4284 
 
4285 
  def send_markTransactionAsProcessed(self, transactionId, category):
4286 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4287 
    args = markTransactionAsProcessed_args()
4288 
    args.transactionId = transactionId
4289 
    args.category = category
4290 
    args.write(self._oprot)
4291 
    self._oprot.writeMessageEnd()
4292 
    self._oprot.trans.flush()
4293 
 
4294 
  def recv_markTransactionAsProcessed(self, ):
4295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4296 
    if mtype == TMessageType.EXCEPTION:
4297 
      x = TApplicationException()
4298 
      x.read(self._iprot)
4299 
      self._iprot.readMessageEnd()
4300 
      raise x
4301 
    result = markTransactionAsProcessed_result()
4302 
    result.read(self._iprot)
4303 
    self._iprot.readMessageEnd()
4304 
    return
4305 
 
4018 chandransh 4306 
  def getItemWiseRiskyOrdersCount(self, ):
4307 
    """
4308 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4309 
    is defined as one whose shipping date is about to expire.
4310 
    """
4311 
    self.send_getItemWiseRiskyOrdersCount()
4312 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4313 
 
4018 chandransh 4314 
  def send_getItemWiseRiskyOrdersCount(self, ):
4315 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4316 
    args = getItemWiseRiskyOrdersCount_args()
4317 
    args.write(self._oprot)
4318 
    self._oprot.writeMessageEnd()
4319 
    self._oprot.trans.flush()
4320 
 
4321 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4323 
    if mtype == TMessageType.EXCEPTION:
4324 
      x = TApplicationException()
4325 
      x.read(self._iprot)
4326 
      self._iprot.readMessageEnd()
4327 
      raise x
4328 
    result = getItemWiseRiskyOrdersCount_result()
4329 
    result.read(self._iprot)
4330 
    self._iprot.readMessageEnd()
4331 
    if result.success is not None:
4332 
      return result.success
4333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4334 
 
4295 varun.gupt 4335 
  def getOrdersForItemIds(self, itemIds):
4336 
    """
4337 
    Returns a list of all orders which have items with given id
4338 
 
4339 
    Parameters:
4340 
     - itemIds
4341 
    """
4342 
    self.send_getOrdersForItemIds(itemIds)
4343 
    return self.recv_getOrdersForItemIds()
4344 
 
4345 
  def send_getOrdersForItemIds(self, itemIds):
4346 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4347 
    args = getOrdersForItemIds_args()
4348 
    args.itemIds = itemIds
4349 
    args.write(self._oprot)
4350 
    self._oprot.writeMessageEnd()
4351 
    self._oprot.trans.flush()
4352 
 
4353 
  def recv_getOrdersForItemIds(self, ):
4354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4355 
    if mtype == TMessageType.EXCEPTION:
4356 
      x = TApplicationException()
4357 
      x.read(self._iprot)
4358 
      self._iprot.readMessageEnd()
4359 
      raise x
4360 
    result = getOrdersForItemIds_result()
4361 
    result.read(self._iprot)
4362 
    self._iprot.readMessageEnd()
4363 
    if result.success is not None:
4364 
      return result.success
4365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4366 
 
4247 rajveer 4367 
  def markOrderCancellationRequestReceived(self, orderId):
4368 
    """
4369 
    Mark order as cancellation request received. If customer sends request of cancellation of
4370 
    a particular order, this method will be called. It will just change status of the order
4371 
    depending on its current status. It also records the previous status, so that we can move
4372 
    back to that status if cancellation request is denied.
4018 chandransh 4373 
 
4247 rajveer 4374 
    Parameters:
4375 
     - orderId
4376 
    """
4377 
    self.send_markOrderCancellationRequestReceived(orderId)
4378 
    self.recv_markOrderCancellationRequestReceived()
4379 
 
4380 
  def send_markOrderCancellationRequestReceived(self, orderId):
4381 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4382 
    args = markOrderCancellationRequestReceived_args()
4383 
    args.orderId = orderId
4384 
    args.write(self._oprot)
4385 
    self._oprot.writeMessageEnd()
4386 
    self._oprot.trans.flush()
4387 
 
4388 
  def recv_markOrderCancellationRequestReceived(self, ):
4389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4390 
    if mtype == TMessageType.EXCEPTION:
4391 
      x = TApplicationException()
4392 
      x.read(self._iprot)
4393 
      self._iprot.readMessageEnd()
4394 
      raise x
4395 
    result = markOrderCancellationRequestReceived_result()
4396 
    result.read(self._iprot)
4397 
    self._iprot.readMessageEnd()
4398 
    if result.ex is not None:
4399 
      raise result.ex
4400 
    return
4401 
 
4402 
  def markOrderCancellationRequestConfirmed(self, orderId):
4403 
    """
4404 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4405 
    cancellation request confirmed. After this OM will be able to cancel the order.
4406 
 
4407 
    Parameters:
4408 
     - orderId
4409 
    """
4410 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4411 
    self.recv_markOrderCancellationRequestConfirmed()
4412 
 
4413 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4414 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4415 
    args = markOrderCancellationRequestConfirmed_args()
4416 
    args.orderId = orderId
4417 
    args.write(self._oprot)
4418 
    self._oprot.writeMessageEnd()
4419 
    self._oprot.trans.flush()
4420 
 
4421 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4423 
    if mtype == TMessageType.EXCEPTION:
4424 
      x = TApplicationException()
4425 
      x.read(self._iprot)
4426 
      self._iprot.readMessageEnd()
4427 
      raise x
4428 
    result = markOrderCancellationRequestConfirmed_result()
4429 
    result.read(self._iprot)
4430 
    self._iprot.readMessageEnd()
4431 
    if result.ex is not None:
4432 
      raise result.ex
4433 
    return
4434 
 
4435 
  def markOrderCancellationRequestDenied(self, orderId):
4436 
    """
4437 
    If we decide to not to cancel order, we will move the order ro previous status.
4438 
 
4439 
    Parameters:
4440 
     - orderId
4441 
    """
4442 
    self.send_markOrderCancellationRequestDenied(orderId)
4443 
    self.recv_markOrderCancellationRequestDenied()
4444 
 
4445 
  def send_markOrderCancellationRequestDenied(self, orderId):
4446 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4447 
    args = markOrderCancellationRequestDenied_args()
4448 
    args.orderId = orderId
4449 
    args.write(self._oprot)
4450 
    self._oprot.writeMessageEnd()
4451 
    self._oprot.trans.flush()
4452 
 
4453 
  def recv_markOrderCancellationRequestDenied(self, ):
4454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4455 
    if mtype == TMessageType.EXCEPTION:
4456 
      x = TApplicationException()
4457 
      x.read(self._iprot)
4458 
      self._iprot.readMessageEnd()
4459 
      raise x
4460 
    result = markOrderCancellationRequestDenied_result()
4461 
    result.read(self._iprot)
4462 
    self._iprot.readMessageEnd()
4463 
    if result.ex is not None:
4464 
      raise result.ex
4465 
    return
4466 
 
4258 rajveer 4467 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4468 
    """
4258 rajveer 4469 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4470 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4471 
 
4472 
    Parameters:
4258 rajveer 4473 
     - transactionId
4247 rajveer 4474 
    """
4258 rajveer 4475 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4476 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4477 
 
4258 rajveer 4478 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4479 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4480 
    args = markTransactionAsPaymentFlagRemoved_args()
4481 
    args.transactionId = transactionId
4247 rajveer 4482 
    args.write(self._oprot)
4483 
    self._oprot.writeMessageEnd()
4484 
    self._oprot.trans.flush()
4485 
 
4258 rajveer 4486 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4487 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4488 
    if mtype == TMessageType.EXCEPTION:
4489 
      x = TApplicationException()
4490 
      x.read(self._iprot)
4491 
      self._iprot.readMessageEnd()
4492 
      raise x
4258 rajveer 4493 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4494 
    result.read(self._iprot)
4495 
    self._iprot.readMessageEnd()
4496 
    if result.ex is not None:
4497 
      raise result.ex
4498 
    return
4499 
 
4259 anupam.sin 4500 
  def refundTransaction(self, transactionId, refundedBy, reason):
4501 
    """
4502 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4503 
    need to be cancelled
4247 rajveer 4504 
 
4259 anupam.sin 4505 
    Parameters:
4506 
     - transactionId
4507 
     - refundedBy
4508 
     - reason
4509 
    """
4510 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4511 
    self.recv_refundTransaction()
4512 
 
4513 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4514 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4515 
    args = refundTransaction_args()
4516 
    args.transactionId = transactionId
4517 
    args.refundedBy = refundedBy
4518 
    args.reason = reason
4519 
    args.write(self._oprot)
4520 
    self._oprot.writeMessageEnd()
4521 
    self._oprot.trans.flush()
4522 
 
4523 
  def recv_refundTransaction(self, ):
4524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4525 
    if mtype == TMessageType.EXCEPTION:
4526 
      x = TApplicationException()
4527 
      x.read(self._iprot)
4528 
      self._iprot.readMessageEnd()
4529 
      raise x
4530 
    result = refundTransaction_result()
4531 
    result.read(self._iprot)
4532 
    self._iprot.readMessageEnd()
4533 
    if result.ex is not None:
4534 
      raise result.ex
4535 
    return
4536 
 
4324 mandeep.dh 4537 
  def updateShipmentAddress(self, orderId, addressId):
4538 
    """
4539 
    Updates shipment address of an order. Delivery and shipping date estimates
4540 
    etc. are also updated here.
4541 
 
4542 
    Throws TransactionServiceException in case address change is not
4543 
    possible due to certain reasons such as new pincode in address is
4544 
    not serviceable etc.
4545 
 
4546 
    Parameters:
4547 
     - orderId
4548 
     - addressId
4549 
    """
4550 
    self.send_updateShipmentAddress(orderId, addressId)
4551 
    self.recv_updateShipmentAddress()
4552 
 
4553 
  def send_updateShipmentAddress(self, orderId, addressId):
4554 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4555 
    args = updateShipmentAddress_args()
4556 
    args.orderId = orderId
4557 
    args.addressId = addressId
4558 
    args.write(self._oprot)
4559 
    self._oprot.writeMessageEnd()
4560 
    self._oprot.trans.flush()
4561 
 
4562 
  def recv_updateShipmentAddress(self, ):
4563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4564 
    if mtype == TMessageType.EXCEPTION:
4565 
      x = TApplicationException()
4566 
      x.read(self._iprot)
4567 
      self._iprot.readMessageEnd()
4568 
      raise x
4569 
    result = updateShipmentAddress_result()
4570 
    result.read(self._iprot)
4571 
    self._iprot.readMessageEnd()
4572 
    if result.ex is not None:
4573 
      raise result.ex
4574 
    return
4575 
 
4285 rajveer 4576 
  def acceptOrdersForItemId(self, itemId, inventory):
4577 
    """
4578 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4579 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4580 
 
4285 rajveer 4581 
    Parameters:
4582 
     - itemId
4583 
     - inventory
4584 
    """
4585 
    self.send_acceptOrdersForItemId(itemId, inventory)
4586 
    return self.recv_acceptOrdersForItemId()
4587 
 
4588 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4589 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4590 
    args = acceptOrdersForItemId_args()
4591 
    args.itemId = itemId
4592 
    args.inventory = inventory
4593 
    args.write(self._oprot)
4594 
    self._oprot.writeMessageEnd()
4595 
    self._oprot.trans.flush()
4596 
 
4597 
  def recv_acceptOrdersForItemId(self, ):
4598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4599 
    if mtype == TMessageType.EXCEPTION:
4600 
      x = TApplicationException()
4601 
      x.read(self._iprot)
4602 
      self._iprot.readMessageEnd()
4603 
      raise x
4604 
    result = acceptOrdersForItemId_result()
4605 
    result.read(self._iprot)
4606 
    self._iprot.readMessageEnd()
4607 
    if result.success is not None:
4608 
      return result.success
4609 
    if result.ex is not None:
4610 
      raise result.ex
4611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4612 
 
4369 rajveer 4613 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4614 
    """
4615 
    Parameters:
4616 
     - vendorId
4617 
     - itemId
4618 
     - quantity
4619 
     - estimate
4369 rajveer 4620 
     - isReminder
4303 rajveer 4621 
    """
4369 rajveer 4622 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4623 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4624 
 
4369 rajveer 4625 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4626 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4627 
    args = markOrdersAsPORaised_args()
4628 
    args.vendorId = vendorId
4629 
    args.itemId = itemId
4630 
    args.quantity = quantity
4631 
    args.estimate = estimate
4369 rajveer 4632 
    args.isReminder = isReminder
4303 rajveer 4633 
    args.write(self._oprot)
4634 
    self._oprot.writeMessageEnd()
4635 
    self._oprot.trans.flush()
4636 
 
4637 
  def recv_markOrdersAsPORaised(self, ):
4638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4639 
    if mtype == TMessageType.EXCEPTION:
4640 
      x = TApplicationException()
4641 
      x.read(self._iprot)
4642 
      self._iprot.readMessageEnd()
4643 
      raise x
4644 
    result = markOrdersAsPORaised_result()
4645 
    result.read(self._iprot)
4646 
    self._iprot.readMessageEnd()
4647 
    if result.ex is not None:
4648 
      raise result.ex
4649 
    return
4650 
 
4369 rajveer 4651 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4652 
    """
4653 
    Parameters:
4654 
     - vendorId
4655 
     - itemId
4656 
     - quantity
4657 
     - estimate
4369 rajveer 4658 
     - isReminder
4303 rajveer 4659 
    """
4369 rajveer 4660 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4661 
    self.recv_markOrdersAsReversalInitiated()
4662 
 
4369 rajveer 4663 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4664 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4665 
    args = markOrdersAsReversalInitiated_args()
4666 
    args.vendorId = vendorId
4667 
    args.itemId = itemId
4668 
    args.quantity = quantity
4669 
    args.estimate = estimate
4369 rajveer 4670 
    args.isReminder = isReminder
4303 rajveer 4671 
    args.write(self._oprot)
4672 
    self._oprot.writeMessageEnd()
4673 
    self._oprot.trans.flush()
4674 
 
4675 
  def recv_markOrdersAsReversalInitiated(self, ):
4676 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4677 
    if mtype == TMessageType.EXCEPTION:
4678 
      x = TApplicationException()
4679 
      x.read(self._iprot)
4680 
      self._iprot.readMessageEnd()
4681 
      raise x
4682 
    result = markOrdersAsReversalInitiated_result()
4683 
    result.read(self._iprot)
4684 
    self._iprot.readMessageEnd()
4685 
    if result.ex is not None:
4686 
      raise result.ex
4687 
    return
4688 
 
4369 rajveer 4689 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4690 
    """
4691 
    Parameters:
4692 
     - vendorId
4693 
     - itemId
4694 
     - quantity
4695 
     - estimate
4369 rajveer 4696 
     - isReminder
4303 rajveer 4697 
    """
4369 rajveer 4698 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4699 
    self.recv_markOrdersAsNotAvailabke()
4700 
 
4369 rajveer 4701 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4702 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4703 
    args = markOrdersAsNotAvailabke_args()
4704 
    args.vendorId = vendorId
4705 
    args.itemId = itemId
4706 
    args.quantity = quantity
4707 
    args.estimate = estimate
4369 rajveer 4708 
    args.isReminder = isReminder
4303 rajveer 4709 
    args.write(self._oprot)
4710 
    self._oprot.writeMessageEnd()
4711 
    self._oprot.trans.flush()
4712 
 
4713 
  def recv_markOrdersAsNotAvailabke(self, ):
4714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4715 
    if mtype == TMessageType.EXCEPTION:
4716 
      x = TApplicationException()
4717 
      x.read(self._iprot)
4718 
      self._iprot.readMessageEnd()
4719 
      raise x
4720 
    result = markOrdersAsNotAvailabke_result()
4721 
    result.read(self._iprot)
4722 
    self._iprot.readMessageEnd()
4723 
    if result.ex is not None:
4724 
      raise result.ex
4725 
    return
4726 
 
4369 rajveer 4727 
  def markOrdersAsTimeout(self, vendorId):
4728 
    """
4729 
    Parameters:
4730 
     - vendorId
4731 
    """
4732 
    self.send_markOrdersAsTimeout(vendorId)
4733 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4734 
 
4369 rajveer 4735 
  def send_markOrdersAsTimeout(self, vendorId):
4736 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4737 
    args = markOrdersAsTimeout_args()
4738 
    args.vendorId = vendorId
4739 
    args.write(self._oprot)
4740 
    self._oprot.writeMessageEnd()
4741 
    self._oprot.trans.flush()
4742 
 
4743 
  def recv_markOrdersAsTimeout(self, ):
4744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4745 
    if mtype == TMessageType.EXCEPTION:
4746 
      x = TApplicationException()
4747 
      x.read(self._iprot)
4748 
      self._iprot.readMessageEnd()
4749 
      raise x
4750 
    result = markOrdersAsTimeout_result()
4751 
    result.read(self._iprot)
4752 
    self._iprot.readMessageEnd()
4753 
    if result.success is not None:
4754 
      return result.success
4755 
    if result.ex is not None:
4756 
      raise result.ex
4757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4758 
 
4662 rajveer 4759 
  def markOrderAsLostInTransit(self, orderId):
4760 
    """
4761 
    Mark order as LOST_IN_TRANSIT
4762 
 
4763 
    Parameters:
4764 
     - orderId
4765 
    """
4766 
    self.send_markOrderAsLostInTransit(orderId)
4767 
    return self.recv_markOrderAsLostInTransit()
4768 
 
4769 
  def send_markOrderAsLostInTransit(self, orderId):
4770 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4771 
    args = markOrderAsLostInTransit_args()
4772 
    args.orderId = orderId
4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_markOrderAsLostInTransit(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = markOrderAsLostInTransit_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.success is not None:
4788 
      return result.success
4789 
    if result.ex is not None:
4790 
      raise result.ex
4791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4792 
 
4386 anupam.sin 4793 
  def getOrderForAwb(self, awb):
4794 
    """
4795 
    Returns the order corresponding to an AWB number
4369 rajveer 4796 
 
4386 anupam.sin 4797 
    Parameters:
4798 
     - awb
4799 
    """
4800 
    self.send_getOrderForAwb(awb)
4801 
    return self.recv_getOrderForAwb()
4802 
 
4803 
  def send_getOrderForAwb(self, awb):
4804 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4805 
    args = getOrderForAwb_args()
4806 
    args.awb = awb
4807 
    args.write(self._oprot)
4808 
    self._oprot.writeMessageEnd()
4809 
    self._oprot.trans.flush()
4810 
 
4811 
  def recv_getOrderForAwb(self, ):
4812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4813 
    if mtype == TMessageType.EXCEPTION:
4814 
      x = TApplicationException()
4815 
      x.read(self._iprot)
4816 
      self._iprot.readMessageEnd()
4817 
      raise x
4818 
    result = getOrderForAwb_result()
4819 
    result.read(self._iprot)
4820 
    self._iprot.readMessageEnd()
4821 
    if result.success is not None:
4822 
      return result.success
4823 
    if result.ex is not None:
4824 
      raise result.ex
4825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4826 
 
4910 phani.kuma 4827 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4828 
    """
4910 phani.kuma 4829 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4830 
 
4506 phani.kuma 4831 
    Parameters:
4832 
     - logistics_provider_id
4910 phani.kuma 4833 
     - order_status_list
4506 phani.kuma 4834 
    """
4910 phani.kuma 4835 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4836 
    return self.recv_getOrdersForProviderForStatus()
4837 
 
4910 phani.kuma 4838 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4839 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4840 
    args = getOrdersForProviderForStatus_args()
4841 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4842 
    args.order_status_list = order_status_list
4506 phani.kuma 4843 
    args.write(self._oprot)
4844 
    self._oprot.writeMessageEnd()
4845 
    self._oprot.trans.flush()
4846 
 
4847 
  def recv_getOrdersForProviderForStatus(self, ):
4848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4849 
    if mtype == TMessageType.EXCEPTION:
4850 
      x = TApplicationException()
4851 
      x.read(self._iprot)
4852 
      self._iprot.readMessageEnd()
4853 
      raise x
4854 
    result = getOrdersForProviderForStatus_result()
4855 
    result.read(self._iprot)
4856 
    self._iprot.readMessageEnd()
4857 
    if result.success is not None:
4858 
      return result.success
4859 
    if result.ex is not None:
4860 
      raise result.ex
4861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4862 
 
4600 varun.gupt 4863 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4864 
    """
4865 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4866 
 
4600 varun.gupt 4867 
    Parameters:
4868 
     - vendorId
4869 
     - billingDateFrom
4870 
     - billingDateTo
4871 
    """
4872 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4873 
    return self.recv_getBilledOrdersForVendor()
4874 
 
4875 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4876 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4877 
    args = getBilledOrdersForVendor_args()
4878 
    args.vendorId = vendorId
4879 
    args.billingDateFrom = billingDateFrom
4880 
    args.billingDateTo = billingDateTo
4881 
    args.write(self._oprot)
4882 
    self._oprot.writeMessageEnd()
4883 
    self._oprot.trans.flush()
4884 
 
4885 
  def recv_getBilledOrdersForVendor(self, ):
4886 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4887 
    if mtype == TMessageType.EXCEPTION:
4888 
      x = TApplicationException()
4889 
      x.read(self._iprot)
4890 
      self._iprot.readMessageEnd()
4891 
      raise x
4892 
    result = getBilledOrdersForVendor_result()
4893 
    result.read(self._iprot)
4894 
    self._iprot.readMessageEnd()
4895 
    if result.success is not None:
4896 
      return result.success
4897 
    if result.ex is not None:
4898 
      raise result.ex
4899 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4900 
 
4607 rajveer 4901 
  def getSlippedSippingDateOrders(self, ):
4902 
    self.send_getSlippedSippingDateOrders()
4903 
    return self.recv_getSlippedSippingDateOrders()
4904 
 
4905 
  def send_getSlippedSippingDateOrders(self, ):
4906 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4907 
    args = getSlippedSippingDateOrders_args()
4908 
    args.write(self._oprot)
4909 
    self._oprot.writeMessageEnd()
4910 
    self._oprot.trans.flush()
4911 
 
4912 
  def recv_getSlippedSippingDateOrders(self, ):
4913 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4914 
    if mtype == TMessageType.EXCEPTION:
4915 
      x = TApplicationException()
4916 
      x.read(self._iprot)
4917 
      self._iprot.readMessageEnd()
4918 
      raise x
4919 
    result = getSlippedSippingDateOrders_result()
4920 
    result.read(self._iprot)
4921 
    self._iprot.readMessageEnd()
4922 
    if result.success is not None:
4923 
      return result.success
4924 
    if result.ex is not None:
4925 
      raise result.ex
4926 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4927 
 
4709 rajveer 4928 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4929 
    """
4930 
    Parameters:
4931 
     - cancelDateFrom
4932 
     - cancelDateTo
4933 
    """
4934 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4935 
    return self.recv_getCancelledOrders()
4936 
 
4937 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4938 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4939 
    args = getCancelledOrders_args()
4940 
    args.cancelDateFrom = cancelDateFrom
4941 
    args.cancelDateTo = cancelDateTo
4942 
    args.write(self._oprot)
4943 
    self._oprot.writeMessageEnd()
4944 
    self._oprot.trans.flush()
4945 
 
4946 
  def recv_getCancelledOrders(self, ):
4947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4948 
    if mtype == TMessageType.EXCEPTION:
4949 
      x = TApplicationException()
4950 
      x.read(self._iprot)
4951 
      self._iprot.readMessageEnd()
4952 
      raise x
4953 
    result = getCancelledOrders_result()
4954 
    result.read(self._iprot)
4955 
    self._iprot.readMessageEnd()
4956 
    if result.success is not None:
4957 
      return result.success
4958 
    if result.ex is not None:
4959 
      raise result.ex
4960 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4961 
 
4600 varun.gupt 4962 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4963 
    """
4964 
    Parameters:
4965 
     - mapAWBAndAmount
4966 
    """
4967 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4968 
    self.recv_saveBluedartSettlements()
4969 
 
4970 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4971 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4972 
    args = saveBluedartSettlements_args()
4973 
    args.mapAWBAndAmount = mapAWBAndAmount
4974 
    args.write(self._oprot)
4975 
    self._oprot.writeMessageEnd()
4976 
    self._oprot.trans.flush()
4977 
 
4978 
  def recv_saveBluedartSettlements(self, ):
4979 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4980 
    if mtype == TMessageType.EXCEPTION:
4981 
      x = TApplicationException()
4982 
      x.read(self._iprot)
4983 
      self._iprot.readMessageEnd()
4984 
      raise x
4985 
    result = saveBluedartSettlements_result()
4986 
    result.read(self._iprot)
4987 
    self._iprot.readMessageEnd()
4988 
    if result.ex is not None:
4989 
      raise result.ex
4990 
    return
4991 
 
4905 varun.gupt 4992 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4993 
    """
4994 
    Parameters:
4995 
     - settlementDate
4996 
     - paymentGatewayId
4905 varun.gupt 4997 
     - referenceId
4600 varun.gupt 4998 
     - serviceTax
4999 
     - otherCharges
5000 
     - netCollection
5001 
    """
4905 varun.gupt 5002 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5003 
    self.recv_savePaymentSettlements()
5004 
 
4905 varun.gupt 5005 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5006 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5007 
    args = savePaymentSettlements_args()
5008 
    args.settlementDate = settlementDate
5009 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5010 
    args.referenceId = referenceId
4600 varun.gupt 5011 
    args.serviceTax = serviceTax
5012 
    args.otherCharges = otherCharges
5013 
    args.netCollection = netCollection
5014 
    args.write(self._oprot)
5015 
    self._oprot.writeMessageEnd()
5016 
    self._oprot.trans.flush()
5017 
 
5018 
  def recv_savePaymentSettlements(self, ):
5019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5020 
    if mtype == TMessageType.EXCEPTION:
5021 
      x = TApplicationException()
5022 
      x.read(self._iprot)
5023 
      self._iprot.readMessageEnd()
5024 
      raise x
5025 
    result = savePaymentSettlements_result()
5026 
    result.read(self._iprot)
5027 
    self._iprot.readMessageEnd()
5028 
    if result.ex is not None:
5029 
      raise result.ex
5030 
    return
5031 
 
5032 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5033 
    """
5034 
    Parameters:
5035 
     - settlementId
5036 
     - settlementDate
5037 
     - transactionDateFrom
5038 
     - transactionDateTo
5039 
     - amount
5040 
    """
5041 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5042 
    self.recv_saveEBSSettlementSummary()
5043 
 
5044 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5045 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5046 
    args = saveEBSSettlementSummary_args()
5047 
    args.settlementId = settlementId
5048 
    args.settlementDate = settlementDate
5049 
    args.transactionDateFrom = transactionDateFrom
5050 
    args.transactionDateTo = transactionDateTo
5051 
    args.amount = amount
5052 
    args.write(self._oprot)
5053 
    self._oprot.writeMessageEnd()
5054 
    self._oprot.trans.flush()
5055 
 
5056 
  def recv_saveEBSSettlementSummary(self, ):
5057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5058 
    if mtype == TMessageType.EXCEPTION:
5059 
      x = TApplicationException()
5060 
      x.read(self._iprot)
5061 
      self._iprot.readMessageEnd()
5062 
      raise x
5063 
    result = saveEBSSettlementSummary_result()
5064 
    result.read(self._iprot)
5065 
    self._iprot.readMessageEnd()
5066 
    if result.ex is not None:
5067 
      raise result.ex
5068 
    return
5069 
 
5386 phani.kuma 5070 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5071 
    """
5072 
    Parameters:
5189 varun.gupt 5073 
     - referenceId
5074 
     - isRefund
4600 varun.gupt 5075 
    """
5386 phani.kuma 5076 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5077 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5078 
 
5386 phani.kuma 5079 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5080 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5081 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5082 
    args.referenceId = referenceId
5083 
    args.isRefund = isRefund
4600 varun.gupt 5084 
    args.write(self._oprot)
5085 
    self._oprot.writeMessageEnd()
5086 
    self._oprot.trans.flush()
5087 
 
5386 phani.kuma 5088 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5090 
    if mtype == TMessageType.EXCEPTION:
5091 
      x = TApplicationException()
5092 
      x.read(self._iprot)
5093 
      self._iprot.readMessageEnd()
5094 
      raise x
5386 phani.kuma 5095 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5096 
    result.read(self._iprot)
5097 
    self._iprot.readMessageEnd()
5098 
    if result.success is not None:
5099 
      return result.success
5100 
    if result.ex is not None:
5101 
      raise result.ex
5386 phani.kuma 5102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5103 
 
5386 phani.kuma 5104 
  def getSettlementForCod(self, orderId, isRefund):
5105 
    """
5106 
    Parameters:
5107 
     - orderId
5108 
     - isRefund
5109 
    """
5110 
    self.send_getSettlementForCod(orderId, isRefund)
5111 
    return self.recv_getSettlementForCod()
5112 
 
5113 
  def send_getSettlementForCod(self, orderId, isRefund):
5114 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5115 
    args = getSettlementForCod_args()
5116 
    args.orderId = orderId
5117 
    args.isRefund = isRefund
5118 
    args.write(self._oprot)
5119 
    self._oprot.writeMessageEnd()
5120 
    self._oprot.trans.flush()
5121 
 
5122 
  def recv_getSettlementForCod(self, ):
5123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5124 
    if mtype == TMessageType.EXCEPTION:
5125 
      x = TApplicationException()
5126 
      x.read(self._iprot)
5127 
      self._iprot.readMessageEnd()
5128 
      raise x
5129 
    result = getSettlementForCod_result()
5130 
    result.read(self._iprot)
5131 
    self._iprot.readMessageEnd()
5132 
    if result.success is not None:
5133 
      return result.success
5134 
    if result.ex is not None:
5135 
      raise result.ex
5136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5137 
 
4600 varun.gupt 5138 
  def getEBSSettlementSummaries(self, ):
5139 
    self.send_getEBSSettlementSummaries()
5140 
    return self.recv_getEBSSettlementSummaries()
5141 
 
5142 
  def send_getEBSSettlementSummaries(self, ):
5143 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5144 
    args = getEBSSettlementSummaries_args()
5145 
    args.write(self._oprot)
5146 
    self._oprot.writeMessageEnd()
5147 
    self._oprot.trans.flush()
5148 
 
5149 
  def recv_getEBSSettlementSummaries(self, ):
5150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5151 
    if mtype == TMessageType.EXCEPTION:
5152 
      x = TApplicationException()
5153 
      x.read(self._iprot)
5154 
      self._iprot.readMessageEnd()
5155 
      raise x
5156 
    result = getEBSSettlementSummaries_result()
5157 
    result.read(self._iprot)
5158 
    self._iprot.readMessageEnd()
5159 
    if result.success is not None:
5160 
      return result.success
5161 
    if result.ex is not None:
5162 
      raise result.ex
5163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5164 
 
5165 
  def markEBSSettlementUploaded(self, settlementId):
5166 
    """
5167 
    Parameters:
5168 
     - settlementId
5169 
    """
5170 
    self.send_markEBSSettlementUploaded(settlementId)
5171 
    self.recv_markEBSSettlementUploaded()
5172 
 
5173 
  def send_markEBSSettlementUploaded(self, settlementId):
5174 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5175 
    args = markEBSSettlementUploaded_args()
5176 
    args.settlementId = settlementId
5177 
    args.write(self._oprot)
5178 
    self._oprot.writeMessageEnd()
5179 
    self._oprot.trans.flush()
5180 
 
5181 
  def recv_markEBSSettlementUploaded(self, ):
5182 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5183 
    if mtype == TMessageType.EXCEPTION:
5184 
      x = TApplicationException()
5185 
      x.read(self._iprot)
5186 
      self._iprot.readMessageEnd()
5187 
      raise x
5188 
    result = markEBSSettlementUploaded_result()
5189 
    result.read(self._iprot)
5190 
    self._iprot.readMessageEnd()
5191 
    if result.ex is not None:
5192 
      raise result.ex
5193 
    return
5194 
 
5195 
  def getEBSSettlementDate(self, settlementId):
5196 
    """
5197 
    Parameters:
5198 
     - settlementId
5199 
    """
5200 
    self.send_getEBSSettlementDate(settlementId)
5201 
    return self.recv_getEBSSettlementDate()
5202 
 
5203 
  def send_getEBSSettlementDate(self, settlementId):
5204 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5205 
    args = getEBSSettlementDate_args()
5206 
    args.settlementId = settlementId
5207 
    args.write(self._oprot)
5208 
    self._oprot.writeMessageEnd()
5209 
    self._oprot.trans.flush()
5210 
 
5211 
  def recv_getEBSSettlementDate(self, ):
5212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5213 
    if mtype == TMessageType.EXCEPTION:
5214 
      x = TApplicationException()
5215 
      x.read(self._iprot)
5216 
      self._iprot.readMessageEnd()
5217 
      raise x
5218 
    result = getEBSSettlementDate_result()
5219 
    result.read(self._iprot)
5220 
    self._iprot.readMessageEnd()
5221 
    if result.success is not None:
5222 
      return result.success
5223 
    if result.ex is not None:
5224 
      raise result.ex
5225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5226 
 
4715 varun.gupt 5227 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5228 
    """
5229 
    Parameters:
5230 
     - settlementDateFrom
5231 
     - settlementDateTo
5232 
     - isRefund
5233 
    """
5234 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5235 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5236 
 
4715 varun.gupt 5237 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5238 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5239 
    args = getSettlementsByDate_args()
5240 
    args.settlementDateFrom = settlementDateFrom
5241 
    args.settlementDateTo = settlementDateTo
5242 
    args.isRefund = isRefund
5243 
    args.write(self._oprot)
5244 
    self._oprot.writeMessageEnd()
5245 
    self._oprot.trans.flush()
5246 
 
5247 
  def recv_getSettlementsByDate(self, ):
5248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5249 
    if mtype == TMessageType.EXCEPTION:
5250 
      x = TApplicationException()
5251 
      x.read(self._iprot)
5252 
      self._iprot.readMessageEnd()
5253 
      raise x
5254 
    result = getSettlementsByDate_result()
5255 
    result.read(self._iprot)
5256 
    self._iprot.readMessageEnd()
5257 
    if result.success is not None:
5258 
      return result.success
5259 
    if result.ex is not None:
5260 
      raise result.ex
5261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5262 
 
5263 
  def getReshippedOrderIds(self, orderIds):
5264 
    """
5265 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5266 
 
5267 
    Parameters:
5268 
     - orderIds
5269 
    """
5270 
    self.send_getReshippedOrderIds(orderIds)
5271 
    return self.recv_getReshippedOrderIds()
5272 
 
5273 
  def send_getReshippedOrderIds(self, orderIds):
5274 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5275 
    args = getReshippedOrderIds_args()
5276 
    args.orderIds = orderIds
5277 
    args.write(self._oprot)
5278 
    self._oprot.writeMessageEnd()
5279 
    self._oprot.trans.flush()
5280 
 
5281 
  def recv_getReshippedOrderIds(self, ):
5282 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5283 
    if mtype == TMessageType.EXCEPTION:
5284 
      x = TApplicationException()
5285 
      x.read(self._iprot)
5286 
      self._iprot.readMessageEnd()
5287 
      raise x
5288 
    result = getReshippedOrderIds_result()
5289 
    result.read(self._iprot)
5290 
    self._iprot.readMessageEnd()
5291 
    if result.success is not None:
5292 
      return result.success
5293 
    if result.ex is not None:
5294 
      raise result.ex
5295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5296 
 
5481 phani.kuma 5297 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5298 
    """
5299 
    Parameters:
5300 
     - vendorId
5481 phani.kuma 5301 
     - onlyVendorNotPaid
5302 
     - billingDateFrom
5303 
     - billingDateTo
4875 varun.gupt 5304 
    """
5481 phani.kuma 5305 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5306 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5307 
 
5481 phani.kuma 5308 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5309 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5310 
    args = getBilledOrders_args()
4875 varun.gupt 5311 
    args.vendorId = vendorId
5481 phani.kuma 5312 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5313 
    args.billingDateFrom = billingDateFrom
5314 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5315 
    args.write(self._oprot)
5316 
    self._oprot.writeMessageEnd()
5317 
    self._oprot.trans.flush()
5318 
 
5481 phani.kuma 5319 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5321 
    if mtype == TMessageType.EXCEPTION:
5322 
      x = TApplicationException()
5323 
      x.read(self._iprot)
5324 
      self._iprot.readMessageEnd()
5325 
      raise x
5481 phani.kuma 5326 
    result = getBilledOrders_result()
4875 varun.gupt 5327 
    result.read(self._iprot)
5328 
    self._iprot.readMessageEnd()
5329 
    if result.success is not None:
5330 
      return result.success
5331 
    if result.ex is not None:
5332 
      raise result.ex
5481 phani.kuma 5333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5334 
 
5031 varun.gupt 5335 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5336 
    """
5337 
    Parameters:
5338 
     - startDate
5339 
     - endDate
5340 
    """
5341 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5342 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5343 
 
5031 varun.gupt 5344 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5345 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5346 
    args = getStatusDistributionOfOrders_args()
5347 
    args.startDate = startDate
5348 
    args.endDate = endDate
5349 
    args.write(self._oprot)
5350 
    self._oprot.writeMessageEnd()
5351 
    self._oprot.trans.flush()
5352 
 
5353 
  def recv_getStatusDistributionOfOrders(self, ):
5354 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5355 
    if mtype == TMessageType.EXCEPTION:
5356 
      x = TApplicationException()
5357 
      x.read(self._iprot)
5358 
      self._iprot.readMessageEnd()
5359 
      raise x
5360 
    result = getStatusDistributionOfOrders_result()
5361 
    result.read(self._iprot)
5362 
    self._iprot.readMessageEnd()
5363 
    if result.success is not None:
5364 
      return result.success
5365 
    if result.ex is not None:
5366 
      raise result.ex
5367 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5368 
 
5067 varun.gupt 5369 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5370 
    """
5371 
    Parameters:
5372 
     - status
5373 
     - startDatetime
5374 
     - endDatetime
5375 
    """
5376 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5377 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5378 
 
5067 varun.gupt 5379 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5380 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5381 
    args = getOrderIdsForStatus_args()
5382 
    args.status = status
5383 
    args.startDatetime = startDatetime
5384 
    args.endDatetime = endDatetime
5385 
    args.write(self._oprot)
5386 
    self._oprot.writeMessageEnd()
5387 
    self._oprot.trans.flush()
5388 
 
5389 
  def recv_getOrderIdsForStatus(self, ):
5390 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5391 
    if mtype == TMessageType.EXCEPTION:
5392 
      x = TApplicationException()
5393 
      x.read(self._iprot)
5394 
      self._iprot.readMessageEnd()
5395 
      raise x
5396 
    result = getOrderIdsForStatus_result()
5397 
    result.read(self._iprot)
5398 
    self._iprot.readMessageEnd()
5399 
    if result.success is not None:
5400 
      return result.success
5401 
    if result.ex is not None:
5402 
      raise result.ex
5403 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5404 
 
5348 anupam.sin 5405 
  def updateCODAgent(self, agent, orderId):
5406 
    """
5407 
    Updates the agent who handled the COD verification call
5408 
 
5409 
    Parameters:
5410 
     - agent
5411 
     - orderId
5412 
    """
5413 
    self.send_updateCODAgent(agent, orderId)
5414 
    self.recv_updateCODAgent()
5415 
 
5416 
  def send_updateCODAgent(self, agent, orderId):
5417 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5418 
    args = updateCODAgent_args()
5419 
    args.agent = agent
5420 
    args.orderId = orderId
5421 
    args.write(self._oprot)
5422 
    self._oprot.writeMessageEnd()
5423 
    self._oprot.trans.flush()
5424 
 
5425 
  def recv_updateCODAgent(self, ):
5426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5427 
    if mtype == TMessageType.EXCEPTION:
5428 
      x = TApplicationException()
5429 
      x.read(self._iprot)
5430 
      self._iprot.readMessageEnd()
5431 
      raise x
5432 
    result = updateCODAgent_result()
5433 
    result.read(self._iprot)
5434 
    self._iprot.readMessageEnd()
5435 
    if result.ex is not None:
5436 
      raise result.ex
5437 
    return
5438 
 
5099 varun.gupt 5439 
  def updateOrderAsPaidToVendor(self, orderId):
5440 
    """
5441 
    Parameters:
5442 
     - orderId
5443 
    """
5444 
    self.send_updateOrderAsPaidToVendor(orderId)
5445 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5446 
 
5099 varun.gupt 5447 
  def send_updateOrderAsPaidToVendor(self, orderId):
5448 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5449 
    args = updateOrderAsPaidToVendor_args()
5450 
    args.orderId = orderId
5451 
    args.write(self._oprot)
5452 
    self._oprot.writeMessageEnd()
5453 
    self._oprot.trans.flush()
5454 
 
5455 
  def recv_updateOrderAsPaidToVendor(self, ):
5456 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5457 
    if mtype == TMessageType.EXCEPTION:
5458 
      x = TApplicationException()
5459 
      x.read(self._iprot)
5460 
      self._iprot.readMessageEnd()
5461 
      raise x
5462 
    result = updateOrderAsPaidToVendor_result()
5463 
    result.read(self._iprot)
5464 
    self._iprot.readMessageEnd()
5465 
    if result.ex is not None:
5466 
      raise result.ex
5467 
    return
5468 
 
5386 phani.kuma 5469 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5470 
    """
5471 
    Parameters:
5472 
     - orderId
5473 
    """
5474 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5475 
    self.recv_updateOrderOnlyAsPaidToVendor()
5476 
 
5477 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5478 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5479 
    args = updateOrderOnlyAsPaidToVendor_args()
5480 
    args.orderId = orderId
5481 
    args.write(self._oprot)
5482 
    self._oprot.writeMessageEnd()
5483 
    self._oprot.trans.flush()
5484 
 
5485 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5487 
    if mtype == TMessageType.EXCEPTION:
5488 
      x = TApplicationException()
5489 
      x.read(self._iprot)
5490 
      self._iprot.readMessageEnd()
5491 
      raise x
5492 
    result = updateOrderOnlyAsPaidToVendor_result()
5493 
    result.read(self._iprot)
5494 
    self._iprot.readMessageEnd()
5495 
    if result.ex is not None:
5496 
      raise result.ex
5497 
    return
5498 
 
5208 varun.gupt 5499 
  def getRefundedOrdersMarkedPaid(self, ):
5500 
    self.send_getRefundedOrdersMarkedPaid()
5501 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5502 
 
5208 varun.gupt 5503 
  def send_getRefundedOrdersMarkedPaid(self, ):
5504 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5505 
    args = getRefundedOrdersMarkedPaid_args()
5506 
    args.write(self._oprot)
5507 
    self._oprot.writeMessageEnd()
5508 
    self._oprot.trans.flush()
5509 
 
5510 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5512 
    if mtype == TMessageType.EXCEPTION:
5513 
      x = TApplicationException()
5514 
      x.read(self._iprot)
5515 
      self._iprot.readMessageEnd()
5516 
      raise x
5517 
    result = getRefundedOrdersMarkedPaid_result()
5518 
    result.read(self._iprot)
5519 
    self._iprot.readMessageEnd()
5520 
    if result.success is not None:
5521 
      return result.success
5522 
    if result.ex is not None:
5523 
      raise result.ex
5524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5525 
 
5447 anupam.sin 5526 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5527 
    """
5528 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5529 
 
5447 anupam.sin 5530 
 
5531 
    Parameters:
5532 
     - minOrderId
5533 
     - maxOrderId
5534 
    """
5535 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5536 
    return self.recv_getAllVerificationAgents()
5537 
 
5538 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5539 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5540 
    args = getAllVerificationAgents_args()
5541 
    args.minOrderId = minOrderId
5542 
    args.maxOrderId = maxOrderId
5543 
    args.write(self._oprot)
5544 
    self._oprot.writeMessageEnd()
5545 
    self._oprot.trans.flush()
5546 
 
5547 
  def recv_getAllVerificationAgents(self, ):
5548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5549 
    if mtype == TMessageType.EXCEPTION:
5550 
      x = TApplicationException()
5551 
      x.read(self._iprot)
5552 
      self._iprot.readMessageEnd()
5553 
      raise x
5554 
    result = getAllVerificationAgents_result()
5555 
    result.read(self._iprot)
5556 
    self._iprot.readMessageEnd()
5557 
    if result.success is not None:
5558 
      return result.success
5559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5560 
 
5527 anupam.sin 5561 
  def getAllAttributesForOrderId(self, orderId):
5562 
    """
5563 
    gets all attributes for a given orderId
5447 anupam.sin 5564 
 
5527 anupam.sin 5565 
    Parameters:
5566 
     - orderId
5567 
    """
5568 
    self.send_getAllAttributesForOrderId(orderId)
5569 
    return self.recv_getAllAttributesForOrderId()
5570 
 
5571 
  def send_getAllAttributesForOrderId(self, orderId):
5572 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5573 
    args = getAllAttributesForOrderId_args()
5574 
    args.orderId = orderId
5575 
    args.write(self._oprot)
5576 
    self._oprot.writeMessageEnd()
5577 
    self._oprot.trans.flush()
5578 
 
5579 
  def recv_getAllAttributesForOrderId(self, ):
5580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5581 
    if mtype == TMessageType.EXCEPTION:
5582 
      x = TApplicationException()
5583 
      x.read(self._iprot)
5584 
      self._iprot.readMessageEnd()
5585 
      raise x
5586 
    result = getAllAttributesForOrderId_result()
5587 
    result.read(self._iprot)
5588 
    self._iprot.readMessageEnd()
5589 
    if result.success is not None:
5590 
      return result.success
5591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5592 
 
5676 rajveer 5593 
  def setOrderAttributes(self, orderId, attributes):
5594 
    """
5595 
    sets attributes for an order
5596 
 
5597 
    Parameters:
5598 
     - orderId
5599 
     - attributes
5600 
    """
5601 
    self.send_setOrderAttributes(orderId, attributes)
5602 
    self.recv_setOrderAttributes()
5603 
 
5604 
  def send_setOrderAttributes(self, orderId, attributes):
5605 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5606 
    args = setOrderAttributes_args()
5607 
    args.orderId = orderId
5608 
    args.attributes = attributes
5609 
    args.write(self._oprot)
5610 
    self._oprot.writeMessageEnd()
5611 
    self._oprot.trans.flush()
5612 
 
5613 
  def recv_setOrderAttributes(self, ):
5614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5615 
    if mtype == TMessageType.EXCEPTION:
5616 
      x = TApplicationException()
5617 
      x.read(self._iprot)
5618 
      self._iprot.readMessageEnd()
5619 
      raise x
5620 
    result = setOrderAttributes_result()
5621 
    result.read(self._iprot)
5622 
    self._iprot.readMessageEnd()
5623 
    return
5624 
 
5527 anupam.sin 5625 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5626 
    """
5627 
    sets attributes for all orders in a transaction
5628 
 
5629 
    Parameters:
5630 
     - transactionId
5631 
     - attribute
5632 
    """
5633 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5634 
    self.recv_setOrderAttributeForTransaction()
5635 
 
5636 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5637 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5638 
    args = setOrderAttributeForTransaction_args()
5639 
    args.transactionId = transactionId
5640 
    args.attribute = attribute
5641 
    args.write(self._oprot)
5642 
    self._oprot.writeMessageEnd()
5643 
    self._oprot.trans.flush()
5644 
 
5645 
  def recv_setOrderAttributeForTransaction(self, ):
5646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5647 
    if mtype == TMessageType.EXCEPTION:
5648 
      x = TApplicationException()
5649 
      x.read(self._iprot)
5650 
      self._iprot.readMessageEnd()
5651 
      raise x
5652 
    result = setOrderAttributeForTransaction_result()
5653 
    result.read(self._iprot)
5654 
    self._iprot.readMessageEnd()
5655 
    return
5656 
 
5553 rajveer 5657 
  def getReceivePendingOrders(self, storeId):
5658 
    """
5659 
    Parameters:
5660 
     - storeId
5661 
    """
5662 
    self.send_getReceivePendingOrders(storeId)
5663 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5664 
 
5553 rajveer 5665 
  def send_getReceivePendingOrders(self, storeId):
5666 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5667 
    args = getReceivePendingOrders_args()
5668 
    args.storeId = storeId
5669 
    args.write(self._oprot)
5670 
    self._oprot.writeMessageEnd()
5671 
    self._oprot.trans.flush()
5672 
 
5673 
  def recv_getReceivePendingOrders(self, ):
5674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5675 
    if mtype == TMessageType.EXCEPTION:
5676 
      x = TApplicationException()
5677 
      x.read(self._iprot)
5678 
      self._iprot.readMessageEnd()
5679 
      raise x
5680 
    result = getReceivePendingOrders_result()
5681 
    result.read(self._iprot)
5682 
    self._iprot.readMessageEnd()
5683 
    if result.success is not None:
5684 
      return result.success
5685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5686 
 
5687 
  def getReceivedAtStoreOrders(self, storeId):
5688 
    """
5689 
    Parameters:
5690 
     - storeId
5691 
    """
5692 
    self.send_getReceivedAtStoreOrders(storeId)
5693 
    return self.recv_getReceivedAtStoreOrders()
5694 
 
5695 
  def send_getReceivedAtStoreOrders(self, storeId):
5696 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5697 
    args = getReceivedAtStoreOrders_args()
5698 
    args.storeId = storeId
5699 
    args.write(self._oprot)
5700 
    self._oprot.writeMessageEnd()
5701 
    self._oprot.trans.flush()
5702 
 
5703 
  def recv_getReceivedAtStoreOrders(self, ):
5704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5705 
    if mtype == TMessageType.EXCEPTION:
5706 
      x = TApplicationException()
5707 
      x.read(self._iprot)
5708 
      self._iprot.readMessageEnd()
5709 
      raise x
5710 
    result = getReceivedAtStoreOrders_result()
5711 
    result.read(self._iprot)
5712 
    self._iprot.readMessageEnd()
5713 
    if result.success is not None:
5714 
      return result.success
5715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5716 
 
5713 rajveer 5717 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5718 
    """
5719 
    Parameters:
5720 
     - storeId
5721 
     - fromDate
5722 
     - toDate
5723 
     - onlyCod
5724 
    """
5725 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5726 
    return self.recv_getOrdersCollectionAtStore()
5727 
 
5728 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5729 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5730 
    args = getOrdersCollectionAtStore_args()
5731 
    args.storeId = storeId
5732 
    args.fromDate = fromDate
5733 
    args.toDate = toDate
5734 
    args.onlyCod = onlyCod
5735 
    args.write(self._oprot)
5736 
    self._oprot.writeMessageEnd()
5737 
    self._oprot.trans.flush()
5738 
 
5739 
  def recv_getOrdersCollectionAtStore(self, ):
5740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5741 
    if mtype == TMessageType.EXCEPTION:
5742 
      x = TApplicationException()
5743 
      x.read(self._iprot)
5744 
      self._iprot.readMessageEnd()
5745 
      raise x
5746 
    result = getOrdersCollectionAtStore_result()
5747 
    result.read(self._iprot)
5748 
    self._iprot.readMessageEnd()
5749 
    if result.success is not None:
5750 
      return result.success
5751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5752 
 
5833 rajveer 5753 
  def getOrderAttributeValue(self, orderId, attributeName):
5754 
    """
5755 
    Parameters:
5756 
     - orderId
5757 
     - attributeName
5758 
    """
5759 
    self.send_getOrderAttributeValue(orderId, attributeName)
5760 
    return self.recv_getOrderAttributeValue()
5761 
 
5762 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5763 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5764 
    args = getOrderAttributeValue_args()
5765 
    args.orderId = orderId
5766 
    args.attributeName = attributeName
5767 
    args.write(self._oprot)
5768 
    self._oprot.writeMessageEnd()
5769 
    self._oprot.trans.flush()
5770 
 
5771 
  def recv_getOrderAttributeValue(self, ):
5772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5773 
    if mtype == TMessageType.EXCEPTION:
5774 
      x = TApplicationException()
5775 
      x.read(self._iprot)
5776 
      self._iprot.readMessageEnd()
5777 
      raise x
5778 
    result = getOrderAttributeValue_result()
5779 
    result.read(self._iprot)
5780 
    self._iprot.readMessageEnd()
5781 
    if result.success is not None:
5782 
      return result.success
5783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5784 
 
6019 rajveer 5785 
  def changeJacketNumber(self, orderId, jacketNumber):
5786 
    """
5787 
    Parameters:
5788 
     - orderId
5789 
     - jacketNumber
5790 
    """
5791 
    self.send_changeJacketNumber(orderId, jacketNumber)
5792 
    return self.recv_changeJacketNumber()
5793 
 
5794 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5795 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5796 
    args = changeJacketNumber_args()
5797 
    args.orderId = orderId
5798 
    args.jacketNumber = jacketNumber
5799 
    args.write(self._oprot)
5800 
    self._oprot.writeMessageEnd()
5801 
    self._oprot.trans.flush()
5802 
 
5803 
  def recv_changeJacketNumber(self, ):
5804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5805 
    if mtype == TMessageType.EXCEPTION:
5806 
      x = TApplicationException()
5807 
      x.read(self._iprot)
5808 
      self._iprot.readMessageEnd()
5809 
      raise x
5810 
    result = changeJacketNumber_result()
5811 
    result.read(self._iprot)
5812 
    self._iprot.readMessageEnd()
5813 
    if result.success is not None:
5814 
      return result.success
5815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5816 
 
5817 
  def markOrderAsRtoInTransit(self, orderId):
5818 
    """
5819 
    Parameters:
5820 
     - orderId
5821 
    """
5822 
    self.send_markOrderAsRtoInTransit(orderId)
5823 
    return self.recv_markOrderAsRtoInTransit()
5824 
 
5825 
  def send_markOrderAsRtoInTransit(self, orderId):
5826 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5827 
    args = markOrderAsRtoInTransit_args()
5828 
    args.orderId = orderId
5829 
    args.write(self._oprot)
5830 
    self._oprot.writeMessageEnd()
5831 
    self._oprot.trans.flush()
5832 
 
5833 
  def recv_markOrderAsRtoInTransit(self, ):
5834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5835 
    if mtype == TMessageType.EXCEPTION:
5836 
      x = TApplicationException()
5837 
      x.read(self._iprot)
5838 
      self._iprot.readMessageEnd()
5839 
      raise x
5840 
    result = markOrderAsRtoInTransit_result()
5841 
    result.read(self._iprot)
5842 
    self._iprot.readMessageEnd()
5843 
    if result.success is not None:
5844 
      return result.success
5845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5846 
 
5593 mandeep.dh 5847 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5848 
    """
5849 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5850 
    invoked while scanning IN of items.
5553 rajveer 5851 
 
5593 mandeep.dh 5852 
    Parameters:
5853 
     - itemId
5854 
     - quantity
5855 
     - fulfilmentWarehouseId
5856 
     - billingWarehouseId
5857 
    """
5858 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5859 
    self.recv_acceptOrderForItem()
5860 
 
5861 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5862 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5863 
    args = acceptOrderForItem_args()
5864 
    args.itemId = itemId
5865 
    args.quantity = quantity
5866 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5867 
    args.billingWarehouseId = billingWarehouseId
5868 
    args.write(self._oprot)
5869 
    self._oprot.writeMessageEnd()
5870 
    self._oprot.trans.flush()
5871 
 
5872 
  def recv_acceptOrderForItem(self, ):
5873 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5874 
    if mtype == TMessageType.EXCEPTION:
5875 
      x = TApplicationException()
5876 
      x.read(self._iprot)
5877 
      self._iprot.readMessageEnd()
5878 
      raise x
5879 
    result = acceptOrderForItem_result()
5880 
    result.read(self._iprot)
5881 
    self._iprot.readMessageEnd()
5882 
    return
5883 
 
6000 mandeep.dh 5884 
  def createRechargeOrder(self, rechargeOrder):
5885 
    """
5886 
    Parameters:
5887 
     - rechargeOrder
5888 
    """
5889 
    self.send_createRechargeOrder(rechargeOrder)
5890 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5891 
 
6000 mandeep.dh 5892 
  def send_createRechargeOrder(self, rechargeOrder):
5893 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5894 
    args = createRechargeOrder_args()
5895 
    args.rechargeOrder = rechargeOrder
5896 
    args.write(self._oprot)
5897 
    self._oprot.writeMessageEnd()
5898 
    self._oprot.trans.flush()
5899 
 
5900 
  def recv_createRechargeOrder(self, ):
5901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5902 
    if mtype == TMessageType.EXCEPTION:
5903 
      x = TApplicationException()
5904 
      x.read(self._iprot)
5905 
      self._iprot.readMessageEnd()
5906 
      raise x
5907 
    result = createRechargeOrder_result()
5908 
    result.read(self._iprot)
5909 
    self._iprot.readMessageEnd()
5910 
    if result.success is not None:
5911 
      return result.success
5912 
    if result.ex is not None:
5913 
      raise result.ex
5914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5915 
 
6031 rajveer 5916 
  def getRechargeOrder(self, rechargeRrderId):
5917 
    """
5918 
    Parameters:
5919 
     - rechargeRrderId
5920 
    """
5921 
    self.send_getRechargeOrder(rechargeRrderId)
5922 
    return self.recv_getRechargeOrder()
5923 
 
5924 
  def send_getRechargeOrder(self, rechargeRrderId):
5925 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5926 
    args = getRechargeOrder_args()
5927 
    args.rechargeRrderId = rechargeRrderId
5928 
    args.write(self._oprot)
5929 
    self._oprot.writeMessageEnd()
5930 
    self._oprot.trans.flush()
5931 
 
5932 
  def recv_getRechargeOrder(self, ):
5933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5934 
    if mtype == TMessageType.EXCEPTION:
5935 
      x = TApplicationException()
5936 
      x.read(self._iprot)
5937 
      self._iprot.readMessageEnd()
5938 
      raise x
5939 
    result = getRechargeOrder_result()
5940 
    result.read(self._iprot)
5941 
    self._iprot.readMessageEnd()
5942 
    if result.success is not None:
5943 
      return result.success
5944 
    if result.ex is not None:
5945 
      raise result.ex
5946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5947 
 
5948 
  def getRechargeOrders(self, userId):
5949 
    """
5950 
    Parameters:
5951 
     - userId
5952 
    """
5953 
    self.send_getRechargeOrders(userId)
5954 
    return self.recv_getRechargeOrders()
5955 
 
5956 
  def send_getRechargeOrders(self, userId):
5957 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5958 
    args = getRechargeOrders_args()
5959 
    args.userId = userId
5960 
    args.write(self._oprot)
5961 
    self._oprot.writeMessageEnd()
5962 
    self._oprot.trans.flush()
5963 
 
5964 
  def recv_getRechargeOrders(self, ):
5965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5966 
    if mtype == TMessageType.EXCEPTION:
5967 
      x = TApplicationException()
5968 
      x.read(self._iprot)
5969 
      self._iprot.readMessageEnd()
5970 
      raise x
5971 
    result = getRechargeOrders_result()
5972 
    result.read(self._iprot)
5973 
    self._iprot.readMessageEnd()
5974 
    if result.success is not None:
5975 
      return result.success
5976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5977 
 
6000 mandeep.dh 5978 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5979 
    """
5980 
    Parameters:
5981 
     - rechargeOrderId
5982 
     - rechargeOrderStatus
5983 
    """
5984 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5985 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5986 
 
5987 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5988 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5989 
    args = updateRechargeOrderStatus_args()
5990 
    args.rechargeOrderId = rechargeOrderId
5991 
    args.rechargeOrderStatus = rechargeOrderStatus
5992 
    args.write(self._oprot)
5993 
    self._oprot.writeMessageEnd()
5994 
    self._oprot.trans.flush()
5995 
 
5996 
  def recv_updateRechargeOrderStatus(self, ):
5997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5998 
    if mtype == TMessageType.EXCEPTION:
5999 
      x = TApplicationException()
6000 
      x.read(self._iprot)
6001 
      self._iprot.readMessageEnd()
6002 
      raise x
6003 
    result = updateRechargeOrderStatus_result()
6004 
    result.read(self._iprot)
6005 
    self._iprot.readMessageEnd()
6031 rajveer 6006 
    if result.success is not None:
6007 
      return result.success
6000 mandeep.dh 6008 
    if result.ex is not None:
6009 
      raise result.ex
6031 rajveer 6010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6011 
 
6031 rajveer 6012 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6013 
    """
6014 
    Parameters:
6031 rajveer 6015 
     - rechargeOrderId
6000 mandeep.dh 6016 
    """
6031 rajveer 6017 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6018 
    return self.recv_activateRechargeTxn()
6019 
 
6031 rajveer 6020 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6021 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6022 
    args = activateRechargeTxn_args()
6031 rajveer 6023 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6024 
    args.write(self._oprot)
6025 
    self._oprot.writeMessageEnd()
6026 
    self._oprot.trans.flush()
6027 
 
6028 
  def recv_activateRechargeTxn(self, ):
6029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6030 
    if mtype == TMessageType.EXCEPTION:
6031 
      x = TApplicationException()
6032 
      x.read(self._iprot)
6033 
      self._iprot.readMessageEnd()
6034 
      raise x
6035 
    result = activateRechargeTxn_result()
6036 
    result.read(self._iprot)
6037 
    self._iprot.readMessageEnd()
6038 
    if result.success is not None:
6039 
      return result.success
6040 
    if result.ex is not None:
6041 
      raise result.ex
6042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6043 
 
6031 rajveer 6044 
  def getUserWallet(self, userId):
6000 mandeep.dh 6045 
    """
6046 
    Parameters:
6031 rajveer 6047 
     - userId
6000 mandeep.dh 6048 
    """
6031 rajveer 6049 
    self.send_getUserWallet(userId)
6050 
    return self.recv_getUserWallet()
6000 mandeep.dh 6051 
 
6031 rajveer 6052 
  def send_getUserWallet(self, userId):
6053 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6054 
    args = getUserWallet_args()
6055 
    args.userId = userId
6000 mandeep.dh 6056 
    args.write(self._oprot)
6057 
    self._oprot.writeMessageEnd()
6058 
    self._oprot.trans.flush()
6059 
 
6031 rajveer 6060 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6062 
    if mtype == TMessageType.EXCEPTION:
6063 
      x = TApplicationException()
6064 
      x.read(self._iprot)
6065 
      self._iprot.readMessageEnd()
6066 
      raise x
6031 rajveer 6067 
    result = getUserWallet_result()
6000 mandeep.dh 6068 
    result.read(self._iprot)
6069 
    self._iprot.readMessageEnd()
6070 
    if result.success is not None:
6071 
      return result.success
6031 rajveer 6072 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6073 
 
6031 rajveer 6074 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6075 
    """
6076 
    Parameters:
6031 rajveer 6077 
     - userId
6000 mandeep.dh 6078 
    """
6031 rajveer 6079 
    self.send_getUserWalletHistory(userId)
6080 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6081 
 
6031 rajveer 6082 
  def send_getUserWalletHistory(self, userId):
6083 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6084 
    args = getUserWalletHistory_args()
6085 
    args.userId = userId
6000 mandeep.dh 6086 
    args.write(self._oprot)
6087 
    self._oprot.writeMessageEnd()
6088 
    self._oprot.trans.flush()
6089 
 
6031 rajveer 6090 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6092 
    if mtype == TMessageType.EXCEPTION:
6093 
      x = TApplicationException()
6094 
      x.read(self._iprot)
6095 
      self._iprot.readMessageEnd()
6096 
      raise x
6031 rajveer 6097 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6098 
    result.read(self._iprot)
6099 
    self._iprot.readMessageEnd()
6100 
    if result.success is not None:
6101 
      return result.success
6031 rajveer 6102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6103 
 
6050 anupam.sin 6104 
  def getRechargeOrdersForTransaction(self, txnId):
6105 
    """
6106 
    Returns a recharge order for a given transactionId
6107 
 
6108 
    Parameters:
6109 
     - txnId
6110 
    """
6111 
    self.send_getRechargeOrdersForTransaction(txnId)
6112 
    return self.recv_getRechargeOrdersForTransaction()
6113 
 
6114 
  def send_getRechargeOrdersForTransaction(self, txnId):
6115 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6116 
    args = getRechargeOrdersForTransaction_args()
6117 
    args.txnId = txnId
6118 
    args.write(self._oprot)
6119 
    self._oprot.writeMessageEnd()
6120 
    self._oprot.trans.flush()
6121 
 
6122 
  def recv_getRechargeOrdersForTransaction(self, ):
6123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6124 
    if mtype == TMessageType.EXCEPTION:
6125 
      x = TApplicationException()
6126 
      x.read(self._iprot)
6127 
      self._iprot.readMessageEnd()
6128 
      raise x
6129 
    result = getRechargeOrdersForTransaction_result()
6130 
    result.read(self._iprot)
6131 
    self._iprot.readMessageEnd()
6132 
    if result.success is not None:
6133 
      return result.success
6134 
    if result.ex is not None:
6135 
      raise result.ex
6136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6137 
 
6206 rajveer 6138 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6139 
    """
6140 
    Parameters:
6141 
     - rechargeType
6206 rajveer 6142 
     - onlyActive
6048 rajveer 6143 
    """
6206 rajveer 6144 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6145 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6146 
 
6206 rajveer 6147 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6148 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6149 
    args = getServiceProviders_args()
6150 
    args.rechargeType = rechargeType
6206 rajveer 6151 
    args.onlyActive = onlyActive
6048 rajveer 6152 
    args.write(self._oprot)
6153 
    self._oprot.writeMessageEnd()
6154 
    self._oprot.trans.flush()
6155 
 
6156 
  def recv_getServiceProviders(self, ):
6157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6158 
    if mtype == TMessageType.EXCEPTION:
6159 
      x = TApplicationException()
6160 
      x.read(self._iprot)
6161 
      self._iprot.readMessageEnd()
6162 
      raise x
6163 
    result = getServiceProviders_result()
6164 
    result.read(self._iprot)
6165 
    self._iprot.readMessageEnd()
6166 
    if result.success is not None:
6167 
      return result.success
6168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6169 
 
6049 rajveer 6170 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6171 
    """
6172 
    Parameters:
6049 rajveer 6173 
     - rechargeType
6048 rajveer 6174 
     - deviceNumber
6175 
    """
6049 rajveer 6176 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6177 
    return self.recv_getServiceProviderForDevice()
6178 
 
6049 rajveer 6179 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6180 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6181 
    args = getServiceProviderForDevice_args()
6049 rajveer 6182 
    args.rechargeType = rechargeType
6048 rajveer 6183 
    args.deviceNumber = deviceNumber
6184 
    args.write(self._oprot)
6185 
    self._oprot.writeMessageEnd()
6186 
    self._oprot.trans.flush()
6187 
 
6188 
  def recv_getServiceProviderForDevice(self, ):
6189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6190 
    if mtype == TMessageType.EXCEPTION:
6191 
      x = TApplicationException()
6192 
      x.read(self._iprot)
6193 
      self._iprot.readMessageEnd()
6194 
      raise x
6195 
    result = getServiceProviderForDevice_result()
6196 
    result.read(self._iprot)
6197 
    self._iprot.readMessageEnd()
6198 
    if result.success is not None:
6199 
      return result.success
6200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6201 
 
6336 anupam.sin 6202 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6203 
    """
6204 
    Parameters:
6205 
     - rechargeType
6206 
     - deviceNumber
6307 anupam.sin 6207 
     - userSelectedProviderId
6269 rajveer 6208 
    """
6336 anupam.sin 6209 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId)
6269 rajveer 6210 
    return self.recv_validateRecharge()
6211 
 
6336 anupam.sin 6212 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6213 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6214 
    args = validateRecharge_args()
6215 
    args.rechargeType = rechargeType
6216 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6217 
    args.userSelectedProviderId = userSelectedProviderId
6269 rajveer 6218 
    args.write(self._oprot)
6219 
    self._oprot.writeMessageEnd()
6220 
    self._oprot.trans.flush()
6221 
 
6222 
  def recv_validateRecharge(self, ):
6223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6224 
    if mtype == TMessageType.EXCEPTION:
6225 
      x = TApplicationException()
6226 
      x.read(self._iprot)
6227 
      self._iprot.readMessageEnd()
6228 
      raise x
6229 
    result = validateRecharge_result()
6230 
    result.read(self._iprot)
6231 
    self._iprot.readMessageEnd()
6232 
    if result.success is not None:
6233 
      return result.success
6234 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6235 
 
6094 rajveer 6236 
  def getRechargeOrdersForDevice(self, deviceNumber):
6237 
    """
6238 
    Parameters:
6239 
     - deviceNumber
6240 
    """
6241 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6242 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6243 
 
6094 rajveer 6244 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6245 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6246 
    args = getRechargeOrdersForDevice_args()
6247 
    args.deviceNumber = deviceNumber
6248 
    args.write(self._oprot)
6249 
    self._oprot.writeMessageEnd()
6250 
    self._oprot.trans.flush()
6251 
 
6252 
  def recv_getRechargeOrdersForDevice(self, ):
6253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6254 
    if mtype == TMessageType.EXCEPTION:
6255 
      x = TApplicationException()
6256 
      x.read(self._iprot)
6257 
      self._iprot.readMessageEnd()
6258 
      raise x
6259 
    result = getRechargeOrdersForDevice_result()
6260 
    result.read(self._iprot)
6261 
    self._iprot.readMessageEnd()
6262 
    if result.success is not None:
6263 
      return result.success
6264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6265 
 
6266 
  def addAmountToWallet(self, userId, orderId, amount):
6267 
    """
6268 
    Parameters:
6269 
     - userId
6270 
     - orderId
6271 
     - amount
6272 
    """
6273 
    self.send_addAmountToWallet(userId, orderId, amount)
6274 
    self.recv_addAmountToWallet()
6275 
 
6276 
  def send_addAmountToWallet(self, userId, orderId, amount):
6277 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6278 
    args = addAmountToWallet_args()
6279 
    args.userId = userId
6280 
    args.orderId = orderId
6281 
    args.amount = amount
6282 
    args.write(self._oprot)
6283 
    self._oprot.writeMessageEnd()
6284 
    self._oprot.trans.flush()
6285 
 
6286 
  def recv_addAmountToWallet(self, ):
6287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6288 
    if mtype == TMessageType.EXCEPTION:
6289 
      x = TApplicationException()
6290 
      x.read(self._iprot)
6291 
      self._iprot.readMessageEnd()
6292 
      raise x
6293 
    result = addAmountToWallet_result()
6294 
    result.read(self._iprot)
6295 
    self._iprot.readMessageEnd()
6296 
    return
6297 
 
6188 rajveer 6298 
  def getRechargeStatistics(self, ):
6299 
    self.send_getRechargeStatistics()
6300 
    return self.recv_getRechargeStatistics()
6301 
 
6302 
  def send_getRechargeStatistics(self, ):
6303 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6304 
    args = getRechargeStatistics_args()
6305 
    args.write(self._oprot)
6306 
    self._oprot.writeMessageEnd()
6307 
    self._oprot.trans.flush()
6308 
 
6309 
  def recv_getRechargeStatistics(self, ):
6310 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6311 
    if mtype == TMessageType.EXCEPTION:
6312 
      x = TApplicationException()
6313 
      x.read(self._iprot)
6314 
      self._iprot.readMessageEnd()
6315 
      raise x
6316 
    result = getRechargeStatistics_result()
6317 
    result.read(self._iprot)
6318 
    self._iprot.readMessageEnd()
6319 
    if result.success is not None:
6320 
      return result.success
6321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6322 
 
6154 rajveer 6323 
  def getRechargeOrdersForStatus(self, status):
6324 
    """
6325 
    Parameters:
6326 
     - status
6327 
    """
6328 
    self.send_getRechargeOrdersForStatus(status)
6329 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6330 
 
6154 rajveer 6331 
  def send_getRechargeOrdersForStatus(self, status):
6332 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6333 
    args = getRechargeOrdersForStatus_args()
6334 
    args.status = status
6335 
    args.write(self._oprot)
6336 
    self._oprot.writeMessageEnd()
6337 
    self._oprot.trans.flush()
6338 
 
6339 
  def recv_getRechargeOrdersForStatus(self, ):
6340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6341 
    if mtype == TMessageType.EXCEPTION:
6342 
      x = TApplicationException()
6343 
      x.read(self._iprot)
6344 
      self._iprot.readMessageEnd()
6345 
      raise x
6346 
    result = getRechargeOrdersForStatus_result()
6347 
    result.read(self._iprot)
6348 
    self._iprot.readMessageEnd()
6349 
    if result.success is not None:
6350 
      return result.success
6351 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6352 
 
6159 rajveer 6353 
  def getPlansForOperator(self, operatorId):
6354 
    """
6355 
    Parameters:
6356 
     - operatorId
6357 
    """
6358 
    self.send_getPlansForOperator(operatorId)
6359 
    return self.recv_getPlansForOperator()
6154 rajveer 6360 
 
6159 rajveer 6361 
  def send_getPlansForOperator(self, operatorId):
6362 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6363 
    args = getPlansForOperator_args()
6364 
    args.operatorId = operatorId
6365 
    args.write(self._oprot)
6366 
    self._oprot.writeMessageEnd()
6367 
    self._oprot.trans.flush()
6368 
 
6369 
  def recv_getPlansForOperator(self, ):
6370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6371 
    if mtype == TMessageType.EXCEPTION:
6372 
      x = TApplicationException()
6373 
      x.read(self._iprot)
6374 
      self._iprot.readMessageEnd()
6375 
      raise x
6376 
    result = getPlansForOperator_result()
6377 
    result.read(self._iprot)
6378 
    self._iprot.readMessageEnd()
6379 
    if result.success is not None:
6380 
      return result.success
6381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6382 
 
6307 anupam.sin 6383 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6384 
    """
6385 
    Returns denominations for a given operator and circle
6159 rajveer 6386 
 
6289 anupam.sin 6387 
    Parameters:
6388 
     - operatorId
6307 anupam.sin 6389 
     - circleCode
6289 anupam.sin 6390 
     - denominationType
6391 
    """
6307 anupam.sin 6392 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6393 
    return self.recv_getRechargeDenominations()
6394 
 
6307 anupam.sin 6395 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6396 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6397 
    args = getRechargeDenominations_args()
6398 
    args.operatorId = operatorId
6307 anupam.sin 6399 
    args.circleCode = circleCode
6289 anupam.sin 6400 
    args.denominationType = denominationType
6401 
    args.write(self._oprot)
6402 
    self._oprot.writeMessageEnd()
6403 
    self._oprot.trans.flush()
6404 
 
6405 
  def recv_getRechargeDenominations(self, ):
6406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6407 
    if mtype == TMessageType.EXCEPTION:
6408 
      x = TApplicationException()
6409 
      x.read(self._iprot)
6410 
      self._iprot.readMessageEnd()
6411 
      raise x
6412 
    result = getRechargeDenominations_result()
6413 
    result.read(self._iprot)
6414 
    self._iprot.readMessageEnd()
6415 
    if result.success is not None:
6416 
      return result.success
6417 
    if result.ex is not None:
6418 
      raise result.ex
6419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6420 
 
6371 rajveer 6421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6422 
    """
6423 
    Parameters:
6424 
     - operatorId
6425 
     - circleId
6426 
     - isAvailable
6427 
    """
6428 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6429 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6430 
 
6371 rajveer 6431 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6432 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6433 
    args = updateAvailabilityStatus_args()
6434 
    args.operatorId = operatorId
6435 
    args.circleId = circleId
6436 
    args.isAvailable = isAvailable
6437 
    args.write(self._oprot)
6438 
    self._oprot.writeMessageEnd()
6439 
    self._oprot.trans.flush()
6440 
 
6441 
  def recv_updateAvailabilityStatus(self, ):
6442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6443 
    if mtype == TMessageType.EXCEPTION:
6444 
      x = TApplicationException()
6445 
      x.read(self._iprot)
6446 
      self._iprot.readMessageEnd()
6447 
      raise x
6448 
    result = updateAvailabilityStatus_result()
6449 
    result.read(self._iprot)
6450 
    self._iprot.readMessageEnd()
6451 
    return
6452 
 
6389 rajveer 6453 
  def getAvailableEmiSchemes(self, ):
6454 
    self.send_getAvailableEmiSchemes()
6455 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6456 
 
6389 rajveer 6457 
  def send_getAvailableEmiSchemes(self, ):
6458 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6459 
    args = getAvailableEmiSchemes_args()
6460 
    args.write(self._oprot)
6461 
    self._oprot.writeMessageEnd()
6462 
    self._oprot.trans.flush()
6463 
 
6464 
  def recv_getAvailableEmiSchemes(self, ):
6465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6466 
    if mtype == TMessageType.EXCEPTION:
6467 
      x = TApplicationException()
6468 
      x.read(self._iprot)
6469 
      self._iprot.readMessageEnd()
6470 
      raise x
6471 
    result = getAvailableEmiSchemes_result()
6472 
    result.read(self._iprot)
6473 
    self._iprot.readMessageEnd()
6474 
    if result.success is not None:
6475 
      return result.success
6476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6477 
 
6478 
  def getMiscCharges(self, transactionId):
6479 
    """
6480 
    Parameters:
6481 
     - transactionId
6482 
    """
6483 
    self.send_getMiscCharges(transactionId)
6484 
    return self.recv_getMiscCharges()
6485 
 
6486 
  def send_getMiscCharges(self, transactionId):
6487 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6488 
    args = getMiscCharges_args()
6489 
    args.transactionId = transactionId
6490 
    args.write(self._oprot)
6491 
    self._oprot.writeMessageEnd()
6492 
    self._oprot.trans.flush()
6493 
 
6494 
  def recv_getMiscCharges(self, ):
6495 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6496 
    if mtype == TMessageType.EXCEPTION:
6497 
      x = TApplicationException()
6498 
      x.read(self._iprot)
6499 
      self._iprot.readMessageEnd()
6500 
      raise x
6501 
    result = getMiscCharges_result()
6502 
    result.read(self._iprot)
6503 
    self._iprot.readMessageEnd()
6504 
    if result.success is not None:
6505 
      return result.success
6506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6507 
 
6507 anupam.sin 6508 
  def refundRechargeOrder(self, rechargeOrderId):
6509 
    """
6510 
    Parameters:
6511 
     - rechargeOrderId
6512 
    """
6513 
    self.send_refundRechargeOrder(rechargeOrderId)
6514 
    return self.recv_refundRechargeOrder()
6389 rajveer 6515 
 
6507 anupam.sin 6516 
  def send_refundRechargeOrder(self, rechargeOrderId):
6517 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6518 
    args = refundRechargeOrder_args()
6519 
    args.rechargeOrderId = rechargeOrderId
6520 
    args.write(self._oprot)
6521 
    self._oprot.writeMessageEnd()
6522 
    self._oprot.trans.flush()
6523 
 
6524 
  def recv_refundRechargeOrder(self, ):
6525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6526 
    if mtype == TMessageType.EXCEPTION:
6527 
      x = TApplicationException()
6528 
      x.read(self._iprot)
6529 
      self._iprot.readMessageEnd()
6530 
      raise x
6531 
    result = refundRechargeOrder_result()
6532 
    result.read(self._iprot)
6533 
    self._iprot.readMessageEnd()
6534 
    if result.success is not None:
6535 
      return result.success
6536 
    if result.ex is not None:
6537 
      raise result.ex
6538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6539 
 
6540 
 
3376 rajveer 6541 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6542 
  def __init__(self, handler):
3376 rajveer 6543 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6544 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6545 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6546 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6547 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6548 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6549 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6550 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6551 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6552 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6553 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6554 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6555 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6556 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6557 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6558 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6559 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6560 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6561 
    self._processMap["createOrder"] = Processor.process_createOrder
6562 
    self._processMap["getOrder"] = Processor.process_getOrder
6563 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6564 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6565 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6566 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6567 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6568 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6569 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6570 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6571 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6572 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6573 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6574 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6575 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6576 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6577 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6578 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6579 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6580 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6581 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6582 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6583 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6584 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6585 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6586 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6587 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6588 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6589 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6590 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6591 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6592 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6593 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6594 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6595 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6596 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6597 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6598 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6599 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6600 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6601 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6602 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6603 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6604 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6605 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6606 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6607 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6608 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6609 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6610 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6611 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6612 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6613 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6614 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6615 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6616 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6617 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6618 
    self._processMap["changeItem"] = Processor.process_changeItem
6619 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6620 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6621 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6622 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6623 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6624 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6625 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6626 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6627 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6628 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6629 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6630 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6631 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6632 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6633 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6634 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6635 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6636 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6637 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6638 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6639 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6640 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6641 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6642 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6643 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6644 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6645 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6646 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6647 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6648 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6649 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6650 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6651 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6652 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6653 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6654 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6655 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6656 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6657 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6658 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6659 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6660 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6661 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6662 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6663 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6664 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6665 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6666 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6667 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6668 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6669 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6670 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6671 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6672 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6673 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6674 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6675 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6676 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6677 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6678 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6679 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6680 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6681 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6682 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6683 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6684 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6685 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6686 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6687 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6688 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6689 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6690 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6691 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
94 ashish 6692 
 
6693 
  def process(self, iprot, oprot):
6694 
    (name, type, seqid) = iprot.readMessageBegin()
6695 
    if name not in self._processMap:
6696 
      iprot.skip(TType.STRUCT)
6697 
      iprot.readMessageEnd()
6698 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6699 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6700 
      x.write(oprot)
6701 
      oprot.writeMessageEnd()
6702 
      oprot.trans.flush()
6703 
      return
6704 
    else:
6705 
      self._processMap[name](self, seqid, iprot, oprot)
6706 
    return True
6707 
 
6708 
  def process_createTransaction(self, seqid, iprot, oprot):
6709 
    args = createTransaction_args()
6710 
    args.read(iprot)
6711 
    iprot.readMessageEnd()
6712 
    result = createTransaction_result()
6713 
    try:
132 ashish 6714 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6715 
    except TransactionServiceException, ex:
6716 
      result.ex = ex
6717 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6718 
    result.write(oprot)
6719 
    oprot.writeMessageEnd()
6720 
    oprot.trans.flush()
6721 
 
6722 
  def process_getTransaction(self, seqid, iprot, oprot):
6723 
    args = getTransaction_args()
6724 
    args.read(iprot)
6725 
    iprot.readMessageEnd()
6726 
    result = getTransaction_result()
6727 
    try:
6728 
      result.success = self._handler.getTransaction(args.id)
6729 
    except TransactionServiceException, ex:
6730 
      result.ex = ex
6731 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6732 
    result.write(oprot)
6733 
    oprot.writeMessageEnd()
6734 
    oprot.trans.flush()
6735 
 
6736 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6737 
    args = getTransactionsForCustomer_args()
6738 
    args.read(iprot)
6739 
    iprot.readMessageEnd()
6740 
    result = getTransactionsForCustomer_result()
6741 
    try:
6742 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6743 
    except TransactionServiceException, ex:
6744 
      result.ex = ex
6745 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6746 
    result.write(oprot)
6747 
    oprot.writeMessageEnd()
6748 
    oprot.trans.flush()
6749 
 
132 ashish 6750 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6751 
    args = getTransactionsForShoppingCartId_args()
6752 
    args.read(iprot)
6753 
    iprot.readMessageEnd()
6754 
    result = getTransactionsForShoppingCartId_result()
6755 
    try:
6756 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6757 
    except TransactionServiceException, ex:
6758 
      result.ex = ex
6759 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6760 
    result.write(oprot)
6761 
    oprot.writeMessageEnd()
6762 
    oprot.trans.flush()
6763 
 
94 ashish 6764 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6765 
    args = getTransactionStatus_args()
6766 
    args.read(iprot)
6767 
    iprot.readMessageEnd()
6768 
    result = getTransactionStatus_result()
6769 
    try:
6770 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6771 
    except TransactionServiceException, ex:
6772 
      result.ex = ex
6773 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6774 
    result.write(oprot)
6775 
    oprot.writeMessageEnd()
6776 
    oprot.trans.flush()
6777 
 
6778 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6779 
    args = changeTransactionStatus_args()
6780 
    args.read(iprot)
6781 
    iprot.readMessageEnd()
6782 
    result = changeTransactionStatus_result()
6783 
    try:
5527 anupam.sin 6784 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6785 
    except TransactionServiceException, ex:
6786 
      result.ex = ex
6787 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6788 
    result.write(oprot)
6789 
    oprot.writeMessageEnd()
6790 
    oprot.trans.flush()
6791 
 
1398 varun.gupt 6792 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6793 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6794 
    args.read(iprot)
6795 
    iprot.readMessageEnd()
1398 varun.gupt 6796 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6797 
    try:
1398 varun.gupt 6798 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6799 
    except TransactionServiceException, ex:
6800 
      result.ex = ex
1398 varun.gupt 6801 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6802 
    result.write(oprot)
6803 
    oprot.writeMessageEnd()
6804 
    oprot.trans.flush()
6805 
 
483 rajveer 6806 
  def process_getAllOrders(self, seqid, iprot, oprot):
6807 
    args = getAllOrders_args()
94 ashish 6808 
    args.read(iprot)
6809 
    iprot.readMessageEnd()
483 rajveer 6810 
    result = getAllOrders_result()
94 ashish 6811 
    try:
4801 anupam.sin 6812 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6813 
    except TransactionServiceException, ex:
6814 
      result.ex = ex
483 rajveer 6815 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6816 
    result.write(oprot)
6817 
    oprot.writeMessageEnd()
6818 
    oprot.trans.flush()
6819 
 
4133 chandransh 6820 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6821 
    args = getOrdersInBatch_args()
6822 
    args.read(iprot)
6823 
    iprot.readMessageEnd()
6824 
    result = getOrdersInBatch_result()
6825 
    try:
6826 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6827 
    except TransactionServiceException, ex:
6828 
      result.ex = ex
6829 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6830 
    result.write(oprot)
6831 
    oprot.writeMessageEnd()
6832 
    oprot.trans.flush()
6833 
 
6834 
  def process_getOrderCount(self, seqid, iprot, oprot):
6835 
    args = getOrderCount_args()
6836 
    args.read(iprot)
6837 
    iprot.readMessageEnd()
6838 
    result = getOrderCount_result()
6839 
    try:
6840 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6841 
    except TransactionServiceException, ex:
6842 
      result.ex = ex
6843 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6844 
    result.write(oprot)
6845 
    oprot.writeMessageEnd()
6846 
    oprot.trans.flush()
6847 
 
999 varun.gupt 6848 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6849 
    args = getOrdersByBillingDate_args()
6850 
    args.read(iprot)
6851 
    iprot.readMessageEnd()
6852 
    result = getOrdersByBillingDate_result()
6853 
    try:
6854 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6855 
    except TransactionServiceException, ex:
6856 
      result.ex = ex
6857 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6858 
    result.write(oprot)
6859 
    oprot.writeMessageEnd()
6860 
    oprot.trans.flush()
6861 
 
3427 chandransh 6862 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6863 
    args = getOrdersByShippingDate_args()
6864 
    args.read(iprot)
6865 
    iprot.readMessageEnd()
6866 
    result = getOrdersByShippingDate_result()
6867 
    try:
3451 chandransh 6868 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6869 
    except TransactionServiceException, ex:
6870 
      result.ex = ex
6871 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6872 
    result.write(oprot)
6873 
    oprot.writeMessageEnd()
6874 
    oprot.trans.flush()
6875 
 
1382 varun.gupt 6876 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6877 
    args = getReturnableOrdersForCustomer_args()
6878 
    args.read(iprot)
6879 
    iprot.readMessageEnd()
6880 
    result = getReturnableOrdersForCustomer_result()
6881 
    try:
6882 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6883 
    except TransactionServiceException, ex:
6884 
      result.ex = ex
6885 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6886 
    result.write(oprot)
6887 
    oprot.writeMessageEnd()
6888 
    oprot.trans.flush()
6889 
 
6890 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6891 
    args = getCancellableOrdersForCustomer_args()
6892 
    args.read(iprot)
6893 
    iprot.readMessageEnd()
6894 
    result = getCancellableOrdersForCustomer_result()
6895 
    try:
6896 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6897 
    except TransactionServiceException, ex:
6898 
      result.ex = ex
6899 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6900 
    result.write(oprot)
6901 
    oprot.writeMessageEnd()
6902 
    oprot.trans.flush()
6903 
 
483 rajveer 6904 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6905 
    args = changeOrderStatus_args()
94 ashish 6906 
    args.read(iprot)
6907 
    iprot.readMessageEnd()
483 rajveer 6908 
    result = changeOrderStatus_result()
94 ashish 6909 
    try:
483 rajveer 6910 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6911 
    except TransactionServiceException, ex:
6912 
      result.ex = ex
483 rajveer 6913 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6914 
    result.write(oprot)
6915 
    oprot.writeMessageEnd()
6916 
    oprot.trans.flush()
6917 
 
483 rajveer 6918 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6919 
    args = getOrdersForTransaction_args()
94 ashish 6920 
    args.read(iprot)
6921 
    iprot.readMessageEnd()
483 rajveer 6922 
    result = getOrdersForTransaction_result()
94 ashish 6923 
    try:
1528 ankur.sing 6924 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6925 
    except TransactionServiceException, ex:
6926 
      result.ex = ex
483 rajveer 6927 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6928 
    result.write(oprot)
6929 
    oprot.writeMessageEnd()
6930 
    oprot.trans.flush()
6931 
 
483 rajveer 6932 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6933 
    args = getOrdersForCustomer_args()
94 ashish 6934 
    args.read(iprot)
6935 
    iprot.readMessageEnd()
483 rajveer 6936 
    result = getOrdersForCustomer_result()
94 ashish 6937 
    try:
3014 chandransh 6938 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6939 
    except TransactionServiceException, ex:
6940 
      result.ex = ex
483 rajveer 6941 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6942 
    result.write(oprot)
6943 
    oprot.writeMessageEnd()
6944 
    oprot.trans.flush()
6945 
 
483 rajveer 6946 
  def process_createOrder(self, seqid, iprot, oprot):
6947 
    args = createOrder_args()
94 ashish 6948 
    args.read(iprot)
6949 
    iprot.readMessageEnd()
483 rajveer 6950 
    result = createOrder_result()
94 ashish 6951 
    try:
483 rajveer 6952 
      result.success = self._handler.createOrder(args.order)
94 ashish 6953 
    except TransactionServiceException, ex:
6954 
      result.ex = ex
483 rajveer 6955 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6956 
    result.write(oprot)
6957 
    oprot.writeMessageEnd()
6958 
    oprot.trans.flush()
6959 
 
483 rajveer 6960 
  def process_getOrder(self, seqid, iprot, oprot):
6961 
    args = getOrder_args()
94 ashish 6962 
    args.read(iprot)
6963 
    iprot.readMessageEnd()
483 rajveer 6964 
    result = getOrder_result()
94 ashish 6965 
    try:
483 rajveer 6966 
      result.success = self._handler.getOrder(args.id)
94 ashish 6967 
    except TransactionServiceException, ex:
6968 
      result.ex = ex
483 rajveer 6969 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6970 
    result.write(oprot)
6971 
    oprot.writeMessageEnd()
6972 
    oprot.trans.flush()
6973 
 
483 rajveer 6974 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6975 
    args = getLineItemsForOrder_args()
94 ashish 6976 
    args.read(iprot)
6977 
    iprot.readMessageEnd()
483 rajveer 6978 
    result = getLineItemsForOrder_result()
94 ashish 6979 
    try:
483 rajveer 6980 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6981 
    except TransactionServiceException, ex:
6982 
      result.ex = ex
483 rajveer 6983 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6984 
    result.write(oprot)
6985 
    oprot.writeMessageEnd()
6986 
    oprot.trans.flush()
6987 
 
4999 phani.kuma 6988 
  def process_getOrderList(self, seqid, iprot, oprot):
6989 
    args = getOrderList_args()
6990 
    args.read(iprot)
6991 
    iprot.readMessageEnd()
6992 
    result = getOrderList_result()
6993 
    result.success = self._handler.getOrderList(args.order_ids)
6994 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6995 
    result.write(oprot)
6996 
    oprot.writeMessageEnd()
6997 
    oprot.trans.flush()
6998 
 
5386 phani.kuma 6999 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7000 
    args = getOrderListForVendor_args()
7001 
    args.read(iprot)
7002 
    iprot.readMessageEnd()
7003 
    result = getOrderListForVendor_result()
7004 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7005 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7006 
    result.write(oprot)
7007 
    oprot.writeMessageEnd()
7008 
    oprot.trans.flush()
7009 
 
1528 ankur.sing 7010 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7011 
    args = getOrderForCustomer_args()
7012 
    args.read(iprot)
7013 
    iprot.readMessageEnd()
7014 
    result = getOrderForCustomer_result()
7015 
    try:
7016 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7017 
    except TransactionServiceException, ex:
7018 
      result.ex = ex
7019 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7020 
    result.write(oprot)
7021 
    oprot.writeMessageEnd()
7022 
    oprot.trans.flush()
7023 
 
3064 chandransh 7024 
  def process_getAlerts(self, seqid, iprot, oprot):
7025 
    args = getAlerts_args()
7026 
    args.read(iprot)
7027 
    iprot.readMessageEnd()
7028 
    result = getAlerts_result()
4444 rajveer 7029 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7030 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7031 
    result.write(oprot)
7032 
    oprot.writeMessageEnd()
7033 
    oprot.trans.flush()
7034 
 
4394 rajveer 7035 
  def process_addAlert(self, seqid, iprot, oprot):
7036 
    args = addAlert_args()
3064 chandransh 7037 
    args.read(iprot)
7038 
    iprot.readMessageEnd()
4394 rajveer 7039 
    result = addAlert_result()
4444 rajveer 7040 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7041 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7042 
    result.write(oprot)
7043 
    oprot.writeMessageEnd()
7044 
    oprot.trans.flush()
7045 
 
4444 rajveer 7046 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7047 
    args = markAlertsAsSeen_args()
7048 
    args.read(iprot)
7049 
    iprot.readMessageEnd()
7050 
    result = markAlertsAsSeen_result()
7051 
    self._handler.markAlertsAsSeen(args.warehouseId)
7052 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7053 
    result.write(oprot)
7054 
    oprot.writeMessageEnd()
7055 
    oprot.trans.flush()
7056 
 
3064 chandransh 7057 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7058 
    args = getValidOrderCount_args()
7059 
    args.read(iprot)
7060 
    iprot.readMessageEnd()
7061 
    result = getValidOrderCount_result()
7062 
    result.success = self._handler.getValidOrderCount()
7063 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7064 
    result.write(oprot)
7065 
    oprot.writeMessageEnd()
7066 
    oprot.trans.flush()
7067 
 
7068 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7069 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7070 
    args.read(iprot)
7071 
    iprot.readMessageEnd()
7072 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7073 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7074 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7075 
    result.write(oprot)
7076 
    oprot.writeMessageEnd()
7077 
    oprot.trans.flush()
7078 
 
7079 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7080 
    args = getValidOrdersAmountRange_args()
7081 
    args.read(iprot)
7082 
    iprot.readMessageEnd()
7083 
    result = getValidOrdersAmountRange_result()
7084 
    result.success = self._handler.getValidOrdersAmountRange()
7085 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7086 
    result.write(oprot)
7087 
    oprot.writeMessageEnd()
7088 
    oprot.trans.flush()
7089 
 
7090 
  def process_getValidOrders(self, seqid, iprot, oprot):
7091 
    args = getValidOrders_args()
7092 
    args.read(iprot)
7093 
    iprot.readMessageEnd()
7094 
    result = getValidOrders_result()
5874 rajveer 7095 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7096 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7097 
    result.write(oprot)
7098 
    oprot.writeMessageEnd()
7099 
    oprot.trans.flush()
7100 
 
1220 chandransh 7101 
  def process_batchOrders(self, seqid, iprot, oprot):
7102 
    args = batchOrders_args()
7103 
    args.read(iprot)
7104 
    iprot.readMessageEnd()
7105 
    result = batchOrders_result()
7106 
    try:
7107 
      result.success = self._handler.batchOrders(args.warehouseId)
7108 
    except TransactionServiceException, ex:
7109 
      result.ex = ex
7110 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7111 
    result.write(oprot)
7112 
    oprot.writeMessageEnd()
7113 
    oprot.trans.flush()
7114 
 
1208 chandransh 7115 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7116 
    args = markOrderAsOutOfStock_args()
7117 
    args.read(iprot)
7118 
    iprot.readMessageEnd()
7119 
    result = markOrderAsOutOfStock_result()
7120 
    try:
7121 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7122 
    except TransactionServiceException, ex:
7123 
      result.ex = ex
7124 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7125 
    result.write(oprot)
7126 
    oprot.writeMessageEnd()
7127 
    oprot.trans.flush()
7128 
 
3064 chandransh 7129 
  def process_verifyOrder(self, seqid, iprot, oprot):
7130 
    args = verifyOrder_args()
759 chandransh 7131 
    args.read(iprot)
7132 
    iprot.readMessageEnd()
3064 chandransh 7133 
    result = verifyOrder_result()
759 chandransh 7134 
    try:
3064 chandransh 7135 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7136 
    except TransactionServiceException, ex:
7137 
      result.ex = ex
3064 chandransh 7138 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7139 
    result.write(oprot)
7140 
    oprot.writeMessageEnd()
7141 
    oprot.trans.flush()
7142 
 
3064 chandransh 7143 
  def process_acceptOrder(self, seqid, iprot, oprot):
7144 
    args = acceptOrder_args()
1113 chandransh 7145 
    args.read(iprot)
7146 
    iprot.readMessageEnd()
3064 chandransh 7147 
    result = acceptOrder_result()
1113 chandransh 7148 
    try:
3064 chandransh 7149 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7150 
    except TransactionServiceException, ex:
7151 
      result.ex = ex
3064 chandransh 7152 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7153 
    result.write(oprot)
7154 
    oprot.writeMessageEnd()
7155 
    oprot.trans.flush()
7156 
 
3064 chandransh 7157 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7158 
    args = addBillingDetails_args()
1135 chandransh 7159 
    args.read(iprot)
7160 
    iprot.readMessageEnd()
3064 chandransh 7161 
    result = addBillingDetails_result()
1135 chandransh 7162 
    try:
5110 mandeep.dh 7163 
      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 7164 
    except TransactionServiceException, ex:
7165 
      result.ex = ex
3064 chandransh 7166 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7167 
    result.write(oprot)
7168 
    oprot.writeMessageEnd()
7169 
    oprot.trans.flush()
7170 
 
4579 rajveer 7171 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7172 
    args = addInvoiceNumber_args()
7173 
    args.read(iprot)
7174 
    iprot.readMessageEnd()
7175 
    result = addInvoiceNumber_result()
7176 
    try:
4763 rajveer 7177 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7178 
    except TransactionServiceException, ex:
7179 
      result.ex = ex
7180 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7181 
    result.write(oprot)
7182 
    oprot.writeMessageEnd()
7183 
    oprot.trans.flush()
7184 
 
4410 rajveer 7185 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7186 
    args = markOrdersAsShippedFromWarehouse_args()
7187 
    args.read(iprot)
7188 
    iprot.readMessageEnd()
7189 
    result = markOrdersAsShippedFromWarehouse_result()
7190 
    try:
4789 rajveer 7191 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7192 
    except TransactionServiceException, ex:
7193 
      result.ex = ex
7194 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7195 
    result.write(oprot)
7196 
    oprot.writeMessageEnd()
7197 
    oprot.trans.flush()
7198 
 
5676 rajveer 7199 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7200 
    args = markOrdersAsReturnedFromStore_args()
7201 
    args.read(iprot)
7202 
    iprot.readMessageEnd()
7203 
    result = markOrdersAsReturnedFromStore_result()
7204 
    try:
5713 rajveer 7205 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7206 
    except TransactionServiceException, ex:
7207 
      result.ex = ex
7208 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7209 
    result.write(oprot)
7210 
    oprot.writeMessageEnd()
7211 
    oprot.trans.flush()
7212 
 
3064 chandransh 7213 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7214 
    args = markOrdersAsPickedUp_args()
304 ashish 7215 
    args.read(iprot)
7216 
    iprot.readMessageEnd()
3064 chandransh 7217 
    result = markOrdersAsPickedUp_result()
7218 
    try:
4910 phani.kuma 7219 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7220 
    except TransactionServiceException, ex:
7221 
      result.ex = ex
7222 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7223 
    result.write(oprot)
7224 
    oprot.writeMessageEnd()
7225 
    oprot.trans.flush()
94 ashish 7226 
 
4910 phani.kuma 7227 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7228 
    args = getOrdersNotPickedUp_args()
7229 
    args.read(iprot)
7230 
    iprot.readMessageEnd()
7231 
    result = getOrdersNotPickedUp_result()
7232 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7233 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7234 
    result.write(oprot)
7235 
    oprot.writeMessageEnd()
7236 
    oprot.trans.flush()
7237 
 
3064 chandransh 7238 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7239 
    args = markOrdersAsDelivered_args()
304 ashish 7240 
    args.read(iprot)
7241 
    iprot.readMessageEnd()
3064 chandransh 7242 
    result = markOrdersAsDelivered_result()
7243 
    try:
7244 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7245 
    except TransactionServiceException, ex:
7246 
      result.ex = ex
7247 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7248 
    result.write(oprot)
7249 
    oprot.writeMessageEnd()
7250 
    oprot.trans.flush()
7251 
 
4910 phani.kuma 7252 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7253 
    args = markAsRTOrders_args()
1596 ankur.sing 7254 
    args.read(iprot)
7255 
    iprot.readMessageEnd()
4910 phani.kuma 7256 
    result = markAsRTOrders_result()
3064 chandransh 7257 
    try:
4910 phani.kuma 7258 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7259 
    except TransactionServiceException, ex:
7260 
      result.ex = ex
4910 phani.kuma 7261 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7262 
    result.write(oprot)
7263 
    oprot.writeMessageEnd()
7264 
    oprot.trans.flush()
304 ashish 7265 
 
4910 phani.kuma 7266 
  def process_getRTOrders(self, seqid, iprot, oprot):
7267 
    args = getRTOrders_args()
7268 
    args.read(iprot)
7269 
    iprot.readMessageEnd()
7270 
    result = getRTOrders_result()
7271 
    result.success = self._handler.getRTOrders(args.providerId)
7272 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
7276 
 
3064 chandransh 7277 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7278 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
3064 chandransh 7281 
    result = updateNonDeliveryReason_result()
7282 
    try:
4910 phani.kuma 7283 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7284 
    except TransactionServiceException, ex:
7285 
      result.ex = ex
7286 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7287 
    result.write(oprot)
7288 
    oprot.writeMessageEnd()
7289 
    oprot.trans.flush()
1596 ankur.sing 7290 
 
4910 phani.kuma 7291 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7292 
    args = getNonDeliveredOrdersbyCourier_args()
7293 
    args.read(iprot)
7294 
    iprot.readMessageEnd()
7295 
    result = getNonDeliveredOrdersbyCourier_result()
7296 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7297 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7298 
    result.write(oprot)
7299 
    oprot.writeMessageEnd()
7300 
    oprot.trans.flush()
7301 
 
7302 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7303 
    args = markOrdersAsLocalConnected_args()
7304 
    args.read(iprot)
7305 
    iprot.readMessageEnd()
7306 
    result = markOrdersAsLocalConnected_result()
7307 
    try:
7308 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7309 
    except TransactionServiceException, ex:
7310 
      result.ex = ex
7311 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7312 
    result.write(oprot)
7313 
    oprot.writeMessageEnd()
7314 
    oprot.trans.flush()
7315 
 
7316 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7317 
    args = getOrdersNotLocalConnected_args()
7318 
    args.read(iprot)
7319 
    iprot.readMessageEnd()
7320 
    result = getOrdersNotLocalConnected_result()
7321 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7322 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7323 
    result.write(oprot)
7324 
    oprot.writeMessageEnd()
7325 
    oprot.trans.flush()
7326 
 
7327 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7328 
    args = markOrdersAsDestinationCityReached_args()
7329 
    args.read(iprot)
7330 
    iprot.readMessageEnd()
7331 
    result = markOrdersAsDestinationCityReached_result()
7332 
    try:
7333 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7334 
    except TransactionServiceException, ex:
7335 
      result.ex = ex
7336 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7337 
    result.write(oprot)
7338 
    oprot.writeMessageEnd()
7339 
    oprot.trans.flush()
7340 
 
7341 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7342 
    args = markOrdersAsFirstDeliveryAttempted_args()
7343 
    args.read(iprot)
7344 
    iprot.readMessageEnd()
7345 
    result = markOrdersAsFirstDeliveryAttempted_result()
7346 
    try:
7347 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7348 
    except TransactionServiceException, ex:
7349 
      result.ex = ex
7350 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7351 
    result.write(oprot)
7352 
    oprot.writeMessageEnd()
7353 
    oprot.trans.flush()
7354 
 
3064 chandransh 7355 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7356 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7357 
    args.read(iprot)
7358 
    iprot.readMessageEnd()
3064 chandransh 7359 
    result = getUndeliveredOrders_result()
7360 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7361 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7362 
    result.write(oprot)
7363 
    oprot.writeMessageEnd()
7364 
    oprot.trans.flush()
7365 
 
4783 phani.kuma 7366 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7367 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7368 
    args.read(iprot)
7369 
    iprot.readMessageEnd()
7370 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7371 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7372 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
2536 chandransh 7377 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7378 
    args = toggleDOAFlag_args()
7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
7381 
    result = toggleDOAFlag_result()
7382 
    try:
7383 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7384 
    except TransactionServiceException, ex:
7385 
      result.ex = ex
7386 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
1886 ankur.sing 7390 
 
4712 rajveer 7391 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7392 
    args = markOrderAsDelivered_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = markOrderAsDelivered_result()
7396 
    try:
7397 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7398 
    except TransactionServiceException, ex:
7399 
      result.ex = ex
7400 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7401 
    result.write(oprot)
7402 
    oprot.writeMessageEnd()
7403 
    oprot.trans.flush()
7404 
 
5553 rajveer 7405 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7406 
    args = markOrderAsReceivedAtStore_args()
7407 
    args.read(iprot)
7408 
    iprot.readMessageEnd()
7409 
    result = markOrderAsReceivedAtStore_result()
7410 
    try:
7411 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7412 
    except TransactionServiceException, ex:
7413 
      result.ex = ex
7414 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
7418 
 
4454 rajveer 7419 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7420 
    args = markOrderDoaRequestReceived_args()
7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
7423 
    result = markOrderDoaRequestReceived_result()
7424 
    try:
7425 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7426 
    except TransactionServiceException, ex:
7427 
      result.ex = ex
7428 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7429 
    result.write(oprot)
7430 
    oprot.writeMessageEnd()
7431 
    oprot.trans.flush()
7432 
 
7433 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7434 
    args = markOrderDoaRequestAuthorized_args()
7435 
    args.read(iprot)
7436 
    iprot.readMessageEnd()
7437 
    result = markOrderDoaRequestAuthorized_result()
7438 
    try:
7439 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7440 
    except TransactionServiceException, ex:
7441 
      result.ex = ex
7442 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7443 
    result.write(oprot)
7444 
    oprot.writeMessageEnd()
7445 
    oprot.trans.flush()
7446 
 
4488 rajveer 7447 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7448 
    args = markOrderReturnRequestReceived_args()
7449 
    args.read(iprot)
7450 
    iprot.readMessageEnd()
7451 
    result = markOrderReturnRequestReceived_result()
7452 
    try:
7453 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7454 
    except TransactionServiceException, ex:
7455 
      result.ex = ex
7456 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7457 
    result.write(oprot)
7458 
    oprot.writeMessageEnd()
7459 
    oprot.trans.flush()
7460 
 
7461 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7462 
    args = markOrderReturnRequestAuthorized_args()
7463 
    args.read(iprot)
7464 
    iprot.readMessageEnd()
7465 
    result = markOrderReturnRequestAuthorized_result()
7466 
    try:
7467 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7468 
    except TransactionServiceException, ex:
7469 
      result.ex = ex
7470 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7471 
    result.write(oprot)
7472 
    oprot.writeMessageEnd()
7473 
    oprot.trans.flush()
7474 
 
2536 chandransh 7475 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7476 
    args = requestPickupNumber_args()
7477 
    args.read(iprot)
7478 
    iprot.readMessageEnd()
7479 
    result = requestPickupNumber_result()
7480 
    try:
4579 rajveer 7481 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7482 
    except TransactionServiceException, ex:
7483 
      result.ex = ex
7484 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7485 
    result.write(oprot)
7486 
    oprot.writeMessageEnd()
7487 
    oprot.trans.flush()
7488 
 
7489 
  def process_authorizePickup(self, seqid, iprot, oprot):
7490 
    args = authorizePickup_args()
7491 
    args.read(iprot)
7492 
    iprot.readMessageEnd()
7493 
    result = authorizePickup_result()
7494 
    try:
4602 rajveer 7495 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7496 
    except TransactionServiceException, ex:
7497 
      result.ex = ex
7498 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7499 
    result.write(oprot)
7500 
    oprot.writeMessageEnd()
7501 
    oprot.trans.flush()
7502 
 
2764 chandransh 7503 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7504 
    args = markDoasAsPickedUp_args()
7505 
    args.read(iprot)
7506 
    iprot.readMessageEnd()
7507 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7508 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7509 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7510 
    result.write(oprot)
7511 
    oprot.writeMessageEnd()
7512 
    oprot.trans.flush()
7513 
 
4910 phani.kuma 7514 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7515 
    args = getDoasNotPickedUp_args()
7516 
    args.read(iprot)
7517 
    iprot.readMessageEnd()
7518 
    result = getDoasNotPickedUp_result()
7519 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7520 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7521 
    result.write(oprot)
7522 
    oprot.writeMessageEnd()
7523 
    oprot.trans.flush()
7524 
 
4741 phani.kuma 7525 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7526 
    args = markReturnOrdersAsPickedUp_args()
7527 
    args.read(iprot)
7528 
    iprot.readMessageEnd()
7529 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7530 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7531 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7532 
    result.write(oprot)
7533 
    oprot.writeMessageEnd()
7534 
    oprot.trans.flush()
7535 
 
4910 phani.kuma 7536 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7537 
    args = getReturnOrdersNotPickedUp_args()
7538 
    args.read(iprot)
7539 
    iprot.readMessageEnd()
7540 
    result = getReturnOrdersNotPickedUp_result()
7541 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7542 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7543 
    result.write(oprot)
7544 
    oprot.writeMessageEnd()
7545 
    oprot.trans.flush()
7546 
 
2616 chandransh 7547 
  def process_receiveReturn(self, seqid, iprot, oprot):
7548 
    args = receiveReturn_args()
2591 chandransh 7549 
    args.read(iprot)
7550 
    iprot.readMessageEnd()
2616 chandransh 7551 
    result = receiveReturn_result()
2591 chandransh 7552 
    try:
4479 rajveer 7553 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7554 
    except TransactionServiceException, ex:
7555 
      result.ex = ex
2616 chandransh 7556 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7557 
    result.write(oprot)
7558 
    oprot.writeMessageEnd()
7559 
    oprot.trans.flush()
2536 chandransh 7560 
 
2591 chandransh 7561 
  def process_validateDoa(self, seqid, iprot, oprot):
7562 
    args = validateDoa_args()
7563 
    args.read(iprot)
7564 
    iprot.readMessageEnd()
7565 
    result = validateDoa_result()
7566 
    try:
7567 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7568 
    except TransactionServiceException, ex:
7569 
      result.ex = ex
7570 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7571 
    result.write(oprot)
7572 
    oprot.writeMessageEnd()
7573 
    oprot.trans.flush()
7574 
 
4495 rajveer 7575 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7576 
    args = validateReturnProduct_args()
7577 
    args.read(iprot)
7578 
    iprot.readMessageEnd()
7579 
    result = validateReturnProduct_result()
7580 
    try:
7581 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7582 
    except TransactionServiceException, ex:
7583 
      result.ex = ex
7584 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7585 
    result.write(oprot)
7586 
    oprot.writeMessageEnd()
7587 
    oprot.trans.flush()
7588 
 
2616 chandransh 7589 
  def process_reshipOrder(self, seqid, iprot, oprot):
7590 
    args = reshipOrder_args()
7591 
    args.read(iprot)
7592 
    iprot.readMessageEnd()
7593 
    result = reshipOrder_result()
7594 
    try:
7595 
      result.success = self._handler.reshipOrder(args.orderId)
7596 
    except TransactionServiceException, ex:
7597 
      result.ex = ex
7598 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7599 
    result.write(oprot)
7600 
    oprot.writeMessageEnd()
7601 
    oprot.trans.flush()
2591 chandransh 7602 
 
2616 chandransh 7603 
  def process_refundOrder(self, seqid, iprot, oprot):
7604 
    args = refundOrder_args()
7605 
    args.read(iprot)
7606 
    iprot.readMessageEnd()
7607 
    result = refundOrder_result()
7608 
    try:
3226 chandransh 7609 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7610 
    except TransactionServiceException, ex:
7611 
      result.ex = ex
7612 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7613 
    result.write(oprot)
7614 
    oprot.writeMessageEnd()
7615 
    oprot.trans.flush()
7616 
 
2690 chandransh 7617 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7618 
    args = getReturnOrders_args()
7619 
    args.read(iprot)
7620 
    iprot.readMessageEnd()
7621 
    result = getReturnOrders_result()
7622 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7623 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7624 
    result.write(oprot)
7625 
    oprot.writeMessageEnd()
7626 
    oprot.trans.flush()
2616 chandransh 7627 
 
5481 phani.kuma 7628 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7629 
    args = getAllReturnOrders_args()
7630 
    args.read(iprot)
7631 
    iprot.readMessageEnd()
7632 
    result = getAllReturnOrders_result()
7633 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7634 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
2700 chandransh 7639 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7640 
    args = getReturnOrder_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = getReturnOrder_result()
7644 
    try:
7645 
      result.success = self._handler.getReturnOrder(args.id)
7646 
    except TransactionServiceException, ex:
7647 
      result.ex = ex
7648 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
7652 
 
2690 chandransh 7653 
  def process_processReturn(self, seqid, iprot, oprot):
7654 
    args = processReturn_args()
7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
7657 
    result = processReturn_result()
7658 
    try:
7659 
      self._handler.processReturn(args.returnOrderId)
7660 
    except TransactionServiceException, ex:
7661 
      result.ex = ex
7662 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
7666 
 
3451 chandransh 7667 
  def process_updateWeight(self, seqid, iprot, oprot):
7668 
    args = updateWeight_args()
7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
7671 
    result = updateWeight_result()
7672 
    try:
7673 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7674 
    except TransactionServiceException, ex:
7675 
      result.ex = ex
7676 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
2819 chandransh 7680 
 
3469 chandransh 7681 
  def process_changeItem(self, seqid, iprot, oprot):
7682 
    args = changeItem_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = changeItem_result()
7686 
    try:
7687 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7688 
    except TransactionServiceException, ex:
7689 
      result.ex = ex
7690 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
3451 chandransh 7694 
 
3469 chandransh 7695 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7696 
    args = shiftToWarehouse_args()
7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
7699 
    result = shiftToWarehouse_result()
7700 
    try:
7701 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7702 
    except TransactionServiceException, ex:
7703 
      result.ex = ex
7704 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
7708 
 
3553 chandransh 7709 
  def process_addDelayReason(self, seqid, iprot, oprot):
7710 
    args = addDelayReason_args()
7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
7713 
    result = addDelayReason_result()
7714 
    try:
4647 rajveer 7715 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7716 
    except TransactionServiceException, ex:
7717 
      result.ex = ex
7718 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7719 
    result.write(oprot)
7720 
    oprot.writeMessageEnd()
7721 
    oprot.trans.flush()
3469 chandransh 7722 
 
3956 chandransh 7723 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7724 
    args = reconcileCodCollection_args()
7725 
    args.read(iprot)
7726 
    iprot.readMessageEnd()
7727 
    result = reconcileCodCollection_result()
7728 
    try:
7729 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7730 
    except TransactionServiceException, ex:
7731 
      result.ex = ex
7732 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7733 
    result.write(oprot)
7734 
    oprot.writeMessageEnd()
7735 
    oprot.trans.flush()
3553 chandransh 7736 
 
4008 mandeep.dh 7737 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7738 
    args = getTransactionsRequiringExtraProcessing_args()
7739 
    args.read(iprot)
7740 
    iprot.readMessageEnd()
7741 
    result = getTransactionsRequiringExtraProcessing_result()
7742 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7743 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7744 
    result.write(oprot)
7745 
    oprot.writeMessageEnd()
7746 
    oprot.trans.flush()
3956 chandransh 7747 
 
4008 mandeep.dh 7748 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7749 
    args = markTransactionAsProcessed_args()
7750 
    args.read(iprot)
7751 
    iprot.readMessageEnd()
7752 
    result = markTransactionAsProcessed_result()
7753 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7754 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7755 
    result.write(oprot)
7756 
    oprot.writeMessageEnd()
7757 
    oprot.trans.flush()
7758 
 
4018 chandransh 7759 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7760 
    args = getItemWiseRiskyOrdersCount_args()
7761 
    args.read(iprot)
7762 
    iprot.readMessageEnd()
7763 
    result = getItemWiseRiskyOrdersCount_result()
7764 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7765 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7766 
    result.write(oprot)
7767 
    oprot.writeMessageEnd()
7768 
    oprot.trans.flush()
4008 mandeep.dh 7769 
 
4295 varun.gupt 7770 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7771 
    args = getOrdersForItemIds_args()
7772 
    args.read(iprot)
7773 
    iprot.readMessageEnd()
7774 
    result = getOrdersForItemIds_result()
7775 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7776 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7777 
    result.write(oprot)
7778 
    oprot.writeMessageEnd()
7779 
    oprot.trans.flush()
7780 
 
4247 rajveer 7781 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7782 
    args = markOrderCancellationRequestReceived_args()
7783 
    args.read(iprot)
7784 
    iprot.readMessageEnd()
7785 
    result = markOrderCancellationRequestReceived_result()
7786 
    try:
7787 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7788 
    except TransactionServiceException, ex:
7789 
      result.ex = ex
7790 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7791 
    result.write(oprot)
7792 
    oprot.writeMessageEnd()
7793 
    oprot.trans.flush()
4018 chandransh 7794 
 
4247 rajveer 7795 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7796 
    args = markOrderCancellationRequestConfirmed_args()
7797 
    args.read(iprot)
7798 
    iprot.readMessageEnd()
7799 
    result = markOrderCancellationRequestConfirmed_result()
7800 
    try:
7801 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7802 
    except TransactionServiceException, ex:
7803 
      result.ex = ex
7804 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7805 
    result.write(oprot)
7806 
    oprot.writeMessageEnd()
7807 
    oprot.trans.flush()
7808 
 
7809 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7810 
    args = markOrderCancellationRequestDenied_args()
7811 
    args.read(iprot)
7812 
    iprot.readMessageEnd()
7813 
    result = markOrderCancellationRequestDenied_result()
7814 
    try:
7815 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7816 
    except TransactionServiceException, ex:
7817 
      result.ex = ex
7818 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7819 
    result.write(oprot)
7820 
    oprot.writeMessageEnd()
7821 
    oprot.trans.flush()
7822 
 
4258 rajveer 7823 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7824 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7825 
    args.read(iprot)
7826 
    iprot.readMessageEnd()
4258 rajveer 7827 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7828 
    try:
4258 rajveer 7829 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7830 
    except TransactionServiceException, ex:
7831 
      result.ex = ex
4258 rajveer 7832 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7833 
    result.write(oprot)
7834 
    oprot.writeMessageEnd()
7835 
    oprot.trans.flush()
7836 
 
4259 anupam.sin 7837 
  def process_refundTransaction(self, seqid, iprot, oprot):
7838 
    args = refundTransaction_args()
7839 
    args.read(iprot)
7840 
    iprot.readMessageEnd()
7841 
    result = refundTransaction_result()
7842 
    try:
7843 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7844 
    except TransactionServiceException, ex:
7845 
      result.ex = ex
7846 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7847 
    result.write(oprot)
7848 
    oprot.writeMessageEnd()
7849 
    oprot.trans.flush()
4247 rajveer 7850 
 
4324 mandeep.dh 7851 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7852 
    args = updateShipmentAddress_args()
7853 
    args.read(iprot)
7854 
    iprot.readMessageEnd()
7855 
    result = updateShipmentAddress_result()
7856 
    try:
7857 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7858 
    except TransactionServiceException, ex:
7859 
      result.ex = ex
7860 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7861 
    result.write(oprot)
7862 
    oprot.writeMessageEnd()
7863 
    oprot.trans.flush()
7864 
 
4285 rajveer 7865 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7866 
    args = acceptOrdersForItemId_args()
7867 
    args.read(iprot)
7868 
    iprot.readMessageEnd()
7869 
    result = acceptOrdersForItemId_result()
7870 
    try:
7871 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7872 
    except TransactionServiceException, ex:
7873 
      result.ex = ex
7874 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7875 
    result.write(oprot)
7876 
    oprot.writeMessageEnd()
7877 
    oprot.trans.flush()
4259 anupam.sin 7878 
 
4303 rajveer 7879 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7880 
    args = markOrdersAsPORaised_args()
7881 
    args.read(iprot)
7882 
    iprot.readMessageEnd()
7883 
    result = markOrdersAsPORaised_result()
7884 
    try:
4369 rajveer 7885 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7886 
    except TransactionServiceException, ex:
7887 
      result.ex = ex
7888 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7889 
    result.write(oprot)
7890 
    oprot.writeMessageEnd()
7891 
    oprot.trans.flush()
4285 rajveer 7892 
 
4303 rajveer 7893 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7894 
    args = markOrdersAsReversalInitiated_args()
7895 
    args.read(iprot)
7896 
    iprot.readMessageEnd()
7897 
    result = markOrdersAsReversalInitiated_result()
7898 
    try:
4369 rajveer 7899 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7900 
    except TransactionServiceException, ex:
7901 
      result.ex = ex
7902 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7903 
    result.write(oprot)
7904 
    oprot.writeMessageEnd()
7905 
    oprot.trans.flush()
7906 
 
7907 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7908 
    args = markOrdersAsNotAvailabke_args()
7909 
    args.read(iprot)
7910 
    iprot.readMessageEnd()
7911 
    result = markOrdersAsNotAvailabke_result()
7912 
    try:
4369 rajveer 7913 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7914 
    except TransactionServiceException, ex:
7915 
      result.ex = ex
7916 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7917 
    result.write(oprot)
7918 
    oprot.writeMessageEnd()
7919 
    oprot.trans.flush()
7920 
 
4369 rajveer 7921 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7922 
    args = markOrdersAsTimeout_args()
7923 
    args.read(iprot)
7924 
    iprot.readMessageEnd()
7925 
    result = markOrdersAsTimeout_result()
7926 
    try:
7927 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7928 
    except TransactionServiceException, ex:
7929 
      result.ex = ex
7930 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7931 
    result.write(oprot)
7932 
    oprot.writeMessageEnd()
7933 
    oprot.trans.flush()
4303 rajveer 7934 
 
4662 rajveer 7935 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7936 
    args = markOrderAsLostInTransit_args()
7937 
    args.read(iprot)
7938 
    iprot.readMessageEnd()
7939 
    result = markOrderAsLostInTransit_result()
7940 
    try:
7941 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7942 
    except TransactionServiceException, ex:
7943 
      result.ex = ex
7944 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7945 
    result.write(oprot)
7946 
    oprot.writeMessageEnd()
7947 
    oprot.trans.flush()
7948 
 
4386 anupam.sin 7949 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7950 
    args = getOrderForAwb_args()
7951 
    args.read(iprot)
7952 
    iprot.readMessageEnd()
7953 
    result = getOrderForAwb_result()
7954 
    try:
7955 
      result.success = self._handler.getOrderForAwb(args.awb)
7956 
    except TransactionServiceException, ex:
7957 
      result.ex = ex
7958 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7959 
    result.write(oprot)
7960 
    oprot.writeMessageEnd()
7961 
    oprot.trans.flush()
4369 rajveer 7962 
 
4506 phani.kuma 7963 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7964 
    args = getOrdersForProviderForStatus_args()
7965 
    args.read(iprot)
7966 
    iprot.readMessageEnd()
7967 
    result = getOrdersForProviderForStatus_result()
7968 
    try:
4910 phani.kuma 7969 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7970 
    except TransactionServiceException, ex:
7971 
      result.ex = ex
7972 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7973 
    result.write(oprot)
7974 
    oprot.writeMessageEnd()
7975 
    oprot.trans.flush()
4386 anupam.sin 7976 
 
4600 varun.gupt 7977 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7978 
    args = getBilledOrdersForVendor_args()
7979 
    args.read(iprot)
7980 
    iprot.readMessageEnd()
7981 
    result = getBilledOrdersForVendor_result()
7982 
    try:
7983 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7984 
    except TransactionServiceException, ex:
7985 
      result.ex = ex
7986 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7987 
    result.write(oprot)
7988 
    oprot.writeMessageEnd()
7989 
    oprot.trans.flush()
4506 phani.kuma 7990 
 
4607 rajveer 7991 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7992 
    args = getSlippedSippingDateOrders_args()
7993 
    args.read(iprot)
7994 
    iprot.readMessageEnd()
7995 
    result = getSlippedSippingDateOrders_result()
7996 
    try:
7997 
      result.success = self._handler.getSlippedSippingDateOrders()
7998 
    except TransactionServiceException, ex:
7999 
      result.ex = ex
8000 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8001 
    result.write(oprot)
8002 
    oprot.writeMessageEnd()
8003 
    oprot.trans.flush()
8004 
 
4709 rajveer 8005 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8006 
    args = getCancelledOrders_args()
8007 
    args.read(iprot)
8008 
    iprot.readMessageEnd()
8009 
    result = getCancelledOrders_result()
8010 
    try:
8011 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8012 
    except TransactionServiceException, ex:
8013 
      result.ex = ex
8014 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8015 
    result.write(oprot)
8016 
    oprot.writeMessageEnd()
8017 
    oprot.trans.flush()
8018 
 
4600 varun.gupt 8019 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8020 
    args = saveBluedartSettlements_args()
8021 
    args.read(iprot)
8022 
    iprot.readMessageEnd()
8023 
    result = saveBluedartSettlements_result()
8024 
    try:
8025 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8026 
    except TransactionServiceException, ex:
8027 
      result.ex = ex
8028 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8029 
    result.write(oprot)
8030 
    oprot.writeMessageEnd()
8031 
    oprot.trans.flush()
8032 
 
8033 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8034 
    args = savePaymentSettlements_args()
8035 
    args.read(iprot)
8036 
    iprot.readMessageEnd()
8037 
    result = savePaymentSettlements_result()
8038 
    try:
4905 varun.gupt 8039 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8040 
    except TransactionServiceException, ex:
8041 
      result.ex = ex
8042 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8043 
    result.write(oprot)
8044 
    oprot.writeMessageEnd()
8045 
    oprot.trans.flush()
8046 
 
8047 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8048 
    args = saveEBSSettlementSummary_args()
8049 
    args.read(iprot)
8050 
    iprot.readMessageEnd()
8051 
    result = saveEBSSettlementSummary_result()
8052 
    try:
8053 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8054 
    except TransactionServiceException, ex:
8055 
      result.ex = ex
8056 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8057 
    result.write(oprot)
8058 
    oprot.writeMessageEnd()
8059 
    oprot.trans.flush()
8060 
 
5386 phani.kuma 8061 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8062 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8063 
    args.read(iprot)
8064 
    iprot.readMessageEnd()
5386 phani.kuma 8065 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8066 
    try:
5386 phani.kuma 8067 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8068 
    except TransactionServiceException, ex:
8069 
      result.ex = ex
5386 phani.kuma 8070 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8071 
    result.write(oprot)
8072 
    oprot.writeMessageEnd()
8073 
    oprot.trans.flush()
8074 
 
5386 phani.kuma 8075 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8076 
    args = getSettlementForCod_args()
8077 
    args.read(iprot)
8078 
    iprot.readMessageEnd()
8079 
    result = getSettlementForCod_result()
8080 
    try:
8081 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8082 
    except TransactionServiceException, ex:
8083 
      result.ex = ex
8084 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8085 
    result.write(oprot)
8086 
    oprot.writeMessageEnd()
8087 
    oprot.trans.flush()
8088 
 
4600 varun.gupt 8089 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8090 
    args = getEBSSettlementSummaries_args()
8091 
    args.read(iprot)
8092 
    iprot.readMessageEnd()
8093 
    result = getEBSSettlementSummaries_result()
8094 
    try:
8095 
      result.success = self._handler.getEBSSettlementSummaries()
8096 
    except TransactionServiceException, ex:
8097 
      result.ex = ex
8098 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8099 
    result.write(oprot)
8100 
    oprot.writeMessageEnd()
8101 
    oprot.trans.flush()
8102 
 
8103 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8104 
    args = markEBSSettlementUploaded_args()
8105 
    args.read(iprot)
8106 
    iprot.readMessageEnd()
8107 
    result = markEBSSettlementUploaded_result()
8108 
    try:
8109 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8110 
    except TransactionServiceException, ex:
8111 
      result.ex = ex
8112 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8113 
    result.write(oprot)
8114 
    oprot.writeMessageEnd()
8115 
    oprot.trans.flush()
8116 
 
8117 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8118 
    args = getEBSSettlementDate_args()
8119 
    args.read(iprot)
8120 
    iprot.readMessageEnd()
8121 
    result = getEBSSettlementDate_result()
8122 
    try:
8123 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8124 
    except TransactionServiceException, ex:
8125 
      result.ex = ex
8126 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8127 
    result.write(oprot)
8128 
    oprot.writeMessageEnd()
8129 
    oprot.trans.flush()
8130 
 
4715 varun.gupt 8131 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8132 
    args = getSettlementsByDate_args()
8133 
    args.read(iprot)
8134 
    iprot.readMessageEnd()
8135 
    result = getSettlementsByDate_result()
8136 
    try:
8137 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8138 
    except TransactionServiceException, ex:
8139 
      result.ex = ex
8140 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8141 
    result.write(oprot)
8142 
    oprot.writeMessageEnd()
8143 
    oprot.trans.flush()
4600 varun.gupt 8144 
 
4715 varun.gupt 8145 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8146 
    args = getReshippedOrderIds_args()
8147 
    args.read(iprot)
8148 
    iprot.readMessageEnd()
8149 
    result = getReshippedOrderIds_result()
8150 
    try:
8151 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8152 
    except TransactionServiceException, ex:
8153 
      result.ex = ex
8154 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8155 
    result.write(oprot)
8156 
    oprot.writeMessageEnd()
8157 
    oprot.trans.flush()
8158 
 
5481 phani.kuma 8159 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8160 
    args = getBilledOrders_args()
4875 varun.gupt 8161 
    args.read(iprot)
8162 
    iprot.readMessageEnd()
5481 phani.kuma 8163 
    result = getBilledOrders_result()
4875 varun.gupt 8164 
    try:
5481 phani.kuma 8165 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8166 
    except TransactionServiceException, ex:
8167 
      result.ex = ex
5481 phani.kuma 8168 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8169 
    result.write(oprot)
8170 
    oprot.writeMessageEnd()
8171 
    oprot.trans.flush()
4757 mandeep.dh 8172 
 
5031 varun.gupt 8173 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8174 
    args = getStatusDistributionOfOrders_args()
8175 
    args.read(iprot)
8176 
    iprot.readMessageEnd()
8177 
    result = getStatusDistributionOfOrders_result()
8178 
    try:
8179 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8180 
    except TransactionServiceException, ex:
8181 
      result.ex = ex
8182 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8183 
    result.write(oprot)
8184 
    oprot.writeMessageEnd()
8185 
    oprot.trans.flush()
4875 varun.gupt 8186 
 
5067 varun.gupt 8187 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8188 
    args = getOrderIdsForStatus_args()
8189 
    args.read(iprot)
8190 
    iprot.readMessageEnd()
8191 
    result = getOrderIdsForStatus_result()
8192 
    try:
8193 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8194 
    except TransactionServiceException, ex:
8195 
      result.ex = ex
8196 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
5031 varun.gupt 8200 
 
5348 anupam.sin 8201 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8202 
    args = updateCODAgent_args()
8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
8205 
    result = updateCODAgent_result()
8206 
    try:
8207 
      self._handler.updateCODAgent(args.agent, args.orderId)
8208 
    except TransactionServiceException, ex:
8209 
      result.ex = ex
8210 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
5099 varun.gupt 8215 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8216 
    args = updateOrderAsPaidToVendor_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = updateOrderAsPaidToVendor_result()
8220 
    try:
8221 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8222 
    except TransactionServiceException, ex:
8223 
      result.ex = ex
8224 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
5067 varun.gupt 8228 
 
5386 phani.kuma 8229 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8230 
    args = updateOrderOnlyAsPaidToVendor_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = updateOrderOnlyAsPaidToVendor_result()
8234 
    try:
8235 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8236 
    except TransactionServiceException, ex:
8237 
      result.ex = ex
8238 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8239 
    result.write(oprot)
8240 
    oprot.writeMessageEnd()
8241 
    oprot.trans.flush()
8242 
 
5208 varun.gupt 8243 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8244 
    args = getRefundedOrdersMarkedPaid_args()
8245 
    args.read(iprot)
8246 
    iprot.readMessageEnd()
8247 
    result = getRefundedOrdersMarkedPaid_result()
8248 
    try:
8249 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8250 
    except TransactionServiceException, ex:
8251 
      result.ex = ex
8252 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
5099 varun.gupt 8256 
 
5447 anupam.sin 8257 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8258 
    args = getAllVerificationAgents_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = getAllVerificationAgents_result()
8262 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8263 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8264 
    result.write(oprot)
8265 
    oprot.writeMessageEnd()
8266 
    oprot.trans.flush()
5208 varun.gupt 8267 
 
5527 anupam.sin 8268 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8269 
    args = getAllAttributesForOrderId_args()
8270 
    args.read(iprot)
8271 
    iprot.readMessageEnd()
8272 
    result = getAllAttributesForOrderId_result()
8273 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8274 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8275 
    result.write(oprot)
8276 
    oprot.writeMessageEnd()
8277 
    oprot.trans.flush()
5447 anupam.sin 8278 
 
5676 rajveer 8279 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8280 
    args = setOrderAttributes_args()
8281 
    args.read(iprot)
8282 
    iprot.readMessageEnd()
8283 
    result = setOrderAttributes_result()
8284 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8285 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8286 
    result.write(oprot)
8287 
    oprot.writeMessageEnd()
8288 
    oprot.trans.flush()
8289 
 
5527 anupam.sin 8290 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8291 
    args = setOrderAttributeForTransaction_args()
8292 
    args.read(iprot)
8293 
    iprot.readMessageEnd()
8294 
    result = setOrderAttributeForTransaction_result()
8295 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8296 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8297 
    result.write(oprot)
8298 
    oprot.writeMessageEnd()
8299 
    oprot.trans.flush()
8300 
 
5553 rajveer 8301 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8302 
    args = getReceivePendingOrders_args()
8303 
    args.read(iprot)
8304 
    iprot.readMessageEnd()
8305 
    result = getReceivePendingOrders_result()
8306 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8307 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8308 
    result.write(oprot)
8309 
    oprot.writeMessageEnd()
8310 
    oprot.trans.flush()
5527 anupam.sin 8311 
 
5553 rajveer 8312 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8313 
    args = getReceivedAtStoreOrders_args()
8314 
    args.read(iprot)
8315 
    iprot.readMessageEnd()
8316 
    result = getReceivedAtStoreOrders_result()
8317 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8318 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8319 
    result.write(oprot)
8320 
    oprot.writeMessageEnd()
8321 
    oprot.trans.flush()
8322 
 
5713 rajveer 8323 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8324 
    args = getOrdersCollectionAtStore_args()
8325 
    args.read(iprot)
8326 
    iprot.readMessageEnd()
8327 
    result = getOrdersCollectionAtStore_result()
8328 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8329 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8330 
    result.write(oprot)
8331 
    oprot.writeMessageEnd()
8332 
    oprot.trans.flush()
8333 
 
5833 rajveer 8334 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8335 
    args = getOrderAttributeValue_args()
8336 
    args.read(iprot)
8337 
    iprot.readMessageEnd()
8338 
    result = getOrderAttributeValue_result()
8339 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8340 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8341 
    result.write(oprot)
8342 
    oprot.writeMessageEnd()
8343 
    oprot.trans.flush()
8344 
 
6019 rajveer 8345 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8346 
    args = changeJacketNumber_args()
8347 
    args.read(iprot)
8348 
    iprot.readMessageEnd()
8349 
    result = changeJacketNumber_result()
8350 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8351 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8352 
    result.write(oprot)
8353 
    oprot.writeMessageEnd()
8354 
    oprot.trans.flush()
8355 
 
8356 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8357 
    args = markOrderAsRtoInTransit_args()
8358 
    args.read(iprot)
8359 
    iprot.readMessageEnd()
8360 
    result = markOrderAsRtoInTransit_result()
8361 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8362 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8363 
    result.write(oprot)
8364 
    oprot.writeMessageEnd()
8365 
    oprot.trans.flush()
8366 
 
5593 mandeep.dh 8367 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8368 
    args = acceptOrderForItem_args()
8369 
    args.read(iprot)
8370 
    iprot.readMessageEnd()
8371 
    result = acceptOrderForItem_result()
8372 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8373 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8374 
    result.write(oprot)
8375 
    oprot.writeMessageEnd()
8376 
    oprot.trans.flush()
5553 rajveer 8377 
 
6000 mandeep.dh 8378 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8379 
    args = createRechargeOrder_args()
8380 
    args.read(iprot)
8381 
    iprot.readMessageEnd()
8382 
    result = createRechargeOrder_result()
8383 
    try:
8384 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8385 
    except TransactionServiceException, ex:
8386 
      result.ex = ex
8387 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8388 
    result.write(oprot)
8389 
    oprot.writeMessageEnd()
8390 
    oprot.trans.flush()
5593 mandeep.dh 8391 
 
6031 rajveer 8392 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8393 
    args = getRechargeOrder_args()
8394 
    args.read(iprot)
8395 
    iprot.readMessageEnd()
8396 
    result = getRechargeOrder_result()
8397 
    try:
8398 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8399 
    except TransactionServiceException, ex:
8400 
      result.ex = ex
8401 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8402 
    result.write(oprot)
8403 
    oprot.writeMessageEnd()
8404 
    oprot.trans.flush()
8405 
 
8406 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8407 
    args = getRechargeOrders_args()
8408 
    args.read(iprot)
8409 
    iprot.readMessageEnd()
8410 
    result = getRechargeOrders_result()
8411 
    result.success = self._handler.getRechargeOrders(args.userId)
8412 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8413 
    result.write(oprot)
8414 
    oprot.writeMessageEnd()
8415 
    oprot.trans.flush()
8416 
 
6000 mandeep.dh 8417 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8418 
    args = updateRechargeOrderStatus_args()
8419 
    args.read(iprot)
8420 
    iprot.readMessageEnd()
8421 
    result = updateRechargeOrderStatus_result()
8422 
    try:
6031 rajveer 8423 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8424 
    except TransactionServiceException, ex:
8425 
      result.ex = ex
8426 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8427 
    result.write(oprot)
8428 
    oprot.writeMessageEnd()
8429 
    oprot.trans.flush()
8430 
 
8431 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8432 
    args = activateRechargeTxn_args()
8433 
    args.read(iprot)
8434 
    iprot.readMessageEnd()
8435 
    result = activateRechargeTxn_result()
8436 
    try:
6031 rajveer 8437 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8438 
    except TransactionServiceException, ex:
8439 
      result.ex = ex
8440 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8441 
    result.write(oprot)
8442 
    oprot.writeMessageEnd()
8443 
    oprot.trans.flush()
8444 
 
6031 rajveer 8445 
  def process_getUserWallet(self, seqid, iprot, oprot):
8446 
    args = getUserWallet_args()
6000 mandeep.dh 8447 
    args.read(iprot)
8448 
    iprot.readMessageEnd()
6031 rajveer 8449 
    result = getUserWallet_result()
8450 
    result.success = self._handler.getUserWallet(args.userId)
8451 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8452 
    result.write(oprot)
8453 
    oprot.writeMessageEnd()
8454 
    oprot.trans.flush()
8455 
 
6031 rajveer 8456 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8457 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8458 
    args.read(iprot)
8459 
    iprot.readMessageEnd()
6031 rajveer 8460 
    result = getUserWalletHistory_result()
8461 
    result.success = self._handler.getUserWalletHistory(args.userId)
8462 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8463 
    result.write(oprot)
8464 
    oprot.writeMessageEnd()
8465 
    oprot.trans.flush()
8466 
 
6050 anupam.sin 8467 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8468 
    args = getRechargeOrdersForTransaction_args()
8469 
    args.read(iprot)
8470 
    iprot.readMessageEnd()
8471 
    result = getRechargeOrdersForTransaction_result()
8472 
    try:
8473 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8474 
    except TransactionServiceException, ex:
8475 
      result.ex = ex
8476 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8477 
    result.write(oprot)
8478 
    oprot.writeMessageEnd()
8479 
    oprot.trans.flush()
8480 
 
6048 rajveer 8481 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8482 
    args = getServiceProviders_args()
8483 
    args.read(iprot)
8484 
    iprot.readMessageEnd()
8485 
    result = getServiceProviders_result()
6206 rajveer 8486 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8487 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8488 
    result.write(oprot)
8489 
    oprot.writeMessageEnd()
8490 
    oprot.trans.flush()
6000 mandeep.dh 8491 
 
6048 rajveer 8492 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8493 
    args = getServiceProviderForDevice_args()
8494 
    args.read(iprot)
8495 
    iprot.readMessageEnd()
8496 
    result = getServiceProviderForDevice_result()
6049 rajveer 8497 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8498 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8499 
    result.write(oprot)
8500 
    oprot.writeMessageEnd()
8501 
    oprot.trans.flush()
8502 
 
6269 rajveer 8503 
  def process_validateRecharge(self, seqid, iprot, oprot):
8504 
    args = validateRecharge_args()
8505 
    args.read(iprot)
8506 
    iprot.readMessageEnd()
8507 
    result = validateRecharge_result()
6336 anupam.sin 8508 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId)
6269 rajveer 8509 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8510 
    result.write(oprot)
8511 
    oprot.writeMessageEnd()
8512 
    oprot.trans.flush()
8513 
 
6094 rajveer 8514 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8515 
    args = getRechargeOrdersForDevice_args()
8516 
    args.read(iprot)
8517 
    iprot.readMessageEnd()
8518 
    result = getRechargeOrdersForDevice_result()
8519 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8520 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8521 
    result.write(oprot)
8522 
    oprot.writeMessageEnd()
8523 
    oprot.trans.flush()
6048 rajveer 8524 
 
6094 rajveer 8525 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8526 
    args = addAmountToWallet_args()
8527 
    args.read(iprot)
8528 
    iprot.readMessageEnd()
8529 
    result = addAmountToWallet_result()
8530 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8531 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8532 
    result.write(oprot)
8533 
    oprot.writeMessageEnd()
8534 
    oprot.trans.flush()
8535 
 
6188 rajveer 8536 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8537 
    args = getRechargeStatistics_args()
8538 
    args.read(iprot)
8539 
    iprot.readMessageEnd()
8540 
    result = getRechargeStatistics_result()
8541 
    result.success = self._handler.getRechargeStatistics()
8542 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8543 
    result.write(oprot)
8544 
    oprot.writeMessageEnd()
8545 
    oprot.trans.flush()
8546 
 
6154 rajveer 8547 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8548 
    args = getRechargeOrdersForStatus_args()
8549 
    args.read(iprot)
8550 
    iprot.readMessageEnd()
8551 
    result = getRechargeOrdersForStatus_result()
8552 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8553 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8554 
    result.write(oprot)
8555 
    oprot.writeMessageEnd()
8556 
    oprot.trans.flush()
6094 rajveer 8557 
 
6159 rajveer 8558 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8559 
    args = getPlansForOperator_args()
8560 
    args.read(iprot)
8561 
    iprot.readMessageEnd()
8562 
    result = getPlansForOperator_result()
8563 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8564 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8565 
    result.write(oprot)
8566 
    oprot.writeMessageEnd()
8567 
    oprot.trans.flush()
6154 rajveer 8568 
 
6289 anupam.sin 8569 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8570 
    args = getRechargeDenominations_args()
8571 
    args.read(iprot)
8572 
    iprot.readMessageEnd()
8573 
    result = getRechargeDenominations_result()
8574 
    try:
6307 anupam.sin 8575 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8576 
    except TransactionServiceException, ex:
8577 
      result.ex = ex
8578 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8579 
    result.write(oprot)
8580 
    oprot.writeMessageEnd()
8581 
    oprot.trans.flush()
6159 rajveer 8582 
 
6371 rajveer 8583 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8584 
    args = updateAvailabilityStatus_args()
8585 
    args.read(iprot)
8586 
    iprot.readMessageEnd()
8587 
    result = updateAvailabilityStatus_result()
8588 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8589 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8590 
    result.write(oprot)
8591 
    oprot.writeMessageEnd()
8592 
    oprot.trans.flush()
6289 anupam.sin 8593 
 
6389 rajveer 8594 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8595 
    args = getAvailableEmiSchemes_args()
8596 
    args.read(iprot)
8597 
    iprot.readMessageEnd()
8598 
    result = getAvailableEmiSchemes_result()
8599 
    result.success = self._handler.getAvailableEmiSchemes()
8600 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8601 
    result.write(oprot)
8602 
    oprot.writeMessageEnd()
8603 
    oprot.trans.flush()
6371 rajveer 8604 
 
6389 rajveer 8605 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8606 
    args = getMiscCharges_args()
8607 
    args.read(iprot)
8608 
    iprot.readMessageEnd()
8609 
    result = getMiscCharges_result()
8610 
    result.success = self._handler.getMiscCharges(args.transactionId)
8611 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8612 
    result.write(oprot)
8613 
    oprot.writeMessageEnd()
8614 
    oprot.trans.flush()
8615 
 
6507 anupam.sin 8616 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8617 
    args = refundRechargeOrder_args()
8618 
    args.read(iprot)
8619 
    iprot.readMessageEnd()
8620 
    result = refundRechargeOrder_result()
8621 
    try:
8622 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8623 
    except TransactionServiceException, ex:
8624 
      result.ex = ex
8625 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8626 
    result.write(oprot)
8627 
    oprot.writeMessageEnd()
8628 
    oprot.trans.flush()
6389 rajveer 8629 
 
6507 anupam.sin 8630 
 
94 ashish 8631 
# HELPER FUNCTIONS AND STRUCTURES
8632 
 
8633 
class createTransaction_args:
8634 
  """
8635 
  Attributes:
8636 
   - transaction
8637 
  """
8638 
 
8639 
  thrift_spec = (
8640 
    None, # 0
8641 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8642 
  )
8643 
 
8644 
  def __init__(self, transaction=None,):
8645 
    self.transaction = transaction
8646 
 
8647 
  def read(self, iprot):
8648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8650 
      return
8651 
    iprot.readStructBegin()
8652 
    while True:
8653 
      (fname, ftype, fid) = iprot.readFieldBegin()
8654 
      if ftype == TType.STOP:
8655 
        break
8656 
      if fid == 1:
8657 
        if ftype == TType.STRUCT:
8658 
          self.transaction = Transaction()
8659 
          self.transaction.read(iprot)
8660 
        else:
8661 
          iprot.skip(ftype)
8662 
      else:
8663 
        iprot.skip(ftype)
8664 
      iprot.readFieldEnd()
8665 
    iprot.readStructEnd()
8666 
 
8667 
  def write(self, oprot):
8668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8670 
      return
8671 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8672 
    if self.transaction is not None:
94 ashish 8673 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8674 
      self.transaction.write(oprot)
8675 
      oprot.writeFieldEnd()
8676 
    oprot.writeFieldStop()
8677 
    oprot.writeStructEnd()
8678 
 
3431 rajveer 8679 
  def validate(self):
8680 
    return
8681 
 
8682 
 
94 ashish 8683 
  def __repr__(self):
8684 
    L = ['%s=%r' % (key, value)
8685 
      for key, value in self.__dict__.iteritems()]
8686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8687 
 
8688 
  def __eq__(self, other):
8689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8690 
 
8691 
  def __ne__(self, other):
8692 
    return not (self == other)
8693 
 
8694 
class createTransaction_result:
8695 
  """
8696 
  Attributes:
132 ashish 8697 
   - success
94 ashish 8698 
   - ex
8699 
  """
8700 
 
8701 
  thrift_spec = (
132 ashish 8702 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8704 
  )
8705 
 
132 ashish 8706 
  def __init__(self, success=None, ex=None,):
8707 
    self.success = success
94 ashish 8708 
    self.ex = ex
8709 
 
8710 
  def read(self, iprot):
8711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8713 
      return
8714 
    iprot.readStructBegin()
8715 
    while True:
8716 
      (fname, ftype, fid) = iprot.readFieldBegin()
8717 
      if ftype == TType.STOP:
8718 
        break
132 ashish 8719 
      if fid == 0:
8720 
        if ftype == TType.I64:
8721 
          self.success = iprot.readI64();
8722 
        else:
8723 
          iprot.skip(ftype)
8724 
      elif fid == 1:
94 ashish 8725 
        if ftype == TType.STRUCT:
8726 
          self.ex = TransactionServiceException()
8727 
          self.ex.read(iprot)
8728 
        else:
8729 
          iprot.skip(ftype)
8730 
      else:
8731 
        iprot.skip(ftype)
8732 
      iprot.readFieldEnd()
8733 
    iprot.readStructEnd()
8734 
 
8735 
  def write(self, oprot):
8736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8738 
      return
8739 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8740 
    if self.success is not None:
132 ashish 8741 
      oprot.writeFieldBegin('success', TType.I64, 0)
8742 
      oprot.writeI64(self.success)
8743 
      oprot.writeFieldEnd()
3431 rajveer 8744 
    if self.ex is not None:
94 ashish 8745 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8746 
      self.ex.write(oprot)
8747 
      oprot.writeFieldEnd()
8748 
    oprot.writeFieldStop()
8749 
    oprot.writeStructEnd()
8750 
 
3431 rajveer 8751 
  def validate(self):
8752 
    return
8753 
 
8754 
 
94 ashish 8755 
  def __repr__(self):
8756 
    L = ['%s=%r' % (key, value)
8757 
      for key, value in self.__dict__.iteritems()]
8758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8759 
 
8760 
  def __eq__(self, other):
8761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8762 
 
8763 
  def __ne__(self, other):
8764 
    return not (self == other)
8765 
 
8766 
class getTransaction_args:
8767 
  """
8768 
  Attributes:
8769 
   - id
8770 
  """
8771 
 
8772 
  thrift_spec = (
8773 
    None, # 0
8774 
    (1, TType.I64, 'id', None, None, ), # 1
8775 
  )
8776 
 
8777 
  def __init__(self, id=None,):
8778 
    self.id = id
8779 
 
8780 
  def read(self, iprot):
8781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8783 
      return
8784 
    iprot.readStructBegin()
8785 
    while True:
8786 
      (fname, ftype, fid) = iprot.readFieldBegin()
8787 
      if ftype == TType.STOP:
8788 
        break
8789 
      if fid == 1:
8790 
        if ftype == TType.I64:
8791 
          self.id = iprot.readI64();
8792 
        else:
8793 
          iprot.skip(ftype)
8794 
      else:
8795 
        iprot.skip(ftype)
8796 
      iprot.readFieldEnd()
8797 
    iprot.readStructEnd()
8798 
 
8799 
  def write(self, oprot):
8800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8802 
      return
8803 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8804 
    if self.id is not None:
94 ashish 8805 
      oprot.writeFieldBegin('id', TType.I64, 1)
8806 
      oprot.writeI64(self.id)
8807 
      oprot.writeFieldEnd()
8808 
    oprot.writeFieldStop()
8809 
    oprot.writeStructEnd()
8810 
 
3431 rajveer 8811 
  def validate(self):
8812 
    return
8813 
 
8814 
 
94 ashish 8815 
  def __repr__(self):
8816 
    L = ['%s=%r' % (key, value)
8817 
      for key, value in self.__dict__.iteritems()]
8818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8819 
 
8820 
  def __eq__(self, other):
8821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8822 
 
8823 
  def __ne__(self, other):
8824 
    return not (self == other)
8825 
 
8826 
class getTransaction_result:
8827 
  """
8828 
  Attributes:
8829 
   - success
8830 
   - ex
8831 
  """
8832 
 
8833 
  thrift_spec = (
8834 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8836 
  )
8837 
 
8838 
  def __init__(self, success=None, ex=None,):
8839 
    self.success = success
8840 
    self.ex = ex
8841 
 
8842 
  def read(self, iprot):
8843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8845 
      return
8846 
    iprot.readStructBegin()
8847 
    while True:
8848 
      (fname, ftype, fid) = iprot.readFieldBegin()
8849 
      if ftype == TType.STOP:
8850 
        break
8851 
      if fid == 0:
8852 
        if ftype == TType.STRUCT:
8853 
          self.success = Transaction()
8854 
          self.success.read(iprot)
8855 
        else:
8856 
          iprot.skip(ftype)
8857 
      elif fid == 1:
8858 
        if ftype == TType.STRUCT:
8859 
          self.ex = TransactionServiceException()
8860 
          self.ex.read(iprot)
8861 
        else:
8862 
          iprot.skip(ftype)
8863 
      else:
8864 
        iprot.skip(ftype)
8865 
      iprot.readFieldEnd()
8866 
    iprot.readStructEnd()
8867 
 
8868 
  def write(self, oprot):
8869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8871 
      return
8872 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8873 
    if self.success is not None:
94 ashish 8874 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8875 
      self.success.write(oprot)
8876 
      oprot.writeFieldEnd()
3431 rajveer 8877 
    if self.ex is not None:
94 ashish 8878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8879 
      self.ex.write(oprot)
8880 
      oprot.writeFieldEnd()
8881 
    oprot.writeFieldStop()
8882 
    oprot.writeStructEnd()
8883 
 
3431 rajveer 8884 
  def validate(self):
8885 
    return
8886 
 
8887 
 
94 ashish 8888 
  def __repr__(self):
8889 
    L = ['%s=%r' % (key, value)
8890 
      for key, value in self.__dict__.iteritems()]
8891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8892 
 
8893 
  def __eq__(self, other):
8894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8895 
 
8896 
  def __ne__(self, other):
8897 
    return not (self == other)
8898 
 
8899 
class getTransactionsForCustomer_args:
8900 
  """
8901 
  Attributes:
8902 
   - customerId
8903 
   - from_date
8904 
   - to_date
8905 
   - status
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    None, # 0
8910 
    (1, TType.I64, 'customerId', None, None, ), # 1
8911 
    (2, TType.I64, 'from_date', None, None, ), # 2
8912 
    (3, TType.I64, 'to_date', None, None, ), # 3
8913 
    (4, TType.I32, 'status', None, None, ), # 4
8914 
  )
8915 
 
8916 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8917 
    self.customerId = customerId
8918 
    self.from_date = from_date
8919 
    self.to_date = to_date
8920 
    self.status = status
8921 
 
8922 
  def read(self, iprot):
8923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8925 
      return
8926 
    iprot.readStructBegin()
8927 
    while True:
8928 
      (fname, ftype, fid) = iprot.readFieldBegin()
8929 
      if ftype == TType.STOP:
8930 
        break
8931 
      if fid == 1:
8932 
        if ftype == TType.I64:
8933 
          self.customerId = iprot.readI64();
8934 
        else:
8935 
          iprot.skip(ftype)
8936 
      elif fid == 2:
8937 
        if ftype == TType.I64:
8938 
          self.from_date = iprot.readI64();
8939 
        else:
8940 
          iprot.skip(ftype)
8941 
      elif fid == 3:
8942 
        if ftype == TType.I64:
8943 
          self.to_date = iprot.readI64();
8944 
        else:
8945 
          iprot.skip(ftype)
8946 
      elif fid == 4:
8947 
        if ftype == TType.I32:
8948 
          self.status = iprot.readI32();
8949 
        else:
8950 
          iprot.skip(ftype)
8951 
      else:
8952 
        iprot.skip(ftype)
8953 
      iprot.readFieldEnd()
8954 
    iprot.readStructEnd()
8955 
 
8956 
  def write(self, oprot):
8957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8959 
      return
8960 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8961 
    if self.customerId is not None:
94 ashish 8962 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8963 
      oprot.writeI64(self.customerId)
8964 
      oprot.writeFieldEnd()
3431 rajveer 8965 
    if self.from_date is not None:
94 ashish 8966 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8967 
      oprot.writeI64(self.from_date)
8968 
      oprot.writeFieldEnd()
3431 rajveer 8969 
    if self.to_date is not None:
94 ashish 8970 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8971 
      oprot.writeI64(self.to_date)
8972 
      oprot.writeFieldEnd()
3431 rajveer 8973 
    if self.status is not None:
94 ashish 8974 
      oprot.writeFieldBegin('status', TType.I32, 4)
8975 
      oprot.writeI32(self.status)
8976 
      oprot.writeFieldEnd()
8977 
    oprot.writeFieldStop()
8978 
    oprot.writeStructEnd()
8979 
 
3431 rajveer 8980 
  def validate(self):
8981 
    return
8982 
 
8983 
 
94 ashish 8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getTransactionsForCustomer_result:
8996 
  """
8997 
  Attributes:
8998 
   - success
8999 
   - ex
9000 
  """
9001 
 
9002 
  thrift_spec = (
9003 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9004 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9005 
  )
9006 
 
9007 
  def __init__(self, success=None, ex=None,):
9008 
    self.success = success
9009 
    self.ex = ex
9010 
 
9011 
  def read(self, iprot):
9012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9014 
      return
9015 
    iprot.readStructBegin()
9016 
    while True:
9017 
      (fname, ftype, fid) = iprot.readFieldBegin()
9018 
      if ftype == TType.STOP:
9019 
        break
9020 
      if fid == 0:
9021 
        if ftype == TType.LIST:
9022 
          self.success = []
6188 rajveer 9023 
          (_etype109, _size106) = iprot.readListBegin()
9024 
          for _i110 in xrange(_size106):
9025 
            _elem111 = Transaction()
9026 
            _elem111.read(iprot)
9027 
            self.success.append(_elem111)
94 ashish 9028 
          iprot.readListEnd()
9029 
        else:
9030 
          iprot.skip(ftype)
9031 
      elif fid == 1:
9032 
        if ftype == TType.STRUCT:
9033 
          self.ex = TransactionServiceException()
9034 
          self.ex.read(iprot)
9035 
        else:
9036 
          iprot.skip(ftype)
9037 
      else:
9038 
        iprot.skip(ftype)
9039 
      iprot.readFieldEnd()
9040 
    iprot.readStructEnd()
9041 
 
9042 
  def write(self, oprot):
9043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9045 
      return
9046 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9047 
    if self.success is not None:
94 ashish 9048 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9049 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9050 
      for iter112 in self.success:
9051 
        iter112.write(oprot)
94 ashish 9052 
      oprot.writeListEnd()
9053 
      oprot.writeFieldEnd()
3431 rajveer 9054 
    if self.ex is not None:
94 ashish 9055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9056 
      self.ex.write(oprot)
9057 
      oprot.writeFieldEnd()
9058 
    oprot.writeFieldStop()
9059 
    oprot.writeStructEnd()
9060 
 
3431 rajveer 9061 
  def validate(self):
9062 
    return
9063 
 
9064 
 
94 ashish 9065 
  def __repr__(self):
9066 
    L = ['%s=%r' % (key, value)
9067 
      for key, value in self.__dict__.iteritems()]
9068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9069 
 
9070 
  def __eq__(self, other):
9071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9072 
 
9073 
  def __ne__(self, other):
9074 
    return not (self == other)
9075 
 
132 ashish 9076 
class getTransactionsForShoppingCartId_args:
9077 
  """
9078 
  Attributes:
9079 
   - shoppingCartId
9080 
  """
9081 
 
9082 
  thrift_spec = (
9083 
    None, # 0
9084 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9085 
  )
9086 
 
9087 
  def __init__(self, shoppingCartId=None,):
9088 
    self.shoppingCartId = shoppingCartId
9089 
 
9090 
  def read(self, iprot):
9091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9093 
      return
9094 
    iprot.readStructBegin()
9095 
    while True:
9096 
      (fname, ftype, fid) = iprot.readFieldBegin()
9097 
      if ftype == TType.STOP:
9098 
        break
9099 
      if fid == 1:
9100 
        if ftype == TType.I64:
9101 
          self.shoppingCartId = iprot.readI64();
9102 
        else:
9103 
          iprot.skip(ftype)
9104 
      else:
9105 
        iprot.skip(ftype)
9106 
      iprot.readFieldEnd()
9107 
    iprot.readStructEnd()
9108 
 
9109 
  def write(self, oprot):
9110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9112 
      return
9113 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9114 
    if self.shoppingCartId is not None:
132 ashish 9115 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9116 
      oprot.writeI64(self.shoppingCartId)
9117 
      oprot.writeFieldEnd()
9118 
    oprot.writeFieldStop()
9119 
    oprot.writeStructEnd()
9120 
 
3431 rajveer 9121 
  def validate(self):
9122 
    return
9123 
 
9124 
 
132 ashish 9125 
  def __repr__(self):
9126 
    L = ['%s=%r' % (key, value)
9127 
      for key, value in self.__dict__.iteritems()]
9128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9129 
 
9130 
  def __eq__(self, other):
9131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9132 
 
9133 
  def __ne__(self, other):
9134 
    return not (self == other)
9135 
 
9136 
class getTransactionsForShoppingCartId_result:
9137 
  """
9138 
  Attributes:
9139 
   - success
9140 
   - ex
9141 
  """
9142 
 
9143 
  thrift_spec = (
9144 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9145 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9146 
  )
9147 
 
9148 
  def __init__(self, success=None, ex=None,):
9149 
    self.success = success
9150 
    self.ex = ex
9151 
 
9152 
  def read(self, iprot):
9153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9155 
      return
9156 
    iprot.readStructBegin()
9157 
    while True:
9158 
      (fname, ftype, fid) = iprot.readFieldBegin()
9159 
      if ftype == TType.STOP:
9160 
        break
9161 
      if fid == 0:
9162 
        if ftype == TType.LIST:
9163 
          self.success = []
6188 rajveer 9164 
          (_etype116, _size113) = iprot.readListBegin()
9165 
          for _i117 in xrange(_size113):
9166 
            _elem118 = Transaction()
9167 
            _elem118.read(iprot)
9168 
            self.success.append(_elem118)
132 ashish 9169 
          iprot.readListEnd()
9170 
        else:
9171 
          iprot.skip(ftype)
9172 
      elif fid == 1:
9173 
        if ftype == TType.STRUCT:
9174 
          self.ex = TransactionServiceException()
9175 
          self.ex.read(iprot)
9176 
        else:
9177 
          iprot.skip(ftype)
9178 
      else:
9179 
        iprot.skip(ftype)
9180 
      iprot.readFieldEnd()
9181 
    iprot.readStructEnd()
9182 
 
9183 
  def write(self, oprot):
9184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9186 
      return
9187 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9188 
    if self.success is not None:
132 ashish 9189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9191 
      for iter119 in self.success:
9192 
        iter119.write(oprot)
132 ashish 9193 
      oprot.writeListEnd()
9194 
      oprot.writeFieldEnd()
3431 rajveer 9195 
    if self.ex is not None:
132 ashish 9196 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9197 
      self.ex.write(oprot)
9198 
      oprot.writeFieldEnd()
9199 
    oprot.writeFieldStop()
9200 
    oprot.writeStructEnd()
9201 
 
3431 rajveer 9202 
  def validate(self):
9203 
    return
9204 
 
9205 
 
132 ashish 9206 
  def __repr__(self):
9207 
    L = ['%s=%r' % (key, value)
9208 
      for key, value in self.__dict__.iteritems()]
9209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9210 
 
9211 
  def __eq__(self, other):
9212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9213 
 
9214 
  def __ne__(self, other):
9215 
    return not (self == other)
9216 
 
94 ashish 9217 
class getTransactionStatus_args:
9218 
  """
9219 
  Attributes:
9220 
   - transactionId
9221 
  """
9222 
 
9223 
  thrift_spec = (
9224 
    None, # 0
9225 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9226 
  )
9227 
 
9228 
  def __init__(self, transactionId=None,):
9229 
    self.transactionId = transactionId
9230 
 
9231 
  def read(self, iprot):
9232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9234 
      return
9235 
    iprot.readStructBegin()
9236 
    while True:
9237 
      (fname, ftype, fid) = iprot.readFieldBegin()
9238 
      if ftype == TType.STOP:
9239 
        break
9240 
      if fid == 1:
9241 
        if ftype == TType.I64:
9242 
          self.transactionId = iprot.readI64();
9243 
        else:
9244 
          iprot.skip(ftype)
9245 
      else:
9246 
        iprot.skip(ftype)
9247 
      iprot.readFieldEnd()
9248 
    iprot.readStructEnd()
9249 
 
9250 
  def write(self, oprot):
9251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9253 
      return
9254 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9255 
    if self.transactionId is not None:
94 ashish 9256 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9257 
      oprot.writeI64(self.transactionId)
9258 
      oprot.writeFieldEnd()
9259 
    oprot.writeFieldStop()
9260 
    oprot.writeStructEnd()
9261 
 
3431 rajveer 9262 
  def validate(self):
9263 
    return
9264 
 
9265 
 
94 ashish 9266 
  def __repr__(self):
9267 
    L = ['%s=%r' % (key, value)
9268 
      for key, value in self.__dict__.iteritems()]
9269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9270 
 
9271 
  def __eq__(self, other):
9272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9273 
 
9274 
  def __ne__(self, other):
9275 
    return not (self == other)
9276 
 
9277 
class getTransactionStatus_result:
9278 
  """
9279 
  Attributes:
9280 
   - success
9281 
   - ex
9282 
  """
9283 
 
9284 
  thrift_spec = (
9285 
    (0, TType.I32, 'success', None, None, ), # 0
9286 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9287 
  )
9288 
 
9289 
  def __init__(self, success=None, ex=None,):
9290 
    self.success = success
9291 
    self.ex = ex
9292 
 
9293 
  def read(self, iprot):
9294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9296 
      return
9297 
    iprot.readStructBegin()
9298 
    while True:
9299 
      (fname, ftype, fid) = iprot.readFieldBegin()
9300 
      if ftype == TType.STOP:
9301 
        break
9302 
      if fid == 0:
9303 
        if ftype == TType.I32:
9304 
          self.success = iprot.readI32();
9305 
        else:
9306 
          iprot.skip(ftype)
9307 
      elif fid == 1:
9308 
        if ftype == TType.STRUCT:
9309 
          self.ex = TransactionServiceException()
9310 
          self.ex.read(iprot)
9311 
        else:
9312 
          iprot.skip(ftype)
9313 
      else:
9314 
        iprot.skip(ftype)
9315 
      iprot.readFieldEnd()
9316 
    iprot.readStructEnd()
9317 
 
9318 
  def write(self, oprot):
9319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9321 
      return
9322 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9323 
    if self.success is not None:
94 ashish 9324 
      oprot.writeFieldBegin('success', TType.I32, 0)
9325 
      oprot.writeI32(self.success)
9326 
      oprot.writeFieldEnd()
3431 rajveer 9327 
    if self.ex is not None:
94 ashish 9328 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9329 
      self.ex.write(oprot)
9330 
      oprot.writeFieldEnd()
9331 
    oprot.writeFieldStop()
9332 
    oprot.writeStructEnd()
9333 
 
3431 rajveer 9334 
  def validate(self):
9335 
    return
9336 
 
9337 
 
94 ashish 9338 
  def __repr__(self):
9339 
    L = ['%s=%r' % (key, value)
9340 
      for key, value in self.__dict__.iteritems()]
9341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9342 
 
9343 
  def __eq__(self, other):
9344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9345 
 
9346 
  def __ne__(self, other):
9347 
    return not (self == other)
9348 
 
9349 
class changeTransactionStatus_args:
9350 
  """
9351 
  Attributes:
9352 
   - transactionId
9353 
   - status
9354 
   - description
5527 anupam.sin 9355 
   - pickUp
9356 
   - orderType
94 ashish 9357 
  """
9358 
 
9359 
  thrift_spec = (
9360 
    None, # 0
9361 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9362 
    (2, TType.I32, 'status', None, None, ), # 2
9363 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9364 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9365 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9366 
  )
9367 
 
5527 anupam.sin 9368 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9369 
    self.transactionId = transactionId
9370 
    self.status = status
9371 
    self.description = description
5527 anupam.sin 9372 
    self.pickUp = pickUp
9373 
    self.orderType = orderType
94 ashish 9374 
 
9375 
  def read(self, iprot):
9376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9378 
      return
9379 
    iprot.readStructBegin()
9380 
    while True:
9381 
      (fname, ftype, fid) = iprot.readFieldBegin()
9382 
      if ftype == TType.STOP:
9383 
        break
9384 
      if fid == 1:
9385 
        if ftype == TType.I64:
9386 
          self.transactionId = iprot.readI64();
9387 
        else:
9388 
          iprot.skip(ftype)
9389 
      elif fid == 2:
9390 
        if ftype == TType.I32:
9391 
          self.status = iprot.readI32();
9392 
        else:
9393 
          iprot.skip(ftype)
9394 
      elif fid == 3:
9395 
        if ftype == TType.STRING:
9396 
          self.description = iprot.readString();
9397 
        else:
9398 
          iprot.skip(ftype)
5387 rajveer 9399 
      elif fid == 4:
5527 anupam.sin 9400 
        if ftype == TType.I64:
9401 
          self.pickUp = iprot.readI64();
5387 rajveer 9402 
        else:
9403 
          iprot.skip(ftype)
5527 anupam.sin 9404 
      elif fid == 5:
9405 
        if ftype == TType.I32:
9406 
          self.orderType = iprot.readI32();
9407 
        else:
9408 
          iprot.skip(ftype)
94 ashish 9409 
      else:
9410 
        iprot.skip(ftype)
9411 
      iprot.readFieldEnd()
9412 
    iprot.readStructEnd()
9413 
 
9414 
  def write(self, oprot):
9415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9417 
      return
9418 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9419 
    if self.transactionId is not None:
94 ashish 9420 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9421 
      oprot.writeI64(self.transactionId)
9422 
      oprot.writeFieldEnd()
3431 rajveer 9423 
    if self.status is not None:
94 ashish 9424 
      oprot.writeFieldBegin('status', TType.I32, 2)
9425 
      oprot.writeI32(self.status)
9426 
      oprot.writeFieldEnd()
3431 rajveer 9427 
    if self.description is not None:
94 ashish 9428 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9429 
      oprot.writeString(self.description)
9430 
      oprot.writeFieldEnd()
5527 anupam.sin 9431 
    if self.pickUp is not None:
9432 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9433 
      oprot.writeI64(self.pickUp)
5387 rajveer 9434 
      oprot.writeFieldEnd()
5527 anupam.sin 9435 
    if self.orderType is not None:
9436 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9437 
      oprot.writeI32(self.orderType)
9438 
      oprot.writeFieldEnd()
94 ashish 9439 
    oprot.writeFieldStop()
9440 
    oprot.writeStructEnd()
9441 
 
3431 rajveer 9442 
  def validate(self):
9443 
    return
9444 
 
9445 
 
94 ashish 9446 
  def __repr__(self):
9447 
    L = ['%s=%r' % (key, value)
9448 
      for key, value in self.__dict__.iteritems()]
9449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9450 
 
9451 
  def __eq__(self, other):
9452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9453 
 
9454 
  def __ne__(self, other):
9455 
    return not (self == other)
9456 
 
9457 
class changeTransactionStatus_result:
9458 
  """
9459 
  Attributes:
9460 
   - success
9461 
   - ex
9462 
  """
9463 
 
9464 
  thrift_spec = (
9465 
    (0, TType.BOOL, 'success', None, None, ), # 0
9466 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9467 
  )
9468 
 
9469 
  def __init__(self, success=None, ex=None,):
9470 
    self.success = success
9471 
    self.ex = ex
9472 
 
9473 
  def read(self, iprot):
9474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9476 
      return
9477 
    iprot.readStructBegin()
9478 
    while True:
9479 
      (fname, ftype, fid) = iprot.readFieldBegin()
9480 
      if ftype == TType.STOP:
9481 
        break
9482 
      if fid == 0:
9483 
        if ftype == TType.BOOL:
9484 
          self.success = iprot.readBool();
9485 
        else:
9486 
          iprot.skip(ftype)
9487 
      elif fid == 1:
9488 
        if ftype == TType.STRUCT:
9489 
          self.ex = TransactionServiceException()
9490 
          self.ex.read(iprot)
9491 
        else:
9492 
          iprot.skip(ftype)
9493 
      else:
9494 
        iprot.skip(ftype)
9495 
      iprot.readFieldEnd()
9496 
    iprot.readStructEnd()
9497 
 
9498 
  def write(self, oprot):
9499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9501 
      return
9502 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9503 
    if self.success is not None:
94 ashish 9504 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9505 
      oprot.writeBool(self.success)
9506 
      oprot.writeFieldEnd()
3431 rajveer 9507 
    if self.ex is not None:
94 ashish 9508 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9509 
      self.ex.write(oprot)
9510 
      oprot.writeFieldEnd()
9511 
    oprot.writeFieldStop()
9512 
    oprot.writeStructEnd()
9513 
 
3431 rajveer 9514 
  def validate(self):
9515 
    return
9516 
 
9517 
 
94 ashish 9518 
  def __repr__(self):
9519 
    L = ['%s=%r' % (key, value)
9520 
      for key, value in self.__dict__.iteritems()]
9521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9522 
 
9523 
  def __eq__(self, other):
9524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9525 
 
9526 
  def __ne__(self, other):
9527 
    return not (self == other)
9528 
 
1398 varun.gupt 9529 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9530 
  """
9531 
  Attributes:
9532 
   - transactionId
9533 
  """
9534 
 
9535 
  thrift_spec = (
9536 
    None, # 0
9537 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9538 
  )
9539 
 
9540 
  def __init__(self, transactionId=None,):
9541 
    self.transactionId = transactionId
9542 
 
9543 
  def read(self, iprot):
9544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9546 
      return
9547 
    iprot.readStructBegin()
9548 
    while True:
9549 
      (fname, ftype, fid) = iprot.readFieldBegin()
9550 
      if ftype == TType.STOP:
9551 
        break
9552 
      if fid == 1:
9553 
        if ftype == TType.I64:
9554 
          self.transactionId = iprot.readI64();
9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      else:
9558 
        iprot.skip(ftype)
9559 
      iprot.readFieldEnd()
9560 
    iprot.readStructEnd()
9561 
 
9562 
  def write(self, oprot):
9563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9565 
      return
1398 varun.gupt 9566 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9567 
    if self.transactionId is not None:
1382 varun.gupt 9568 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9569 
      oprot.writeI64(self.transactionId)
9570 
      oprot.writeFieldEnd()
9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
3431 rajveer 9574 
  def validate(self):
9575 
    return
9576 
 
9577 
 
1382 varun.gupt 9578 
  def __repr__(self):
9579 
    L = ['%s=%r' % (key, value)
9580 
      for key, value in self.__dict__.iteritems()]
9581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9582 
 
9583 
  def __eq__(self, other):
9584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9585 
 
9586 
  def __ne__(self, other):
9587 
    return not (self == other)
9588 
 
1398 varun.gupt 9589 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9590 
  """
9591 
  Attributes:
9592 
   - success
9593 
   - ex
9594 
  """
9595 
 
9596 
  thrift_spec = (
9597 
    (0, TType.BOOL, 'success', None, None, ), # 0
9598 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9599 
  )
9600 
 
9601 
  def __init__(self, success=None, ex=None,):
9602 
    self.success = success
9603 
    self.ex = ex
9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 0:
9615 
        if ftype == TType.BOOL:
9616 
          self.success = iprot.readBool();
9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      elif fid == 1:
9620 
        if ftype == TType.STRUCT:
9621 
          self.ex = TransactionServiceException()
9622 
          self.ex.read(iprot)
9623 
        else:
9624 
          iprot.skip(ftype)
9625 
      else:
9626 
        iprot.skip(ftype)
9627 
      iprot.readFieldEnd()
9628 
    iprot.readStructEnd()
9629 
 
9630 
  def write(self, oprot):
9631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9633 
      return
1398 varun.gupt 9634 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9635 
    if self.success is not None:
1382 varun.gupt 9636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9637 
      oprot.writeBool(self.success)
9638 
      oprot.writeFieldEnd()
3431 rajveer 9639 
    if self.ex is not None:
1382 varun.gupt 9640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9641 
      self.ex.write(oprot)
9642 
      oprot.writeFieldEnd()
9643 
    oprot.writeFieldStop()
9644 
    oprot.writeStructEnd()
9645 
 
3431 rajveer 9646 
  def validate(self):
9647 
    return
9648 
 
9649 
 
1382 varun.gupt 9650 
  def __repr__(self):
9651 
    L = ['%s=%r' % (key, value)
9652 
      for key, value in self.__dict__.iteritems()]
9653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9654 
 
9655 
  def __eq__(self, other):
9656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9657 
 
9658 
  def __ne__(self, other):
9659 
    return not (self == other)
9660 
 
483 rajveer 9661 
class getAllOrders_args:
94 ashish 9662 
  """
9663 
  Attributes:
4801 anupam.sin 9664 
   - statuses
483 rajveer 9665 
   - from_date
9666 
   - to_date
9667 
   - warehouse_id
94 ashish 9668 
  """
9669 
 
9670 
  thrift_spec = (
9671 
    None, # 0
4801 anupam.sin 9672 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9673 
    (2, TType.I64, 'from_date', None, None, ), # 2
9674 
    (3, TType.I64, 'to_date', None, None, ), # 3
9675 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9676 
  )
9677 
 
4801 anupam.sin 9678 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9679 
    self.statuses = statuses
483 rajveer 9680 
    self.from_date = from_date
9681 
    self.to_date = to_date
9682 
    self.warehouse_id = warehouse_id
94 ashish 9683 
 
9684 
  def read(self, iprot):
9685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9687 
      return
9688 
    iprot.readStructBegin()
9689 
    while True:
9690 
      (fname, ftype, fid) = iprot.readFieldBegin()
9691 
      if ftype == TType.STOP:
9692 
        break
9693 
      if fid == 1:
4801 anupam.sin 9694 
        if ftype == TType.LIST:
9695 
          self.statuses = []
6188 rajveer 9696 
          (_etype123, _size120) = iprot.readListBegin()
9697 
          for _i124 in xrange(_size120):
9698 
            _elem125 = iprot.readI32();
9699 
            self.statuses.append(_elem125)
4801 anupam.sin 9700 
          iprot.readListEnd()
94 ashish 9701 
        else:
9702 
          iprot.skip(ftype)
483 rajveer 9703 
      elif fid == 2:
9704 
        if ftype == TType.I64:
9705 
          self.from_date = iprot.readI64();
94 ashish 9706 
        else:
9707 
          iprot.skip(ftype)
483 rajveer 9708 
      elif fid == 3:
9709 
        if ftype == TType.I64:
9710 
          self.to_date = iprot.readI64();
94 ashish 9711 
        else:
9712 
          iprot.skip(ftype)
483 rajveer 9713 
      elif fid == 4:
94 ashish 9714 
        if ftype == TType.I64:
483 rajveer 9715 
          self.warehouse_id = iprot.readI64();
94 ashish 9716 
        else:
9717 
          iprot.skip(ftype)
9718 
      else:
9719 
        iprot.skip(ftype)
9720 
      iprot.readFieldEnd()
9721 
    iprot.readStructEnd()
9722 
 
9723 
  def write(self, oprot):
9724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9726 
      return
483 rajveer 9727 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9728 
    if self.statuses is not None:
9729 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9730 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9731 
      for iter126 in self.statuses:
9732 
        oprot.writeI32(iter126)
4801 anupam.sin 9733 
      oprot.writeListEnd()
94 ashish 9734 
      oprot.writeFieldEnd()
3431 rajveer 9735 
    if self.from_date is not None:
483 rajveer 9736 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9737 
      oprot.writeI64(self.from_date)
94 ashish 9738 
      oprot.writeFieldEnd()
3431 rajveer 9739 
    if self.to_date is not None:
483 rajveer 9740 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9741 
      oprot.writeI64(self.to_date)
94 ashish 9742 
      oprot.writeFieldEnd()
3431 rajveer 9743 
    if self.warehouse_id is not None:
483 rajveer 9744 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9745 
      oprot.writeI64(self.warehouse_id)
94 ashish 9746 
      oprot.writeFieldEnd()
9747 
    oprot.writeFieldStop()
9748 
    oprot.writeStructEnd()
9749 
 
3431 rajveer 9750 
  def validate(self):
9751 
    return
9752 
 
9753 
 
94 ashish 9754 
  def __repr__(self):
9755 
    L = ['%s=%r' % (key, value)
9756 
      for key, value in self.__dict__.iteritems()]
9757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9758 
 
9759 
  def __eq__(self, other):
9760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9761 
 
9762 
  def __ne__(self, other):
9763 
    return not (self == other)
9764 
 
483 rajveer 9765 
class getAllOrders_result:
94 ashish 9766 
  """
9767 
  Attributes:
9768 
   - success
9769 
   - ex
9770 
  """
9771 
 
9772 
  thrift_spec = (
483 rajveer 9773 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9775 
  )
9776 
 
9777 
  def __init__(self, success=None, ex=None,):
9778 
    self.success = success
9779 
    self.ex = ex
9780 
 
9781 
  def read(self, iprot):
9782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9784 
      return
9785 
    iprot.readStructBegin()
9786 
    while True:
9787 
      (fname, ftype, fid) = iprot.readFieldBegin()
9788 
      if ftype == TType.STOP:
9789 
        break
9790 
      if fid == 0:
483 rajveer 9791 
        if ftype == TType.LIST:
9792 
          self.success = []
6188 rajveer 9793 
          (_etype130, _size127) = iprot.readListBegin()
9794 
          for _i131 in xrange(_size127):
9795 
            _elem132 = Order()
9796 
            _elem132.read(iprot)
9797 
            self.success.append(_elem132)
483 rajveer 9798 
          iprot.readListEnd()
94 ashish 9799 
        else:
9800 
          iprot.skip(ftype)
9801 
      elif fid == 1:
9802 
        if ftype == TType.STRUCT:
9803 
          self.ex = TransactionServiceException()
9804 
          self.ex.read(iprot)
9805 
        else:
9806 
          iprot.skip(ftype)
9807 
      else:
9808 
        iprot.skip(ftype)
9809 
      iprot.readFieldEnd()
9810 
    iprot.readStructEnd()
9811 
 
9812 
  def write(self, oprot):
9813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9815 
      return
483 rajveer 9816 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9817 
    if self.success is not None:
483 rajveer 9818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9820 
      for iter133 in self.success:
9821 
        iter133.write(oprot)
483 rajveer 9822 
      oprot.writeListEnd()
94 ashish 9823 
      oprot.writeFieldEnd()
3431 rajveer 9824 
    if self.ex is not None:
94 ashish 9825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9826 
      self.ex.write(oprot)
9827 
      oprot.writeFieldEnd()
9828 
    oprot.writeFieldStop()
9829 
    oprot.writeStructEnd()
9830 
 
3431 rajveer 9831 
  def validate(self):
9832 
    return
9833 
 
9834 
 
94 ashish 9835 
  def __repr__(self):
9836 
    L = ['%s=%r' % (key, value)
9837 
      for key, value in self.__dict__.iteritems()]
9838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9839 
 
9840 
  def __eq__(self, other):
9841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9842 
 
9843 
  def __ne__(self, other):
9844 
    return not (self == other)
9845 
 
4133 chandransh 9846 
class getOrdersInBatch_args:
9847 
  """
9848 
  Attributes:
9849 
   - statuses
9850 
   - offset
9851 
   - limit
9852 
   - warehouse_id
9853 
  """
9854 
 
9855 
  thrift_spec = (
9856 
    None, # 0
9857 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9858 
    (2, TType.I64, 'offset', None, None, ), # 2
9859 
    (3, TType.I64, 'limit', None, None, ), # 3
9860 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9861 
  )
9862 
 
9863 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9864 
    self.statuses = statuses
9865 
    self.offset = offset
9866 
    self.limit = limit
9867 
    self.warehouse_id = warehouse_id
9868 
 
9869 
  def read(self, iprot):
9870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9872 
      return
9873 
    iprot.readStructBegin()
9874 
    while True:
9875 
      (fname, ftype, fid) = iprot.readFieldBegin()
9876 
      if ftype == TType.STOP:
9877 
        break
9878 
      if fid == 1:
9879 
        if ftype == TType.LIST:
9880 
          self.statuses = []
6188 rajveer 9881 
          (_etype137, _size134) = iprot.readListBegin()
9882 
          for _i138 in xrange(_size134):
9883 
            _elem139 = iprot.readI32();
9884 
            self.statuses.append(_elem139)
4133 chandransh 9885 
          iprot.readListEnd()
9886 
        else:
9887 
          iprot.skip(ftype)
9888 
      elif fid == 2:
9889 
        if ftype == TType.I64:
9890 
          self.offset = iprot.readI64();
9891 
        else:
9892 
          iprot.skip(ftype)
9893 
      elif fid == 3:
9894 
        if ftype == TType.I64:
9895 
          self.limit = iprot.readI64();
9896 
        else:
9897 
          iprot.skip(ftype)
9898 
      elif fid == 4:
9899 
        if ftype == TType.I64:
9900 
          self.warehouse_id = iprot.readI64();
9901 
        else:
9902 
          iprot.skip(ftype)
9903 
      else:
9904 
        iprot.skip(ftype)
9905 
      iprot.readFieldEnd()
9906 
    iprot.readStructEnd()
9907 
 
9908 
  def write(self, oprot):
9909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9911 
      return
9912 
    oprot.writeStructBegin('getOrdersInBatch_args')
9913 
    if self.statuses is not None:
9914 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9915 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9916 
      for iter140 in self.statuses:
9917 
        oprot.writeI32(iter140)
4133 chandransh 9918 
      oprot.writeListEnd()
9919 
      oprot.writeFieldEnd()
9920 
    if self.offset is not None:
9921 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9922 
      oprot.writeI64(self.offset)
9923 
      oprot.writeFieldEnd()
9924 
    if self.limit is not None:
9925 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9926 
      oprot.writeI64(self.limit)
9927 
      oprot.writeFieldEnd()
9928 
    if self.warehouse_id is not None:
9929 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9930 
      oprot.writeI64(self.warehouse_id)
9931 
      oprot.writeFieldEnd()
9932 
    oprot.writeFieldStop()
9933 
    oprot.writeStructEnd()
9934 
 
9935 
  def validate(self):
9936 
    return
9937 
 
9938 
 
9939 
  def __repr__(self):
9940 
    L = ['%s=%r' % (key, value)
9941 
      for key, value in self.__dict__.iteritems()]
9942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9943 
 
9944 
  def __eq__(self, other):
9945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9946 
 
9947 
  def __ne__(self, other):
9948 
    return not (self == other)
9949 
 
9950 
class getOrdersInBatch_result:
9951 
  """
9952 
  Attributes:
9953 
   - success
9954 
   - ex
9955 
  """
9956 
 
9957 
  thrift_spec = (
9958 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9960 
  )
9961 
 
9962 
  def __init__(self, success=None, ex=None,):
9963 
    self.success = success
9964 
    self.ex = ex
9965 
 
9966 
  def read(self, iprot):
9967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9969 
      return
9970 
    iprot.readStructBegin()
9971 
    while True:
9972 
      (fname, ftype, fid) = iprot.readFieldBegin()
9973 
      if ftype == TType.STOP:
9974 
        break
9975 
      if fid == 0:
9976 
        if ftype == TType.LIST:
9977 
          self.success = []
6188 rajveer 9978 
          (_etype144, _size141) = iprot.readListBegin()
9979 
          for _i145 in xrange(_size141):
9980 
            _elem146 = Order()
9981 
            _elem146.read(iprot)
9982 
            self.success.append(_elem146)
4133 chandransh 9983 
          iprot.readListEnd()
9984 
        else:
9985 
          iprot.skip(ftype)
9986 
      elif fid == 1:
9987 
        if ftype == TType.STRUCT:
9988 
          self.ex = TransactionServiceException()
9989 
          self.ex.read(iprot)
9990 
        else:
9991 
          iprot.skip(ftype)
9992 
      else:
9993 
        iprot.skip(ftype)
9994 
      iprot.readFieldEnd()
9995 
    iprot.readStructEnd()
9996 
 
9997 
  def write(self, oprot):
9998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10000 
      return
10001 
    oprot.writeStructBegin('getOrdersInBatch_result')
10002 
    if self.success is not None:
10003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10005 
      for iter147 in self.success:
10006 
        iter147.write(oprot)
4133 chandransh 10007 
      oprot.writeListEnd()
10008 
      oprot.writeFieldEnd()
10009 
    if self.ex is not None:
10010 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10011 
      self.ex.write(oprot)
10012 
      oprot.writeFieldEnd()
10013 
    oprot.writeFieldStop()
10014 
    oprot.writeStructEnd()
10015 
 
10016 
  def validate(self):
10017 
    return
10018 
 
10019 
 
10020 
  def __repr__(self):
10021 
    L = ['%s=%r' % (key, value)
10022 
      for key, value in self.__dict__.iteritems()]
10023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10024 
 
10025 
  def __eq__(self, other):
10026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10027 
 
10028 
  def __ne__(self, other):
10029 
    return not (self == other)
10030 
 
10031 
class getOrderCount_args:
10032 
  """
10033 
  Attributes:
10034 
   - statuses
10035 
   - warehouseId
10036 
  """
10037 
 
10038 
  thrift_spec = (
10039 
    None, # 0
10040 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10041 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10042 
  )
10043 
 
10044 
  def __init__(self, statuses=None, warehouseId=None,):
10045 
    self.statuses = statuses
10046 
    self.warehouseId = warehouseId
10047 
 
10048 
  def read(self, iprot):
10049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10051 
      return
10052 
    iprot.readStructBegin()
10053 
    while True:
10054 
      (fname, ftype, fid) = iprot.readFieldBegin()
10055 
      if ftype == TType.STOP:
10056 
        break
10057 
      if fid == 1:
10058 
        if ftype == TType.LIST:
10059 
          self.statuses = []
6188 rajveer 10060 
          (_etype151, _size148) = iprot.readListBegin()
10061 
          for _i152 in xrange(_size148):
10062 
            _elem153 = iprot.readI32();
10063 
            self.statuses.append(_elem153)
4133 chandransh 10064 
          iprot.readListEnd()
10065 
        else:
10066 
          iprot.skip(ftype)
10067 
      elif fid == 2:
10068 
        if ftype == TType.I64:
10069 
          self.warehouseId = iprot.readI64();
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      else:
10073 
        iprot.skip(ftype)
10074 
      iprot.readFieldEnd()
10075 
    iprot.readStructEnd()
10076 
 
10077 
  def write(self, oprot):
10078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10080 
      return
10081 
    oprot.writeStructBegin('getOrderCount_args')
10082 
    if self.statuses is not None:
10083 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10084 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10085 
      for iter154 in self.statuses:
10086 
        oprot.writeI32(iter154)
4133 chandransh 10087 
      oprot.writeListEnd()
10088 
      oprot.writeFieldEnd()
10089 
    if self.warehouseId is not None:
10090 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10091 
      oprot.writeI64(self.warehouseId)
10092 
      oprot.writeFieldEnd()
10093 
    oprot.writeFieldStop()
10094 
    oprot.writeStructEnd()
10095 
 
10096 
  def validate(self):
10097 
    return
10098 
 
10099 
 
10100 
  def __repr__(self):
10101 
    L = ['%s=%r' % (key, value)
10102 
      for key, value in self.__dict__.iteritems()]
10103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10104 
 
10105 
  def __eq__(self, other):
10106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10107 
 
10108 
  def __ne__(self, other):
10109 
    return not (self == other)
10110 
 
10111 
class getOrderCount_result:
10112 
  """
10113 
  Attributes:
10114 
   - success
10115 
   - ex
10116 
  """
10117 
 
10118 
  thrift_spec = (
10119 
    (0, TType.I32, 'success', None, None, ), # 0
10120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10121 
  )
10122 
 
10123 
  def __init__(self, success=None, ex=None,):
10124 
    self.success = success
10125 
    self.ex = ex
10126 
 
10127 
  def read(self, iprot):
10128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10130 
      return
10131 
    iprot.readStructBegin()
10132 
    while True:
10133 
      (fname, ftype, fid) = iprot.readFieldBegin()
10134 
      if ftype == TType.STOP:
10135 
        break
10136 
      if fid == 0:
10137 
        if ftype == TType.I32:
10138 
          self.success = iprot.readI32();
10139 
        else:
10140 
          iprot.skip(ftype)
10141 
      elif fid == 1:
10142 
        if ftype == TType.STRUCT:
10143 
          self.ex = TransactionServiceException()
10144 
          self.ex.read(iprot)
10145 
        else:
10146 
          iprot.skip(ftype)
10147 
      else:
10148 
        iprot.skip(ftype)
10149 
      iprot.readFieldEnd()
10150 
    iprot.readStructEnd()
10151 
 
10152 
  def write(self, oprot):
10153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10155 
      return
10156 
    oprot.writeStructBegin('getOrderCount_result')
10157 
    if self.success is not None:
10158 
      oprot.writeFieldBegin('success', TType.I32, 0)
10159 
      oprot.writeI32(self.success)
10160 
      oprot.writeFieldEnd()
10161 
    if self.ex is not None:
10162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10163 
      self.ex.write(oprot)
10164 
      oprot.writeFieldEnd()
10165 
    oprot.writeFieldStop()
10166 
    oprot.writeStructEnd()
10167 
 
10168 
  def validate(self):
10169 
    return
10170 
 
10171 
 
10172 
  def __repr__(self):
10173 
    L = ['%s=%r' % (key, value)
10174 
      for key, value in self.__dict__.iteritems()]
10175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10176 
 
10177 
  def __eq__(self, other):
10178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10179 
 
10180 
  def __ne__(self, other):
10181 
    return not (self == other)
10182 
 
999 varun.gupt 10183 
class getOrdersByBillingDate_args:
10184 
  """
10185 
  Attributes:
10186 
   - status
10187 
   - start_billing_date
10188 
   - end_billing_date
10189 
   - warehouse_id
10190 
  """
10191 
 
10192 
  thrift_spec = (
10193 
    None, # 0
10194 
    (1, TType.I32, 'status', None, None, ), # 1
10195 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10196 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10197 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10198 
  )
10199 
 
10200 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10201 
    self.status = status
10202 
    self.start_billing_date = start_billing_date
10203 
    self.end_billing_date = end_billing_date
10204 
    self.warehouse_id = warehouse_id
10205 
 
10206 
  def read(self, iprot):
10207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10209 
      return
10210 
    iprot.readStructBegin()
10211 
    while True:
10212 
      (fname, ftype, fid) = iprot.readFieldBegin()
10213 
      if ftype == TType.STOP:
10214 
        break
10215 
      if fid == 1:
10216 
        if ftype == TType.I32:
10217 
          self.status = iprot.readI32();
10218 
        else:
10219 
          iprot.skip(ftype)
10220 
      elif fid == 2:
10221 
        if ftype == TType.I64:
10222 
          self.start_billing_date = iprot.readI64();
10223 
        else:
10224 
          iprot.skip(ftype)
10225 
      elif fid == 3:
10226 
        if ftype == TType.I64:
10227 
          self.end_billing_date = iprot.readI64();
10228 
        else:
10229 
          iprot.skip(ftype)
10230 
      elif fid == 4:
10231 
        if ftype == TType.I64:
10232 
          self.warehouse_id = iprot.readI64();
10233 
        else:
10234 
          iprot.skip(ftype)
10235 
      else:
10236 
        iprot.skip(ftype)
10237 
      iprot.readFieldEnd()
10238 
    iprot.readStructEnd()
10239 
 
10240 
  def write(self, oprot):
10241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10243 
      return
10244 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10245 
    if self.status is not None:
999 varun.gupt 10246 
      oprot.writeFieldBegin('status', TType.I32, 1)
10247 
      oprot.writeI32(self.status)
10248 
      oprot.writeFieldEnd()
3431 rajveer 10249 
    if self.start_billing_date is not None:
999 varun.gupt 10250 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10251 
      oprot.writeI64(self.start_billing_date)
10252 
      oprot.writeFieldEnd()
3431 rajveer 10253 
    if self.end_billing_date is not None:
999 varun.gupt 10254 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10255 
      oprot.writeI64(self.end_billing_date)
10256 
      oprot.writeFieldEnd()
3431 rajveer 10257 
    if self.warehouse_id is not None:
999 varun.gupt 10258 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10259 
      oprot.writeI64(self.warehouse_id)
10260 
      oprot.writeFieldEnd()
10261 
    oprot.writeFieldStop()
10262 
    oprot.writeStructEnd()
10263 
 
3431 rajveer 10264 
  def validate(self):
10265 
    return
10266 
 
10267 
 
999 varun.gupt 10268 
  def __repr__(self):
10269 
    L = ['%s=%r' % (key, value)
10270 
      for key, value in self.__dict__.iteritems()]
10271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10272 
 
10273 
  def __eq__(self, other):
10274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10275 
 
10276 
  def __ne__(self, other):
10277 
    return not (self == other)
10278 
 
10279 
class getOrdersByBillingDate_result:
10280 
  """
10281 
  Attributes:
10282 
   - success
10283 
   - ex
10284 
  """
10285 
 
10286 
  thrift_spec = (
10287 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10289 
  )
10290 
 
10291 
  def __init__(self, success=None, ex=None,):
10292 
    self.success = success
10293 
    self.ex = ex
10294 
 
10295 
  def read(self, iprot):
10296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10298 
      return
10299 
    iprot.readStructBegin()
10300 
    while True:
10301 
      (fname, ftype, fid) = iprot.readFieldBegin()
10302 
      if ftype == TType.STOP:
10303 
        break
10304 
      if fid == 0:
10305 
        if ftype == TType.LIST:
10306 
          self.success = []
6188 rajveer 10307 
          (_etype158, _size155) = iprot.readListBegin()
10308 
          for _i159 in xrange(_size155):
10309 
            _elem160 = Order()
10310 
            _elem160.read(iprot)
10311 
            self.success.append(_elem160)
999 varun.gupt 10312 
          iprot.readListEnd()
10313 
        else:
10314 
          iprot.skip(ftype)
10315 
      elif fid == 1:
10316 
        if ftype == TType.STRUCT:
10317 
          self.ex = TransactionServiceException()
10318 
          self.ex.read(iprot)
10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
10330 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10331 
    if self.success is not None:
999 varun.gupt 10332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10334 
      for iter161 in self.success:
10335 
        iter161.write(oprot)
999 varun.gupt 10336 
      oprot.writeListEnd()
10337 
      oprot.writeFieldEnd()
3431 rajveer 10338 
    if self.ex is not None:
999 varun.gupt 10339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10340 
      self.ex.write(oprot)
10341 
      oprot.writeFieldEnd()
10342 
    oprot.writeFieldStop()
10343 
    oprot.writeStructEnd()
10344 
 
3431 rajveer 10345 
  def validate(self):
10346 
    return
10347 
 
10348 
 
999 varun.gupt 10349 
  def __repr__(self):
10350 
    L = ['%s=%r' % (key, value)
10351 
      for key, value in self.__dict__.iteritems()]
10352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10353 
 
10354 
  def __eq__(self, other):
10355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10356 
 
10357 
  def __ne__(self, other):
10358 
    return not (self == other)
10359 
 
3427 chandransh 10360 
class getOrdersByShippingDate_args:
10361 
  """
10362 
  Attributes:
10363 
   - fromShippingDate
10364 
   - toShippingDate
10365 
   - providerId
10366 
   - warehouseId
3451 chandransh 10367 
   - cod
3427 chandransh 10368 
  """
10369 
 
10370 
  thrift_spec = (
10371 
    None, # 0
10372 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10373 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10374 
    (3, TType.I64, 'providerId', None, None, ), # 3
10375 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10376 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10377 
  )
10378 
 
3451 chandransh 10379 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10380 
    self.fromShippingDate = fromShippingDate
10381 
    self.toShippingDate = toShippingDate
10382 
    self.providerId = providerId
10383 
    self.warehouseId = warehouseId
3451 chandransh 10384 
    self.cod = cod
3427 chandransh 10385 
 
10386 
  def read(self, iprot):
10387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10389 
      return
10390 
    iprot.readStructBegin()
10391 
    while True:
10392 
      (fname, ftype, fid) = iprot.readFieldBegin()
10393 
      if ftype == TType.STOP:
10394 
        break
10395 
      if fid == 1:
10396 
        if ftype == TType.I64:
10397 
          self.fromShippingDate = iprot.readI64();
10398 
        else:
10399 
          iprot.skip(ftype)
10400 
      elif fid == 2:
10401 
        if ftype == TType.I64:
10402 
          self.toShippingDate = iprot.readI64();
10403 
        else:
10404 
          iprot.skip(ftype)
10405 
      elif fid == 3:
10406 
        if ftype == TType.I64:
10407 
          self.providerId = iprot.readI64();
10408 
        else:
10409 
          iprot.skip(ftype)
10410 
      elif fid == 4:
10411 
        if ftype == TType.I64:
10412 
          self.warehouseId = iprot.readI64();
10413 
        else:
10414 
          iprot.skip(ftype)
3451 chandransh 10415 
      elif fid == 5:
10416 
        if ftype == TType.BOOL:
10417 
          self.cod = iprot.readBool();
10418 
        else:
10419 
          iprot.skip(ftype)
3427 chandransh 10420 
      else:
10421 
        iprot.skip(ftype)
10422 
      iprot.readFieldEnd()
10423 
    iprot.readStructEnd()
10424 
 
10425 
  def write(self, oprot):
10426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10428 
      return
10429 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10430 
    if self.fromShippingDate is not None:
3427 chandransh 10431 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10432 
      oprot.writeI64(self.fromShippingDate)
10433 
      oprot.writeFieldEnd()
3431 rajveer 10434 
    if self.toShippingDate is not None:
3427 chandransh 10435 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10436 
      oprot.writeI64(self.toShippingDate)
10437 
      oprot.writeFieldEnd()
3431 rajveer 10438 
    if self.providerId is not None:
3427 chandransh 10439 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10440 
      oprot.writeI64(self.providerId)
10441 
      oprot.writeFieldEnd()
3431 rajveer 10442 
    if self.warehouseId is not None:
3427 chandransh 10443 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10444 
      oprot.writeI64(self.warehouseId)
10445 
      oprot.writeFieldEnd()
3451 chandransh 10446 
    if self.cod is not None:
10447 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10448 
      oprot.writeBool(self.cod)
10449 
      oprot.writeFieldEnd()
3427 chandransh 10450 
    oprot.writeFieldStop()
10451 
    oprot.writeStructEnd()
10452 
 
3431 rajveer 10453 
  def validate(self):
10454 
    return
10455 
 
10456 
 
3427 chandransh 10457 
  def __repr__(self):
10458 
    L = ['%s=%r' % (key, value)
10459 
      for key, value in self.__dict__.iteritems()]
10460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10461 
 
10462 
  def __eq__(self, other):
10463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10464 
 
10465 
  def __ne__(self, other):
10466 
    return not (self == other)
10467 
 
10468 
class getOrdersByShippingDate_result:
10469 
  """
10470 
  Attributes:
10471 
   - success
10472 
   - ex
10473 
  """
10474 
 
10475 
  thrift_spec = (
10476 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10477 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10478 
  )
10479 
 
10480 
  def __init__(self, success=None, ex=None,):
10481 
    self.success = success
10482 
    self.ex = ex
10483 
 
10484 
  def read(self, iprot):
10485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10487 
      return
10488 
    iprot.readStructBegin()
10489 
    while True:
10490 
      (fname, ftype, fid) = iprot.readFieldBegin()
10491 
      if ftype == TType.STOP:
10492 
        break
10493 
      if fid == 0:
10494 
        if ftype == TType.LIST:
10495 
          self.success = []
6188 rajveer 10496 
          (_etype165, _size162) = iprot.readListBegin()
10497 
          for _i166 in xrange(_size162):
10498 
            _elem167 = Order()
10499 
            _elem167.read(iprot)
10500 
            self.success.append(_elem167)
3427 chandransh 10501 
          iprot.readListEnd()
10502 
        else:
10503 
          iprot.skip(ftype)
10504 
      elif fid == 1:
10505 
        if ftype == TType.STRUCT:
10506 
          self.ex = TransactionServiceException()
10507 
          self.ex.read(iprot)
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
10519 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10520 
    if self.success is not None:
3427 chandransh 10521 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10522 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10523 
      for iter168 in self.success:
10524 
        iter168.write(oprot)
3427 chandransh 10525 
      oprot.writeListEnd()
10526 
      oprot.writeFieldEnd()
3431 rajveer 10527 
    if self.ex is not None:
3427 chandransh 10528 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10529 
      self.ex.write(oprot)
10530 
      oprot.writeFieldEnd()
10531 
    oprot.writeFieldStop()
10532 
    oprot.writeStructEnd()
10533 
 
3431 rajveer 10534 
  def validate(self):
10535 
    return
10536 
 
10537 
 
3427 chandransh 10538 
  def __repr__(self):
10539 
    L = ['%s=%r' % (key, value)
10540 
      for key, value in self.__dict__.iteritems()]
10541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10542 
 
10543 
  def __eq__(self, other):
10544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10545 
 
10546 
  def __ne__(self, other):
10547 
    return not (self == other)
10548 
 
1382 varun.gupt 10549 
class getReturnableOrdersForCustomer_args:
10550 
  """
10551 
  Attributes:
10552 
   - customer_id
10553 
   - limit
10554 
  """
10555 
 
10556 
  thrift_spec = (
10557 
    None, # 0
10558 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10559 
    (2, TType.I64, 'limit', None, None, ), # 2
10560 
  )
10561 
 
10562 
  def __init__(self, customer_id=None, limit=None,):
10563 
    self.customer_id = customer_id
10564 
    self.limit = limit
10565 
 
10566 
  def read(self, iprot):
10567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10569 
      return
10570 
    iprot.readStructBegin()
10571 
    while True:
10572 
      (fname, ftype, fid) = iprot.readFieldBegin()
10573 
      if ftype == TType.STOP:
10574 
        break
10575 
      if fid == 1:
10576 
        if ftype == TType.I64:
10577 
          self.customer_id = iprot.readI64();
10578 
        else:
10579 
          iprot.skip(ftype)
10580 
      elif fid == 2:
10581 
        if ftype == TType.I64:
10582 
          self.limit = iprot.readI64();
10583 
        else:
10584 
          iprot.skip(ftype)
10585 
      else:
10586 
        iprot.skip(ftype)
10587 
      iprot.readFieldEnd()
10588 
    iprot.readStructEnd()
10589 
 
10590 
  def write(self, oprot):
10591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10593 
      return
10594 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10595 
    if self.customer_id is not None:
1382 varun.gupt 10596 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10597 
      oprot.writeI64(self.customer_id)
10598 
      oprot.writeFieldEnd()
3431 rajveer 10599 
    if self.limit is not None:
1382 varun.gupt 10600 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10601 
      oprot.writeI64(self.limit)
10602 
      oprot.writeFieldEnd()
10603 
    oprot.writeFieldStop()
10604 
    oprot.writeStructEnd()
10605 
 
3431 rajveer 10606 
  def validate(self):
10607 
    return
10608 
 
10609 
 
1382 varun.gupt 10610 
  def __repr__(self):
10611 
    L = ['%s=%r' % (key, value)
10612 
      for key, value in self.__dict__.iteritems()]
10613 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10614 
 
10615 
  def __eq__(self, other):
10616 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10617 
 
10618 
  def __ne__(self, other):
10619 
    return not (self == other)
10620 
 
10621 
class getReturnableOrdersForCustomer_result:
10622 
  """
10623 
  Attributes:
10624 
   - success
10625 
   - ex
10626 
  """
10627 
 
10628 
  thrift_spec = (
10629 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10630 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10631 
  )
10632 
 
10633 
  def __init__(self, success=None, ex=None,):
10634 
    self.success = success
10635 
    self.ex = ex
10636 
 
10637 
  def read(self, iprot):
10638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10640 
      return
10641 
    iprot.readStructBegin()
10642 
    while True:
10643 
      (fname, ftype, fid) = iprot.readFieldBegin()
10644 
      if ftype == TType.STOP:
10645 
        break
10646 
      if fid == 0:
10647 
        if ftype == TType.LIST:
10648 
          self.success = []
6188 rajveer 10649 
          (_etype172, _size169) = iprot.readListBegin()
10650 
          for _i173 in xrange(_size169):
10651 
            _elem174 = iprot.readI64();
10652 
            self.success.append(_elem174)
1382 varun.gupt 10653 
          iprot.readListEnd()
10654 
        else:
10655 
          iprot.skip(ftype)
10656 
      elif fid == 1:
10657 
        if ftype == TType.STRUCT:
10658 
          self.ex = TransactionServiceException()
10659 
          self.ex.read(iprot)
10660 
        else:
10661 
          iprot.skip(ftype)
10662 
      else:
10663 
        iprot.skip(ftype)
10664 
      iprot.readFieldEnd()
10665 
    iprot.readStructEnd()
10666 
 
10667 
  def write(self, oprot):
10668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10670 
      return
10671 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10672 
    if self.success is not None:
1382 varun.gupt 10673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10674 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10675 
      for iter175 in self.success:
10676 
        oprot.writeI64(iter175)
1382 varun.gupt 10677 
      oprot.writeListEnd()
10678 
      oprot.writeFieldEnd()
3431 rajveer 10679 
    if self.ex is not None:
1382 varun.gupt 10680 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10681 
      self.ex.write(oprot)
10682 
      oprot.writeFieldEnd()
10683 
    oprot.writeFieldStop()
10684 
    oprot.writeStructEnd()
10685 
 
3431 rajveer 10686 
  def validate(self):
10687 
    return
10688 
 
10689 
 
1382 varun.gupt 10690 
  def __repr__(self):
10691 
    L = ['%s=%r' % (key, value)
10692 
      for key, value in self.__dict__.iteritems()]
10693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10694 
 
10695 
  def __eq__(self, other):
10696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10697 
 
10698 
  def __ne__(self, other):
10699 
    return not (self == other)
10700 
 
10701 
class getCancellableOrdersForCustomer_args:
10702 
  """
10703 
  Attributes:
10704 
   - customer_id
10705 
   - limit
10706 
  """
10707 
 
10708 
  thrift_spec = (
10709 
    None, # 0
10710 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10711 
    (2, TType.I64, 'limit', None, None, ), # 2
10712 
  )
10713 
 
10714 
  def __init__(self, customer_id=None, limit=None,):
10715 
    self.customer_id = customer_id
10716 
    self.limit = limit
10717 
 
10718 
  def read(self, iprot):
10719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10721 
      return
10722 
    iprot.readStructBegin()
10723 
    while True:
10724 
      (fname, ftype, fid) = iprot.readFieldBegin()
10725 
      if ftype == TType.STOP:
10726 
        break
10727 
      if fid == 1:
10728 
        if ftype == TType.I64:
10729 
          self.customer_id = iprot.readI64();
10730 
        else:
10731 
          iprot.skip(ftype)
10732 
      elif fid == 2:
10733 
        if ftype == TType.I64:
10734 
          self.limit = iprot.readI64();
10735 
        else:
10736 
          iprot.skip(ftype)
10737 
      else:
10738 
        iprot.skip(ftype)
10739 
      iprot.readFieldEnd()
10740 
    iprot.readStructEnd()
10741 
 
10742 
  def write(self, oprot):
10743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10745 
      return
10746 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10747 
    if self.customer_id is not None:
1382 varun.gupt 10748 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10749 
      oprot.writeI64(self.customer_id)
10750 
      oprot.writeFieldEnd()
3431 rajveer 10751 
    if self.limit is not None:
1382 varun.gupt 10752 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10753 
      oprot.writeI64(self.limit)
10754 
      oprot.writeFieldEnd()
10755 
    oprot.writeFieldStop()
10756 
    oprot.writeStructEnd()
10757 
 
3431 rajveer 10758 
  def validate(self):
10759 
    return
10760 
 
10761 
 
1382 varun.gupt 10762 
  def __repr__(self):
10763 
    L = ['%s=%r' % (key, value)
10764 
      for key, value in self.__dict__.iteritems()]
10765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10766 
 
10767 
  def __eq__(self, other):
10768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10769 
 
10770 
  def __ne__(self, other):
10771 
    return not (self == other)
10772 
 
10773 
class getCancellableOrdersForCustomer_result:
10774 
  """
10775 
  Attributes:
10776 
   - success
10777 
   - ex
10778 
  """
10779 
 
10780 
  thrift_spec = (
10781 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10782 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10783 
  )
10784 
 
10785 
  def __init__(self, success=None, ex=None,):
10786 
    self.success = success
10787 
    self.ex = ex
10788 
 
10789 
  def read(self, iprot):
10790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10792 
      return
10793 
    iprot.readStructBegin()
10794 
    while True:
10795 
      (fname, ftype, fid) = iprot.readFieldBegin()
10796 
      if ftype == TType.STOP:
10797 
        break
10798 
      if fid == 0:
10799 
        if ftype == TType.LIST:
10800 
          self.success = []
6188 rajveer 10801 
          (_etype179, _size176) = iprot.readListBegin()
10802 
          for _i180 in xrange(_size176):
10803 
            _elem181 = iprot.readI64();
10804 
            self.success.append(_elem181)
1382 varun.gupt 10805 
          iprot.readListEnd()
10806 
        else:
10807 
          iprot.skip(ftype)
10808 
      elif fid == 1:
10809 
        if ftype == TType.STRUCT:
10810 
          self.ex = TransactionServiceException()
10811 
          self.ex.read(iprot)
10812 
        else:
10813 
          iprot.skip(ftype)
10814 
      else:
10815 
        iprot.skip(ftype)
10816 
      iprot.readFieldEnd()
10817 
    iprot.readStructEnd()
10818 
 
10819 
  def write(self, oprot):
10820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10822 
      return
10823 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10824 
    if self.success is not None:
1382 varun.gupt 10825 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10826 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10827 
      for iter182 in self.success:
10828 
        oprot.writeI64(iter182)
1382 varun.gupt 10829 
      oprot.writeListEnd()
10830 
      oprot.writeFieldEnd()
3431 rajveer 10831 
    if self.ex is not None:
1382 varun.gupt 10832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10833 
      self.ex.write(oprot)
10834 
      oprot.writeFieldEnd()
10835 
    oprot.writeFieldStop()
10836 
    oprot.writeStructEnd()
10837 
 
3431 rajveer 10838 
  def validate(self):
10839 
    return
10840 
 
10841 
 
1382 varun.gupt 10842 
  def __repr__(self):
10843 
    L = ['%s=%r' % (key, value)
10844 
      for key, value in self.__dict__.iteritems()]
10845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10846 
 
10847 
  def __eq__(self, other):
10848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10849 
 
10850 
  def __ne__(self, other):
10851 
    return not (self == other)
10852 
 
483 rajveer 10853 
class changeOrderStatus_args:
94 ashish 10854 
  """
10855 
  Attributes:
483 rajveer 10856 
   - orderId
10857 
   - status
10858 
   - description
94 ashish 10859 
  """
10860 
 
10861 
  thrift_spec = (
10862 
    None, # 0
483 rajveer 10863 
    (1, TType.I64, 'orderId', None, None, ), # 1
10864 
    (2, TType.I32, 'status', None, None, ), # 2
10865 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10866 
  )
10867 
 
483 rajveer 10868 
  def __init__(self, orderId=None, status=None, description=None,):
10869 
    self.orderId = orderId
10870 
    self.status = status
10871 
    self.description = description
94 ashish 10872 
 
10873 
  def read(self, iprot):
10874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10876 
      return
10877 
    iprot.readStructBegin()
10878 
    while True:
10879 
      (fname, ftype, fid) = iprot.readFieldBegin()
10880 
      if ftype == TType.STOP:
10881 
        break
10882 
      if fid == 1:
10883 
        if ftype == TType.I64:
483 rajveer 10884 
          self.orderId = iprot.readI64();
94 ashish 10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      elif fid == 2:
483 rajveer 10888 
        if ftype == TType.I32:
10889 
          self.status = iprot.readI32();
94 ashish 10890 
        else:
10891 
          iprot.skip(ftype)
483 rajveer 10892 
      elif fid == 3:
10893 
        if ftype == TType.STRING:
10894 
          self.description = iprot.readString();
10895 
        else:
10896 
          iprot.skip(ftype)
94 ashish 10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
483 rajveer 10906 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10907 
    if self.orderId is not None:
483 rajveer 10908 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10909 
      oprot.writeI64(self.orderId)
94 ashish 10910 
      oprot.writeFieldEnd()
3431 rajveer 10911 
    if self.status is not None:
483 rajveer 10912 
      oprot.writeFieldBegin('status', TType.I32, 2)
10913 
      oprot.writeI32(self.status)
94 ashish 10914 
      oprot.writeFieldEnd()
3431 rajveer 10915 
    if self.description is not None:
483 rajveer 10916 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10917 
      oprot.writeString(self.description)
10918 
      oprot.writeFieldEnd()
94 ashish 10919 
    oprot.writeFieldStop()
10920 
    oprot.writeStructEnd()
10921 
 
3431 rajveer 10922 
  def validate(self):
10923 
    return
10924 
 
10925 
 
94 ashish 10926 
  def __repr__(self):
10927 
    L = ['%s=%r' % (key, value)
10928 
      for key, value in self.__dict__.iteritems()]
10929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10930 
 
10931 
  def __eq__(self, other):
10932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10933 
 
10934 
  def __ne__(self, other):
10935 
    return not (self == other)
10936 
 
483 rajveer 10937 
class changeOrderStatus_result:
94 ashish 10938 
  """
10939 
  Attributes:
10940 
   - success
10941 
   - ex
10942 
  """
10943 
 
10944 
  thrift_spec = (
10945 
    (0, TType.BOOL, 'success', None, None, ), # 0
10946 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10947 
  )
10948 
 
10949 
  def __init__(self, success=None, ex=None,):
10950 
    self.success = success
10951 
    self.ex = ex
10952 
 
10953 
  def read(self, iprot):
10954 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10955 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10956 
      return
10957 
    iprot.readStructBegin()
10958 
    while True:
10959 
      (fname, ftype, fid) = iprot.readFieldBegin()
10960 
      if ftype == TType.STOP:
10961 
        break
10962 
      if fid == 0:
10963 
        if ftype == TType.BOOL:
10964 
          self.success = iprot.readBool();
10965 
        else:
10966 
          iprot.skip(ftype)
10967 
      elif fid == 1:
10968 
        if ftype == TType.STRUCT:
10969 
          self.ex = TransactionServiceException()
10970 
          self.ex.read(iprot)
10971 
        else:
10972 
          iprot.skip(ftype)
10973 
      else:
10974 
        iprot.skip(ftype)
10975 
      iprot.readFieldEnd()
10976 
    iprot.readStructEnd()
10977 
 
10978 
  def write(self, oprot):
10979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10981 
      return
483 rajveer 10982 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10983 
    if self.success is not None:
94 ashish 10984 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10985 
      oprot.writeBool(self.success)
10986 
      oprot.writeFieldEnd()
3431 rajveer 10987 
    if self.ex is not None:
94 ashish 10988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10989 
      self.ex.write(oprot)
10990 
      oprot.writeFieldEnd()
10991 
    oprot.writeFieldStop()
10992 
    oprot.writeStructEnd()
10993 
 
3431 rajveer 10994 
  def validate(self):
10995 
    return
10996 
 
10997 
 
94 ashish 10998 
  def __repr__(self):
10999 
    L = ['%s=%r' % (key, value)
11000 
      for key, value in self.__dict__.iteritems()]
11001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11002 
 
11003 
  def __eq__(self, other):
11004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11005 
 
11006 
  def __ne__(self, other):
11007 
    return not (self == other)
11008 
 
3064 chandransh 11009 
class getOrdersForTransaction_args:
494 rajveer 11010 
  """
11011 
  Attributes:
3064 chandransh 11012 
   - transactionId
11013 
   - customerId
494 rajveer 11014 
  """
11015 
 
11016 
  thrift_spec = (
11017 
    None, # 0
3064 chandransh 11018 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11019 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11020 
  )
11021 
 
3064 chandransh 11022 
  def __init__(self, transactionId=None, customerId=None,):
11023 
    self.transactionId = transactionId
11024 
    self.customerId = customerId
494 rajveer 11025 
 
11026 
  def read(self, iprot):
11027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11029 
      return
11030 
    iprot.readStructBegin()
11031 
    while True:
11032 
      (fname, ftype, fid) = iprot.readFieldBegin()
11033 
      if ftype == TType.STOP:
11034 
        break
11035 
      if fid == 1:
11036 
        if ftype == TType.I64:
3064 chandransh 11037 
          self.transactionId = iprot.readI64();
494 rajveer 11038 
        else:
11039 
          iprot.skip(ftype)
11040 
      elif fid == 2:
3064 chandransh 11041 
        if ftype == TType.I64:
11042 
          self.customerId = iprot.readI64();
494 rajveer 11043 
        else:
11044 
          iprot.skip(ftype)
11045 
      else:
11046 
        iprot.skip(ftype)
11047 
      iprot.readFieldEnd()
11048 
    iprot.readStructEnd()
11049 
 
11050 
  def write(self, oprot):
11051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11053 
      return
3064 chandransh 11054 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11055 
    if self.transactionId is not None:
3064 chandransh 11056 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11057 
      oprot.writeI64(self.transactionId)
494 rajveer 11058 
      oprot.writeFieldEnd()
3431 rajveer 11059 
    if self.customerId is not None:
3064 chandransh 11060 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11061 
      oprot.writeI64(self.customerId)
494 rajveer 11062 
      oprot.writeFieldEnd()
11063 
    oprot.writeFieldStop()
11064 
    oprot.writeStructEnd()
11065 
 
3431 rajveer 11066 
  def validate(self):
11067 
    return
11068 
 
11069 
 
494 rajveer 11070 
  def __repr__(self):
11071 
    L = ['%s=%r' % (key, value)
11072 
      for key, value in self.__dict__.iteritems()]
11073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11074 
 
11075 
  def __eq__(self, other):
11076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11077 
 
11078 
  def __ne__(self, other):
11079 
    return not (self == other)
11080 
 
3064 chandransh 11081 
class getOrdersForTransaction_result:
494 rajveer 11082 
  """
11083 
  Attributes:
11084 
   - success
11085 
   - ex
11086 
  """
11087 
 
11088 
  thrift_spec = (
3064 chandransh 11089 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11091 
  )
11092 
 
11093 
  def __init__(self, success=None, ex=None,):
11094 
    self.success = success
11095 
    self.ex = ex
11096 
 
11097 
  def read(self, iprot):
11098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11100 
      return
11101 
    iprot.readStructBegin()
11102 
    while True:
11103 
      (fname, ftype, fid) = iprot.readFieldBegin()
11104 
      if ftype == TType.STOP:
11105 
        break
11106 
      if fid == 0:
3064 chandransh 11107 
        if ftype == TType.LIST:
11108 
          self.success = []
6188 rajveer 11109 
          (_etype186, _size183) = iprot.readListBegin()
11110 
          for _i187 in xrange(_size183):
11111 
            _elem188 = Order()
11112 
            _elem188.read(iprot)
11113 
            self.success.append(_elem188)
3064 chandransh 11114 
          iprot.readListEnd()
494 rajveer 11115 
        else:
11116 
          iprot.skip(ftype)
11117 
      elif fid == 1:
11118 
        if ftype == TType.STRUCT:
11119 
          self.ex = TransactionServiceException()
11120 
          self.ex.read(iprot)
11121 
        else:
11122 
          iprot.skip(ftype)
11123 
      else:
11124 
        iprot.skip(ftype)
11125 
      iprot.readFieldEnd()
11126 
    iprot.readStructEnd()
11127 
 
11128 
  def write(self, oprot):
11129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11131 
      return
3064 chandransh 11132 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11133 
    if self.success is not None:
3064 chandransh 11134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11136 
      for iter189 in self.success:
11137 
        iter189.write(oprot)
3064 chandransh 11138 
      oprot.writeListEnd()
494 rajveer 11139 
      oprot.writeFieldEnd()
3431 rajveer 11140 
    if self.ex is not None:
494 rajveer 11141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11142 
      self.ex.write(oprot)
11143 
      oprot.writeFieldEnd()
11144 
    oprot.writeFieldStop()
11145 
    oprot.writeStructEnd()
11146 
 
3431 rajveer 11147 
  def validate(self):
11148 
    return
11149 
 
11150 
 
494 rajveer 11151 
  def __repr__(self):
11152 
    L = ['%s=%r' % (key, value)
11153 
      for key, value in self.__dict__.iteritems()]
11154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11155 
 
11156 
  def __eq__(self, other):
11157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11158 
 
11159 
  def __ne__(self, other):
11160 
    return not (self == other)
11161 
 
3064 chandransh 11162 
class getOrdersForCustomer_args:
1149 chandransh 11163 
  """
11164 
  Attributes:
3064 chandransh 11165 
   - customerId
11166 
   - from_date
11167 
   - to_date
11168 
   - statuses
1149 chandransh 11169 
  """
11170 
 
11171 
  thrift_spec = (
11172 
    None, # 0
3064 chandransh 11173 
    (1, TType.I64, 'customerId', None, None, ), # 1
11174 
    (2, TType.I64, 'from_date', None, None, ), # 2
11175 
    (3, TType.I64, 'to_date', None, None, ), # 3
11176 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11177 
  )
11178 
 
3064 chandransh 11179 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11180 
    self.customerId = customerId
11181 
    self.from_date = from_date
11182 
    self.to_date = to_date
11183 
    self.statuses = statuses
1149 chandransh 11184 
 
11185 
  def read(self, iprot):
11186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11188 
      return
11189 
    iprot.readStructBegin()
11190 
    while True:
11191 
      (fname, ftype, fid) = iprot.readFieldBegin()
11192 
      if ftype == TType.STOP:
11193 
        break
11194 
      if fid == 1:
11195 
        if ftype == TType.I64:
3064 chandransh 11196 
          self.customerId = iprot.readI64();
1149 chandransh 11197 
        else:
11198 
          iprot.skip(ftype)
11199 
      elif fid == 2:
11200 
        if ftype == TType.I64:
3064 chandransh 11201 
          self.from_date = iprot.readI64();
1149 chandransh 11202 
        else:
11203 
          iprot.skip(ftype)
2783 chandransh 11204 
      elif fid == 3:
11205 
        if ftype == TType.I64:
3064 chandransh 11206 
          self.to_date = iprot.readI64();
2783 chandransh 11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      elif fid == 4:
3064 chandransh 11210 
        if ftype == TType.LIST:
11211 
          self.statuses = []
6188 rajveer 11212 
          (_etype193, _size190) = iprot.readListBegin()
11213 
          for _i194 in xrange(_size190):
11214 
            _elem195 = iprot.readI32();
11215 
            self.statuses.append(_elem195)
3064 chandransh 11216 
          iprot.readListEnd()
2783 chandransh 11217 
        else:
11218 
          iprot.skip(ftype)
1149 chandransh 11219 
      else:
11220 
        iprot.skip(ftype)
11221 
      iprot.readFieldEnd()
11222 
    iprot.readStructEnd()
11223 
 
11224 
  def write(self, oprot):
11225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11227 
      return
3064 chandransh 11228 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11229 
    if self.customerId is not None:
3064 chandransh 11230 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11231 
      oprot.writeI64(self.customerId)
1149 chandransh 11232 
      oprot.writeFieldEnd()
3431 rajveer 11233 
    if self.from_date is not None:
3064 chandransh 11234 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11235 
      oprot.writeI64(self.from_date)
1149 chandransh 11236 
      oprot.writeFieldEnd()
3431 rajveer 11237 
    if self.to_date is not None:
3064 chandransh 11238 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11239 
      oprot.writeI64(self.to_date)
2783 chandransh 11240 
      oprot.writeFieldEnd()
3431 rajveer 11241 
    if self.statuses is not None:
3064 chandransh 11242 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11243 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11244 
      for iter196 in self.statuses:
11245 
        oprot.writeI32(iter196)
3064 chandransh 11246 
      oprot.writeListEnd()
2783 chandransh 11247 
      oprot.writeFieldEnd()
1149 chandransh 11248 
    oprot.writeFieldStop()
11249 
    oprot.writeStructEnd()
11250 
 
3431 rajveer 11251 
  def validate(self):
11252 
    return
11253 
 
11254 
 
1149 chandransh 11255 
  def __repr__(self):
11256 
    L = ['%s=%r' % (key, value)
11257 
      for key, value in self.__dict__.iteritems()]
11258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11259 
 
11260 
  def __eq__(self, other):
11261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11262 
 
11263 
  def __ne__(self, other):
11264 
    return not (self == other)
11265 
 
3064 chandransh 11266 
class getOrdersForCustomer_result:
1149 chandransh 11267 
  """
11268 
  Attributes:
11269 
   - success
11270 
   - ex
11271 
  """
11272 
 
11273 
  thrift_spec = (
3064 chandransh 11274 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11275 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11276 
  )
11277 
 
11278 
  def __init__(self, success=None, ex=None,):
11279 
    self.success = success
11280 
    self.ex = ex
11281 
 
11282 
  def read(self, iprot):
11283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11285 
      return
11286 
    iprot.readStructBegin()
11287 
    while True:
11288 
      (fname, ftype, fid) = iprot.readFieldBegin()
11289 
      if ftype == TType.STOP:
11290 
        break
11291 
      if fid == 0:
3064 chandransh 11292 
        if ftype == TType.LIST:
11293 
          self.success = []
6188 rajveer 11294 
          (_etype200, _size197) = iprot.readListBegin()
11295 
          for _i201 in xrange(_size197):
11296 
            _elem202 = Order()
11297 
            _elem202.read(iprot)
11298 
            self.success.append(_elem202)
3064 chandransh 11299 
          iprot.readListEnd()
1149 chandransh 11300 
        else:
11301 
          iprot.skip(ftype)
11302 
      elif fid == 1:
11303 
        if ftype == TType.STRUCT:
11304 
          self.ex = TransactionServiceException()
11305 
          self.ex.read(iprot)
11306 
        else:
11307 
          iprot.skip(ftype)
11308 
      else:
11309 
        iprot.skip(ftype)
11310 
      iprot.readFieldEnd()
11311 
    iprot.readStructEnd()
11312 
 
11313 
  def write(self, oprot):
11314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11316 
      return
3064 chandransh 11317 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11318 
    if self.success is not None:
3064 chandransh 11319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11321 
      for iter203 in self.success:
11322 
        iter203.write(oprot)
3064 chandransh 11323 
      oprot.writeListEnd()
1149 chandransh 11324 
      oprot.writeFieldEnd()
3431 rajveer 11325 
    if self.ex is not None:
1149 chandransh 11326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11327 
      self.ex.write(oprot)
11328 
      oprot.writeFieldEnd()
11329 
    oprot.writeFieldStop()
11330 
    oprot.writeStructEnd()
11331 
 
3431 rajveer 11332 
  def validate(self):
11333 
    return
11334 
 
11335 
 
1149 chandransh 11336 
  def __repr__(self):
11337 
    L = ['%s=%r' % (key, value)
11338 
      for key, value in self.__dict__.iteritems()]
11339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11340 
 
11341 
  def __eq__(self, other):
11342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11343 
 
11344 
  def __ne__(self, other):
11345 
    return not (self == other)
11346 
 
3064 chandransh 11347 
class createOrder_args:
921 rajveer 11348 
  """
11349 
  Attributes:
3064 chandransh 11350 
   - order
921 rajveer 11351 
  """
11352 
 
11353 
  thrift_spec = (
11354 
    None, # 0
3064 chandransh 11355 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11356 
  )
11357 
 
3064 chandransh 11358 
  def __init__(self, order=None,):
11359 
    self.order = order
921 rajveer 11360 
 
11361 
  def read(self, iprot):
11362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11364 
      return
11365 
    iprot.readStructBegin()
11366 
    while True:
11367 
      (fname, ftype, fid) = iprot.readFieldBegin()
11368 
      if ftype == TType.STOP:
11369 
        break
11370 
      if fid == 1:
3064 chandransh 11371 
        if ftype == TType.STRUCT:
11372 
          self.order = Order()
11373 
          self.order.read(iprot)
921 rajveer 11374 
        else:
11375 
          iprot.skip(ftype)
11376 
      else:
11377 
        iprot.skip(ftype)
11378 
      iprot.readFieldEnd()
11379 
    iprot.readStructEnd()
11380 
 
11381 
  def write(self, oprot):
11382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11384 
      return
3064 chandransh 11385 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11386 
    if self.order is not None:
3064 chandransh 11387 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11388 
      self.order.write(oprot)
921 rajveer 11389 
      oprot.writeFieldEnd()
11390 
    oprot.writeFieldStop()
11391 
    oprot.writeStructEnd()
11392 
 
3431 rajveer 11393 
  def validate(self):
11394 
    return
11395 
 
11396 
 
921 rajveer 11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
3064 chandransh 11408 
class createOrder_result:
921 rajveer 11409 
  """
11410 
  Attributes:
11411 
   - success
11412 
   - ex
11413 
  """
11414 
 
11415 
  thrift_spec = (
3064 chandransh 11416 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11417 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11418 
  )
11419 
 
11420 
  def __init__(self, success=None, ex=None,):
11421 
    self.success = success
11422 
    self.ex = ex
11423 
 
11424 
  def read(self, iprot):
11425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11427 
      return
11428 
    iprot.readStructBegin()
11429 
    while True:
11430 
      (fname, ftype, fid) = iprot.readFieldBegin()
11431 
      if ftype == TType.STOP:
11432 
        break
11433 
      if fid == 0:
3064 chandransh 11434 
        if ftype == TType.I64:
11435 
          self.success = iprot.readI64();
921 rajveer 11436 
        else:
11437 
          iprot.skip(ftype)
11438 
      elif fid == 1:
11439 
        if ftype == TType.STRUCT:
11440 
          self.ex = TransactionServiceException()
11441 
          self.ex.read(iprot)
11442 
        else:
11443 
          iprot.skip(ftype)
11444 
      else:
11445 
        iprot.skip(ftype)
11446 
      iprot.readFieldEnd()
11447 
    iprot.readStructEnd()
11448 
 
11449 
  def write(self, oprot):
11450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11452 
      return
3064 chandransh 11453 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11454 
    if self.success is not None:
3064 chandransh 11455 
      oprot.writeFieldBegin('success', TType.I64, 0)
11456 
      oprot.writeI64(self.success)
921 rajveer 11457 
      oprot.writeFieldEnd()
3431 rajveer 11458 
    if self.ex is not None:
921 rajveer 11459 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11460 
      self.ex.write(oprot)
11461 
      oprot.writeFieldEnd()
11462 
    oprot.writeFieldStop()
11463 
    oprot.writeStructEnd()
11464 
 
3431 rajveer 11465 
  def validate(self):
11466 
    return
11467 
 
11468 
 
921 rajveer 11469 
  def __repr__(self):
11470 
    L = ['%s=%r' % (key, value)
11471 
      for key, value in self.__dict__.iteritems()]
11472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11473 
 
11474 
  def __eq__(self, other):
11475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11476 
 
11477 
  def __ne__(self, other):
11478 
    return not (self == other)
11479 
 
3064 chandransh 11480 
class getOrder_args:
921 rajveer 11481 
  """
11482 
  Attributes:
3064 chandransh 11483 
   - id
921 rajveer 11484 
  """
11485 
 
11486 
  thrift_spec = (
11487 
    None, # 0
3064 chandransh 11488 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11489 
  )
11490 
 
3064 chandransh 11491 
  def __init__(self, id=None,):
11492 
    self.id = id
921 rajveer 11493 
 
11494 
  def read(self, iprot):
11495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11497 
      return
11498 
    iprot.readStructBegin()
11499 
    while True:
11500 
      (fname, ftype, fid) = iprot.readFieldBegin()
11501 
      if ftype == TType.STOP:
11502 
        break
11503 
      if fid == 1:
11504 
        if ftype == TType.I64:
3064 chandransh 11505 
          self.id = iprot.readI64();
921 rajveer 11506 
        else:
11507 
          iprot.skip(ftype)
11508 
      else:
11509 
        iprot.skip(ftype)
11510 
      iprot.readFieldEnd()
11511 
    iprot.readStructEnd()
11512 
 
11513 
  def write(self, oprot):
11514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11516 
      return
3064 chandransh 11517 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11518 
    if self.id is not None:
3064 chandransh 11519 
      oprot.writeFieldBegin('id', TType.I64, 1)
11520 
      oprot.writeI64(self.id)
921 rajveer 11521 
      oprot.writeFieldEnd()
11522 
    oprot.writeFieldStop()
11523 
    oprot.writeStructEnd()
11524 
 
3431 rajveer 11525 
  def validate(self):
11526 
    return
11527 
 
11528 
 
921 rajveer 11529 
  def __repr__(self):
11530 
    L = ['%s=%r' % (key, value)
11531 
      for key, value in self.__dict__.iteritems()]
11532 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11533 
 
11534 
  def __eq__(self, other):
11535 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11536 
 
11537 
  def __ne__(self, other):
11538 
    return not (self == other)
11539 
 
3064 chandransh 11540 
class getOrder_result:
921 rajveer 11541 
  """
11542 
  Attributes:
11543 
   - success
11544 
   - ex
11545 
  """
11546 
 
11547 
  thrift_spec = (
3064 chandransh 11548 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11549 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11550 
  )
11551 
 
11552 
  def __init__(self, success=None, ex=None,):
11553 
    self.success = success
11554 
    self.ex = ex
11555 
 
11556 
  def read(self, iprot):
11557 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11558 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11559 
      return
11560 
    iprot.readStructBegin()
11561 
    while True:
11562 
      (fname, ftype, fid) = iprot.readFieldBegin()
11563 
      if ftype == TType.STOP:
11564 
        break
11565 
      if fid == 0:
3064 chandransh 11566 
        if ftype == TType.STRUCT:
11567 
          self.success = Order()
11568 
          self.success.read(iprot)
921 rajveer 11569 
        else:
11570 
          iprot.skip(ftype)
11571 
      elif fid == 1:
11572 
        if ftype == TType.STRUCT:
11573 
          self.ex = TransactionServiceException()
11574 
          self.ex.read(iprot)
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
3064 chandransh 11586 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11587 
    if self.success is not None:
3064 chandransh 11588 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11589 
      self.success.write(oprot)
921 rajveer 11590 
      oprot.writeFieldEnd()
3431 rajveer 11591 
    if self.ex is not None:
921 rajveer 11592 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11593 
      self.ex.write(oprot)
11594 
      oprot.writeFieldEnd()
11595 
    oprot.writeFieldStop()
11596 
    oprot.writeStructEnd()
11597 
 
3431 rajveer 11598 
  def validate(self):
11599 
    return
11600 
 
11601 
 
921 rajveer 11602 
  def __repr__(self):
11603 
    L = ['%s=%r' % (key, value)
11604 
      for key, value in self.__dict__.iteritems()]
11605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11606 
 
11607 
  def __eq__(self, other):
11608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11609 
 
11610 
  def __ne__(self, other):
11611 
    return not (self == other)
11612 
 
3064 chandransh 11613 
class getLineItemsForOrder_args:
94 ashish 11614 
  """
11615 
  Attributes:
3064 chandransh 11616 
   - orderId
94 ashish 11617 
  """
11618 
 
11619 
  thrift_spec = (
11620 
    None, # 0
3064 chandransh 11621 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11622 
  )
11623 
 
3064 chandransh 11624 
  def __init__(self, orderId=None,):
11625 
    self.orderId = orderId
94 ashish 11626 
 
11627 
  def read(self, iprot):
11628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11630 
      return
11631 
    iprot.readStructBegin()
11632 
    while True:
11633 
      (fname, ftype, fid) = iprot.readFieldBegin()
11634 
      if ftype == TType.STOP:
11635 
        break
11636 
      if fid == 1:
11637 
        if ftype == TType.I64:
3064 chandransh 11638 
          self.orderId = iprot.readI64();
94 ashish 11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
3064 chandransh 11650 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11651 
    if self.orderId is not None:
3064 chandransh 11652 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11653 
      oprot.writeI64(self.orderId)
94 ashish 11654 
      oprot.writeFieldEnd()
11655 
    oprot.writeFieldStop()
11656 
    oprot.writeStructEnd()
11657 
 
3431 rajveer 11658 
  def validate(self):
11659 
    return
11660 
 
11661 
 
94 ashish 11662 
  def __repr__(self):
11663 
    L = ['%s=%r' % (key, value)
11664 
      for key, value in self.__dict__.iteritems()]
11665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11666 
 
11667 
  def __eq__(self, other):
11668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11669 
 
11670 
  def __ne__(self, other):
11671 
    return not (self == other)
11672 
 
3064 chandransh 11673 
class getLineItemsForOrder_result:
94 ashish 11674 
  """
11675 
  Attributes:
11676 
   - success
11677 
   - ex
11678 
  """
11679 
 
11680 
  thrift_spec = (
3064 chandransh 11681 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11682 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11683 
  )
11684 
 
11685 
  def __init__(self, success=None, ex=None,):
11686 
    self.success = success
11687 
    self.ex = ex
11688 
 
11689 
  def read(self, iprot):
11690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11692 
      return
11693 
    iprot.readStructBegin()
11694 
    while True:
11695 
      (fname, ftype, fid) = iprot.readFieldBegin()
11696 
      if ftype == TType.STOP:
11697 
        break
11698 
      if fid == 0:
483 rajveer 11699 
        if ftype == TType.LIST:
11700 
          self.success = []
6188 rajveer 11701 
          (_etype207, _size204) = iprot.readListBegin()
11702 
          for _i208 in xrange(_size204):
11703 
            _elem209 = LineItem()
11704 
            _elem209.read(iprot)
11705 
            self.success.append(_elem209)
483 rajveer 11706 
          iprot.readListEnd()
94 ashish 11707 
        else:
11708 
          iprot.skip(ftype)
11709 
      elif fid == 1:
11710 
        if ftype == TType.STRUCT:
11711 
          self.ex = TransactionServiceException()
11712 
          self.ex.read(iprot)
11713 
        else:
11714 
          iprot.skip(ftype)
11715 
      else:
11716 
        iprot.skip(ftype)
11717 
      iprot.readFieldEnd()
11718 
    iprot.readStructEnd()
11719 
 
11720 
  def write(self, oprot):
11721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11723 
      return
3064 chandransh 11724 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11725 
    if self.success is not None:
483 rajveer 11726 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11727 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11728 
      for iter210 in self.success:
11729 
        iter210.write(oprot)
483 rajveer 11730 
      oprot.writeListEnd()
94 ashish 11731 
      oprot.writeFieldEnd()
3431 rajveer 11732 
    if self.ex is not None:
94 ashish 11733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11734 
      self.ex.write(oprot)
11735 
      oprot.writeFieldEnd()
11736 
    oprot.writeFieldStop()
11737 
    oprot.writeStructEnd()
11738 
 
3431 rajveer 11739 
  def validate(self):
11740 
    return
11741 
 
11742 
 
94 ashish 11743 
  def __repr__(self):
11744 
    L = ['%s=%r' % (key, value)
11745 
      for key, value in self.__dict__.iteritems()]
11746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11747 
 
11748 
  def __eq__(self, other):
11749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11750 
 
11751 
  def __ne__(self, other):
11752 
    return not (self == other)
11753 
 
4999 phani.kuma 11754 
class getOrderList_args:
11755 
  """
11756 
  Attributes:
11757 
   - order_ids
11758 
  """
11759 
 
11760 
  thrift_spec = (
11761 
    None, # 0
11762 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11763 
  )
11764 
 
11765 
  def __init__(self, order_ids=None,):
11766 
    self.order_ids = order_ids
11767 
 
11768 
  def read(self, iprot):
11769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11771 
      return
11772 
    iprot.readStructBegin()
11773 
    while True:
11774 
      (fname, ftype, fid) = iprot.readFieldBegin()
11775 
      if ftype == TType.STOP:
11776 
        break
11777 
      if fid == 1:
11778 
        if ftype == TType.LIST:
11779 
          self.order_ids = []
6188 rajveer 11780 
          (_etype214, _size211) = iprot.readListBegin()
11781 
          for _i215 in xrange(_size211):
11782 
            _elem216 = iprot.readI64();
11783 
            self.order_ids.append(_elem216)
4999 phani.kuma 11784 
          iprot.readListEnd()
11785 
        else:
11786 
          iprot.skip(ftype)
11787 
      else:
11788 
        iprot.skip(ftype)
11789 
      iprot.readFieldEnd()
11790 
    iprot.readStructEnd()
11791 
 
11792 
  def write(self, oprot):
11793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11795 
      return
11796 
    oprot.writeStructBegin('getOrderList_args')
11797 
    if self.order_ids is not None:
11798 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11799 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11800 
      for iter217 in self.order_ids:
11801 
        oprot.writeI64(iter217)
4999 phani.kuma 11802 
      oprot.writeListEnd()
11803 
      oprot.writeFieldEnd()
11804 
    oprot.writeFieldStop()
11805 
    oprot.writeStructEnd()
11806 
 
11807 
  def validate(self):
11808 
    return
11809 
 
11810 
 
11811 
  def __repr__(self):
11812 
    L = ['%s=%r' % (key, value)
11813 
      for key, value in self.__dict__.iteritems()]
11814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11815 
 
11816 
  def __eq__(self, other):
11817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11818 
 
11819 
  def __ne__(self, other):
11820 
    return not (self == other)
11821 
 
11822 
class getOrderList_result:
11823 
  """
11824 
  Attributes:
11825 
   - success
11826 
  """
11827 
 
11828 
  thrift_spec = (
11829 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11830 
  )
11831 
 
11832 
  def __init__(self, success=None,):
11833 
    self.success = success
11834 
 
11835 
  def read(self, iprot):
11836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11838 
      return
11839 
    iprot.readStructBegin()
11840 
    while True:
11841 
      (fname, ftype, fid) = iprot.readFieldBegin()
11842 
      if ftype == TType.STOP:
11843 
        break
11844 
      if fid == 0:
11845 
        if ftype == TType.LIST:
11846 
          self.success = []
6188 rajveer 11847 
          (_etype221, _size218) = iprot.readListBegin()
11848 
          for _i222 in xrange(_size218):
11849 
            _elem223 = Order()
11850 
            _elem223.read(iprot)
11851 
            self.success.append(_elem223)
4999 phani.kuma 11852 
          iprot.readListEnd()
11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      else:
11856 
        iprot.skip(ftype)
11857 
      iprot.readFieldEnd()
11858 
    iprot.readStructEnd()
11859 
 
11860 
  def write(self, oprot):
11861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11863 
      return
11864 
    oprot.writeStructBegin('getOrderList_result')
11865 
    if self.success is not None:
11866 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11867 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11868 
      for iter224 in self.success:
11869 
        iter224.write(oprot)
4999 phani.kuma 11870 
      oprot.writeListEnd()
11871 
      oprot.writeFieldEnd()
11872 
    oprot.writeFieldStop()
11873 
    oprot.writeStructEnd()
11874 
 
11875 
  def validate(self):
11876 
    return
11877 
 
11878 
 
11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
5386 phani.kuma 11890 
class getOrderListForVendor_args:
11891 
  """
11892 
  Attributes:
11893 
   - order_ids
11894 
   - vendorId
11895 
  """
11896 
 
11897 
  thrift_spec = (
11898 
    None, # 0
11899 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11900 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11901 
  )
11902 
 
11903 
  def __init__(self, order_ids=None, vendorId=None,):
11904 
    self.order_ids = order_ids
11905 
    self.vendorId = vendorId
11906 
 
11907 
  def read(self, iprot):
11908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11910 
      return
11911 
    iprot.readStructBegin()
11912 
    while True:
11913 
      (fname, ftype, fid) = iprot.readFieldBegin()
11914 
      if ftype == TType.STOP:
11915 
        break
11916 
      if fid == 1:
11917 
        if ftype == TType.LIST:
11918 
          self.order_ids = []
6188 rajveer 11919 
          (_etype228, _size225) = iprot.readListBegin()
11920 
          for _i229 in xrange(_size225):
11921 
            _elem230 = iprot.readI64();
11922 
            self.order_ids.append(_elem230)
5386 phani.kuma 11923 
          iprot.readListEnd()
11924 
        else:
11925 
          iprot.skip(ftype)
11926 
      elif fid == 2:
11927 
        if ftype == TType.I64:
11928 
          self.vendorId = iprot.readI64();
11929 
        else:
11930 
          iprot.skip(ftype)
11931 
      else:
11932 
        iprot.skip(ftype)
11933 
      iprot.readFieldEnd()
11934 
    iprot.readStructEnd()
11935 
 
11936 
  def write(self, oprot):
11937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11939 
      return
11940 
    oprot.writeStructBegin('getOrderListForVendor_args')
11941 
    if self.order_ids is not None:
11942 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11943 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11944 
      for iter231 in self.order_ids:
11945 
        oprot.writeI64(iter231)
5386 phani.kuma 11946 
      oprot.writeListEnd()
11947 
      oprot.writeFieldEnd()
11948 
    if self.vendorId is not None:
11949 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11950 
      oprot.writeI64(self.vendorId)
11951 
      oprot.writeFieldEnd()
11952 
    oprot.writeFieldStop()
11953 
    oprot.writeStructEnd()
11954 
 
11955 
  def validate(self):
11956 
    return
11957 
 
11958 
 
11959 
  def __repr__(self):
11960 
    L = ['%s=%r' % (key, value)
11961 
      for key, value in self.__dict__.iteritems()]
11962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11963 
 
11964 
  def __eq__(self, other):
11965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11966 
 
11967 
  def __ne__(self, other):
11968 
    return not (self == other)
11969 
 
11970 
class getOrderListForVendor_result:
11971 
  """
11972 
  Attributes:
11973 
   - success
11974 
  """
11975 
 
11976 
  thrift_spec = (
11977 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11978 
  )
11979 
 
11980 
  def __init__(self, success=None,):
11981 
    self.success = success
11982 
 
11983 
  def read(self, iprot):
11984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11986 
      return
11987 
    iprot.readStructBegin()
11988 
    while True:
11989 
      (fname, ftype, fid) = iprot.readFieldBegin()
11990 
      if ftype == TType.STOP:
11991 
        break
11992 
      if fid == 0:
11993 
        if ftype == TType.LIST:
11994 
          self.success = []
6188 rajveer 11995 
          (_etype235, _size232) = iprot.readListBegin()
11996 
          for _i236 in xrange(_size232):
11997 
            _elem237 = Order()
11998 
            _elem237.read(iprot)
11999 
            self.success.append(_elem237)
5386 phani.kuma 12000 
          iprot.readListEnd()
12001 
        else:
12002 
          iprot.skip(ftype)
12003 
      else:
12004 
        iprot.skip(ftype)
12005 
      iprot.readFieldEnd()
12006 
    iprot.readStructEnd()
12007 
 
12008 
  def write(self, oprot):
12009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12011 
      return
12012 
    oprot.writeStructBegin('getOrderListForVendor_result')
12013 
    if self.success is not None:
12014 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12015 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12016 
      for iter238 in self.success:
12017 
        iter238.write(oprot)
5386 phani.kuma 12018 
      oprot.writeListEnd()
12019 
      oprot.writeFieldEnd()
12020 
    oprot.writeFieldStop()
12021 
    oprot.writeStructEnd()
12022 
 
12023 
  def validate(self):
12024 
    return
12025 
 
12026 
 
12027 
  def __repr__(self):
12028 
    L = ['%s=%r' % (key, value)
12029 
      for key, value in self.__dict__.iteritems()]
12030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12031 
 
12032 
  def __eq__(self, other):
12033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12034 
 
12035 
  def __ne__(self, other):
12036 
    return not (self == other)
12037 
 
3064 chandransh 12038 
class getOrderForCustomer_args:
94 ashish 12039 
  """
12040 
  Attributes:
3064 chandransh 12041 
   - orderId
483 rajveer 12042 
   - customerId
94 ashish 12043 
  """
12044 
 
12045 
  thrift_spec = (
12046 
    None, # 0
3064 chandransh 12047 
    (1, TType.I64, 'orderId', None, None, ), # 1
12048 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12049 
  )
12050 
 
3064 chandransh 12051 
  def __init__(self, orderId=None, customerId=None,):
12052 
    self.orderId = orderId
483 rajveer 12053 
    self.customerId = customerId
94 ashish 12054 
 
12055 
  def read(self, iprot):
12056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12058 
      return
12059 
    iprot.readStructBegin()
12060 
    while True:
12061 
      (fname, ftype, fid) = iprot.readFieldBegin()
12062 
      if ftype == TType.STOP:
12063 
        break
12064 
      if fid == 1:
12065 
        if ftype == TType.I64:
3064 chandransh 12066 
          self.orderId = iprot.readI64();
94 ashish 12067 
        else:
12068 
          iprot.skip(ftype)
12069 
      elif fid == 2:
12070 
        if ftype == TType.I64:
3064 chandransh 12071 
          self.customerId = iprot.readI64();
94 ashish 12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
3064 chandransh 12083 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12084 
    if self.orderId is not None:
3064 chandransh 12085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12086 
      oprot.writeI64(self.orderId)
12087 
      oprot.writeFieldEnd()
3431 rajveer 12088 
    if self.customerId is not None:
3064 chandransh 12089 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12090 
      oprot.writeI64(self.customerId)
94 ashish 12091 
      oprot.writeFieldEnd()
12092 
    oprot.writeFieldStop()
12093 
    oprot.writeStructEnd()
12094 
 
3431 rajveer 12095 
  def validate(self):
12096 
    return
12097 
 
12098 
 
94 ashish 12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
3064 chandransh 12110 
class getOrderForCustomer_result:
94 ashish 12111 
  """
12112 
  Attributes:
12113 
   - success
12114 
   - ex
12115 
  """
12116 
 
12117 
  thrift_spec = (
3064 chandransh 12118 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12119 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12120 
  )
12121 
 
12122 
  def __init__(self, success=None, ex=None,):
12123 
    self.success = success
12124 
    self.ex = ex
12125 
 
12126 
  def read(self, iprot):
12127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12129 
      return
12130 
    iprot.readStructBegin()
12131 
    while True:
12132 
      (fname, ftype, fid) = iprot.readFieldBegin()
12133 
      if ftype == TType.STOP:
12134 
        break
12135 
      if fid == 0:
3064 chandransh 12136 
        if ftype == TType.STRUCT:
12137 
          self.success = Order()
12138 
          self.success.read(iprot)
94 ashish 12139 
        else:
12140 
          iprot.skip(ftype)
12141 
      elif fid == 1:
12142 
        if ftype == TType.STRUCT:
12143 
          self.ex = TransactionServiceException()
12144 
          self.ex.read(iprot)
12145 
        else:
12146 
          iprot.skip(ftype)
12147 
      else:
12148 
        iprot.skip(ftype)
12149 
      iprot.readFieldEnd()
12150 
    iprot.readStructEnd()
12151 
 
12152 
  def write(self, oprot):
12153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12155 
      return
3064 chandransh 12156 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12157 
    if self.success is not None:
3064 chandransh 12158 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12159 
      self.success.write(oprot)
94 ashish 12160 
      oprot.writeFieldEnd()
3431 rajveer 12161 
    if self.ex is not None:
94 ashish 12162 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12163 
      self.ex.write(oprot)
12164 
      oprot.writeFieldEnd()
12165 
    oprot.writeFieldStop()
12166 
    oprot.writeStructEnd()
12167 
 
3431 rajveer 12168 
  def validate(self):
12169 
    return
12170 
 
12171 
 
94 ashish 12172 
  def __repr__(self):
12173 
    L = ['%s=%r' % (key, value)
12174 
      for key, value in self.__dict__.iteritems()]
12175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12176 
 
12177 
  def __eq__(self, other):
12178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12179 
 
12180 
  def __ne__(self, other):
12181 
    return not (self == other)
12182 
 
3064 chandransh 12183 
class getAlerts_args:
94 ashish 12184 
  """
12185 
  Attributes:
4394 rajveer 12186 
   - type
4444 rajveer 12187 
   - warehouseId
4394 rajveer 12188 
   - status
12189 
   - timestamp
94 ashish 12190 
  """
12191 
 
12192 
  thrift_spec = (
12193 
    None, # 0
4394 rajveer 12194 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12195 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12196 
    (3, TType.I64, 'status', None, None, ), # 3
12197 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12198 
  )
12199 
 
4444 rajveer 12200 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12201 
    self.type = type
4444 rajveer 12202 
    self.warehouseId = warehouseId
4394 rajveer 12203 
    self.status = status
12204 
    self.timestamp = timestamp
94 ashish 12205 
 
12206 
  def read(self, iprot):
12207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12209 
      return
12210 
    iprot.readStructBegin()
12211 
    while True:
12212 
      (fname, ftype, fid) = iprot.readFieldBegin()
12213 
      if ftype == TType.STOP:
12214 
        break
12215 
      if fid == 1:
3064 chandransh 12216 
        if ftype == TType.I64:
4394 rajveer 12217 
          self.type = iprot.readI64();
94 ashish 12218 
        else:
12219 
          iprot.skip(ftype)
3064 chandransh 12220 
      elif fid == 2:
4394 rajveer 12221 
        if ftype == TType.I64:
4444 rajveer 12222 
          self.warehouseId = iprot.readI64();
3064 chandransh 12223 
        else:
12224 
          iprot.skip(ftype)
4394 rajveer 12225 
      elif fid == 3:
12226 
        if ftype == TType.I64:
4444 rajveer 12227 
          self.status = iprot.readI64();
12228 
        else:
12229 
          iprot.skip(ftype)
12230 
      elif fid == 4:
12231 
        if ftype == TType.I64:
4394 rajveer 12232 
          self.timestamp = iprot.readI64();
12233 
        else:
12234 
          iprot.skip(ftype)
94 ashish 12235 
      else:
12236 
        iprot.skip(ftype)
12237 
      iprot.readFieldEnd()
12238 
    iprot.readStructEnd()
12239 
 
12240 
  def write(self, oprot):
12241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12243 
      return
3064 chandransh 12244 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12245 
    if self.type is not None:
12246 
      oprot.writeFieldBegin('type', TType.I64, 1)
12247 
      oprot.writeI64(self.type)
94 ashish 12248 
      oprot.writeFieldEnd()
4444 rajveer 12249 
    if self.warehouseId is not None:
12250 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12251 
      oprot.writeI64(self.warehouseId)
12252 
      oprot.writeFieldEnd()
4394 rajveer 12253 
    if self.status is not None:
4444 rajveer 12254 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12255 
      oprot.writeI64(self.status)
3064 chandransh 12256 
      oprot.writeFieldEnd()
4394 rajveer 12257 
    if self.timestamp is not None:
4444 rajveer 12258 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12259 
      oprot.writeI64(self.timestamp)
12260 
      oprot.writeFieldEnd()
94 ashish 12261 
    oprot.writeFieldStop()
12262 
    oprot.writeStructEnd()
12263 
 
3431 rajveer 12264 
  def validate(self):
12265 
    return
12266 
 
12267 
 
94 ashish 12268 
  def __repr__(self):
12269 
    L = ['%s=%r' % (key, value)
12270 
      for key, value in self.__dict__.iteritems()]
12271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12272 
 
12273 
  def __eq__(self, other):
12274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12275 
 
12276 
  def __ne__(self, other):
12277 
    return not (self == other)
12278 
 
3064 chandransh 12279 
class getAlerts_result:
94 ashish 12280 
  """
12281 
  Attributes:
12282 
   - success
12283 
  """
12284 
 
12285 
  thrift_spec = (
3064 chandransh 12286 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12287 
  )
12288 
 
3064 chandransh 12289 
  def __init__(self, success=None,):
94 ashish 12290 
    self.success = success
12291 
 
12292 
  def read(self, iprot):
12293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12295 
      return
12296 
    iprot.readStructBegin()
12297 
    while True:
12298 
      (fname, ftype, fid) = iprot.readFieldBegin()
12299 
      if ftype == TType.STOP:
12300 
        break
12301 
      if fid == 0:
3064 chandransh 12302 
        if ftype == TType.LIST:
12303 
          self.success = []
6188 rajveer 12304 
          (_etype242, _size239) = iprot.readListBegin()
12305 
          for _i243 in xrange(_size239):
12306 
            _elem244 = Alert()
12307 
            _elem244.read(iprot)
12308 
            self.success.append(_elem244)
3064 chandransh 12309 
          iprot.readListEnd()
94 ashish 12310 
        else:
12311 
          iprot.skip(ftype)
12312 
      else:
12313 
        iprot.skip(ftype)
12314 
      iprot.readFieldEnd()
12315 
    iprot.readStructEnd()
12316 
 
12317 
  def write(self, oprot):
12318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12320 
      return
3064 chandransh 12321 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12322 
    if self.success is not None:
3064 chandransh 12323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12324 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12325 
      for iter245 in self.success:
12326 
        iter245.write(oprot)
3064 chandransh 12327 
      oprot.writeListEnd()
94 ashish 12328 
      oprot.writeFieldEnd()
12329 
    oprot.writeFieldStop()
12330 
    oprot.writeStructEnd()
12331 
 
3431 rajveer 12332 
  def validate(self):
12333 
    return
12334 
 
12335 
 
94 ashish 12336 
  def __repr__(self):
12337 
    L = ['%s=%r' % (key, value)
12338 
      for key, value in self.__dict__.iteritems()]
12339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12340 
 
12341 
  def __eq__(self, other):
12342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12343 
 
12344 
  def __ne__(self, other):
12345 
    return not (self == other)
12346 
 
4394 rajveer 12347 
class addAlert_args:
94 ashish 12348 
  """
12349 
  Attributes:
3064 chandransh 12350 
   - type
4444 rajveer 12351 
   - warehouseId
4394 rajveer 12352 
   - description
94 ashish 12353 
  """
12354 
 
12355 
  thrift_spec = (
12356 
    None, # 0
4394 rajveer 12357 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12358 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12359 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12360 
  )
12361 
 
4444 rajveer 12362 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12363 
    self.type = type
4444 rajveer 12364 
    self.warehouseId = warehouseId
4394 rajveer 12365 
    self.description = description
94 ashish 12366 
 
12367 
  def read(self, iprot):
12368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12370 
      return
12371 
    iprot.readStructBegin()
12372 
    while True:
12373 
      (fname, ftype, fid) = iprot.readFieldBegin()
12374 
      if ftype == TType.STOP:
12375 
        break
12376 
      if fid == 1:
12377 
        if ftype == TType.I64:
4394 rajveer 12378 
          self.type = iprot.readI64();
94 ashish 12379 
        else:
12380 
          iprot.skip(ftype)
3064 chandransh 12381 
      elif fid == 2:
4444 rajveer 12382 
        if ftype == TType.I64:
12383 
          self.warehouseId = iprot.readI64();
12384 
        else:
12385 
          iprot.skip(ftype)
12386 
      elif fid == 3:
3064 chandransh 12387 
        if ftype == TType.STRING:
4394 rajveer 12388 
          self.description = iprot.readString();
3064 chandransh 12389 
        else:
12390 
          iprot.skip(ftype)
94 ashish 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_args')
3431 rajveer 12401 
    if self.type is not None:
4394 rajveer 12402 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12403 
      oprot.writeI64(self.type)
12404 
      oprot.writeFieldEnd()
4444 rajveer 12405 
    if self.warehouseId is not None:
12406 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12407 
      oprot.writeI64(self.warehouseId)
12408 
      oprot.writeFieldEnd()
4394 rajveer 12409 
    if self.description is not None:
4444 rajveer 12410 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12411 
      oprot.writeString(self.description)
3064 chandransh 12412 
      oprot.writeFieldEnd()
94 ashish 12413 
    oprot.writeFieldStop()
12414 
    oprot.writeStructEnd()
12415 
 
3431 rajveer 12416 
  def validate(self):
12417 
    return
12418 
 
12419 
 
94 ashish 12420 
  def __repr__(self):
12421 
    L = ['%s=%r' % (key, value)
12422 
      for key, value in self.__dict__.iteritems()]
12423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12424 
 
12425 
  def __eq__(self, other):
12426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12427 
 
12428 
  def __ne__(self, other):
12429 
    return not (self == other)
12430 
 
4394 rajveer 12431 
class addAlert_result:
3064 chandransh 12432 
 
12433 
  thrift_spec = (
12434 
  )
12435 
 
12436 
  def read(self, iprot):
12437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12439 
      return
12440 
    iprot.readStructBegin()
12441 
    while True:
12442 
      (fname, ftype, fid) = iprot.readFieldBegin()
12443 
      if ftype == TType.STOP:
12444 
        break
12445 
      else:
12446 
        iprot.skip(ftype)
12447 
      iprot.readFieldEnd()
12448 
    iprot.readStructEnd()
12449 
 
12450 
  def write(self, oprot):
12451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12453 
      return
4394 rajveer 12454 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12455 
    oprot.writeFieldStop()
12456 
    oprot.writeStructEnd()
12457 
 
3431 rajveer 12458 
  def validate(self):
12459 
    return
12460 
 
12461 
 
3064 chandransh 12462 
  def __repr__(self):
12463 
    L = ['%s=%r' % (key, value)
12464 
      for key, value in self.__dict__.iteritems()]
12465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12466 
 
12467 
  def __eq__(self, other):
12468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12469 
 
12470 
  def __ne__(self, other):
12471 
    return not (self == other)
12472 
 
4444 rajveer 12473 
class markAlertsAsSeen_args:
12474 
  """
12475 
  Attributes:
12476 
   - warehouseId
12477 
  """
12478 
 
12479 
  thrift_spec = (
12480 
    None, # 0
12481 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12482 
  )
12483 
 
12484 
  def __init__(self, warehouseId=None,):
12485 
    self.warehouseId = warehouseId
12486 
 
12487 
  def read(self, iprot):
12488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12490 
      return
12491 
    iprot.readStructBegin()
12492 
    while True:
12493 
      (fname, ftype, fid) = iprot.readFieldBegin()
12494 
      if ftype == TType.STOP:
12495 
        break
12496 
      if fid == 1:
12497 
        if ftype == TType.I64:
12498 
          self.warehouseId = iprot.readI64();
12499 
        else:
12500 
          iprot.skip(ftype)
12501 
      else:
12502 
        iprot.skip(ftype)
12503 
      iprot.readFieldEnd()
12504 
    iprot.readStructEnd()
12505 
 
12506 
  def write(self, oprot):
12507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12509 
      return
12510 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12511 
    if self.warehouseId is not None:
12512 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12513 
      oprot.writeI64(self.warehouseId)
12514 
      oprot.writeFieldEnd()
12515 
    oprot.writeFieldStop()
12516 
    oprot.writeStructEnd()
12517 
 
12518 
  def validate(self):
12519 
    return
12520 
 
12521 
 
12522 
  def __repr__(self):
12523 
    L = ['%s=%r' % (key, value)
12524 
      for key, value in self.__dict__.iteritems()]
12525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12526 
 
12527 
  def __eq__(self, other):
12528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12529 
 
12530 
  def __ne__(self, other):
12531 
    return not (self == other)
12532 
 
12533 
class markAlertsAsSeen_result:
12534 
 
12535 
  thrift_spec = (
12536 
  )
12537 
 
12538 
  def read(self, iprot):
12539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12541 
      return
12542 
    iprot.readStructBegin()
12543 
    while True:
12544 
      (fname, ftype, fid) = iprot.readFieldBegin()
12545 
      if ftype == TType.STOP:
12546 
        break
12547 
      else:
12548 
        iprot.skip(ftype)
12549 
      iprot.readFieldEnd()
12550 
    iprot.readStructEnd()
12551 
 
12552 
  def write(self, oprot):
12553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12555 
      return
12556 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12557 
    oprot.writeFieldStop()
12558 
    oprot.writeStructEnd()
12559 
 
12560 
  def validate(self):
12561 
    return
12562 
 
12563 
 
12564 
  def __repr__(self):
12565 
    L = ['%s=%r' % (key, value)
12566 
      for key, value in self.__dict__.iteritems()]
12567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12568 
 
12569 
  def __eq__(self, other):
12570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12571 
 
12572 
  def __ne__(self, other):
12573 
    return not (self == other)
12574 
 
3064 chandransh 12575 
class getValidOrderCount_args:
12576 
 
12577 
  thrift_spec = (
12578 
  )
12579 
 
12580 
  def read(self, iprot):
12581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12583 
      return
12584 
    iprot.readStructBegin()
12585 
    while True:
12586 
      (fname, ftype, fid) = iprot.readFieldBegin()
12587 
      if ftype == TType.STOP:
12588 
        break
12589 
      else:
12590 
        iprot.skip(ftype)
12591 
      iprot.readFieldEnd()
12592 
    iprot.readStructEnd()
12593 
 
12594 
  def write(self, oprot):
12595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12597 
      return
12598 
    oprot.writeStructBegin('getValidOrderCount_args')
12599 
    oprot.writeFieldStop()
12600 
    oprot.writeStructEnd()
12601 
 
3431 rajveer 12602 
  def validate(self):
12603 
    return
12604 
 
12605 
 
3064 chandransh 12606 
  def __repr__(self):
12607 
    L = ['%s=%r' % (key, value)
12608 
      for key, value in self.__dict__.iteritems()]
12609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12610 
 
12611 
  def __eq__(self, other):
12612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12613 
 
12614 
  def __ne__(self, other):
12615 
    return not (self == other)
12616 
 
12617 
class getValidOrderCount_result:
94 ashish 12618 
  """
12619 
  Attributes:
12620 
   - success
12621 
  """
12622 
 
12623 
  thrift_spec = (
3064 chandransh 12624 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12625 
  )
12626 
 
3064 chandransh 12627 
  def __init__(self, success=None,):
94 ashish 12628 
    self.success = success
12629 
 
12630 
  def read(self, iprot):
12631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12633 
      return
12634 
    iprot.readStructBegin()
12635 
    while True:
12636 
      (fname, ftype, fid) = iprot.readFieldBegin()
12637 
      if ftype == TType.STOP:
12638 
        break
12639 
      if fid == 0:
3064 chandransh 12640 
        if ftype == TType.I64:
12641 
          self.success = iprot.readI64();
94 ashish 12642 
        else:
12643 
          iprot.skip(ftype)
12644 
      else:
12645 
        iprot.skip(ftype)
12646 
      iprot.readFieldEnd()
12647 
    iprot.readStructEnd()
12648 
 
12649 
  def write(self, oprot):
12650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12652 
      return
3064 chandransh 12653 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12654 
    if self.success is not None:
3064 chandransh 12655 
      oprot.writeFieldBegin('success', TType.I64, 0)
12656 
      oprot.writeI64(self.success)
94 ashish 12657 
      oprot.writeFieldEnd()
12658 
    oprot.writeFieldStop()
12659 
    oprot.writeStructEnd()
12660 
 
3431 rajveer 12661 
  def validate(self):
12662 
    return
12663 
 
12664 
 
94 ashish 12665 
  def __repr__(self):
12666 
    L = ['%s=%r' % (key, value)
12667 
      for key, value in self.__dict__.iteritems()]
12668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12669 
 
12670 
  def __eq__(self, other):
12671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12672 
 
12673 
  def __ne__(self, other):
12674 
    return not (self == other)
12675 
 
3064 chandransh 12676 
class getNoOfCustomersWithSuccessfulTransaction_args:
12677 
 
12678 
  thrift_spec = (
12679 
  )
12680 
 
12681 
  def read(self, iprot):
12682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12684 
      return
12685 
    iprot.readStructBegin()
12686 
    while True:
12687 
      (fname, ftype, fid) = iprot.readFieldBegin()
12688 
      if ftype == TType.STOP:
12689 
        break
12690 
      else:
12691 
        iprot.skip(ftype)
12692 
      iprot.readFieldEnd()
12693 
    iprot.readStructEnd()
12694 
 
12695 
  def write(self, oprot):
12696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12698 
      return
12699 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12700 
    oprot.writeFieldStop()
12701 
    oprot.writeStructEnd()
12702 
 
3431 rajveer 12703 
  def validate(self):
12704 
    return
12705 
 
12706 
 
3064 chandransh 12707 
  def __repr__(self):
12708 
    L = ['%s=%r' % (key, value)
12709 
      for key, value in self.__dict__.iteritems()]
12710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12711 
 
12712 
  def __eq__(self, other):
12713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12714 
 
12715 
  def __ne__(self, other):
12716 
    return not (self == other)
12717 
 
12718 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12719 
  """
12720 
  Attributes:
3064 chandransh 12721 
   - success
94 ashish 12722 
  """
12723 
 
12724 
  thrift_spec = (
3064 chandransh 12725 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12726 
  )
12727 
 
3064 chandransh 12728 
  def __init__(self, success=None,):
12729 
    self.success = success
94 ashish 12730 
 
12731 
  def read(self, iprot):
12732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12734 
      return
12735 
    iprot.readStructBegin()
12736 
    while True:
12737 
      (fname, ftype, fid) = iprot.readFieldBegin()
12738 
      if ftype == TType.STOP:
12739 
        break
3064 chandransh 12740 
      if fid == 0:
94 ashish 12741 
        if ftype == TType.I64:
3064 chandransh 12742 
          self.success = iprot.readI64();
94 ashish 12743 
        else:
12744 
          iprot.skip(ftype)
12745 
      else:
12746 
        iprot.skip(ftype)
12747 
      iprot.readFieldEnd()
12748 
    iprot.readStructEnd()
12749 
 
12750 
  def write(self, oprot):
12751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12753 
      return
3064 chandransh 12754 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12755 
    if self.success is not None:
3064 chandransh 12756 
      oprot.writeFieldBegin('success', TType.I64, 0)
12757 
      oprot.writeI64(self.success)
94 ashish 12758 
      oprot.writeFieldEnd()
12759 
    oprot.writeFieldStop()
12760 
    oprot.writeStructEnd()
12761 
 
3431 rajveer 12762 
  def validate(self):
12763 
    return
12764 
 
12765 
 
94 ashish 12766 
  def __repr__(self):
12767 
    L = ['%s=%r' % (key, value)
12768 
      for key, value in self.__dict__.iteritems()]
12769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12770 
 
12771 
  def __eq__(self, other):
12772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12773 
 
12774 
  def __ne__(self, other):
12775 
    return not (self == other)
12776 
 
3064 chandransh 12777 
class getValidOrdersAmountRange_args:
12778 
 
12779 
  thrift_spec = (
12780 
  )
12781 
 
12782 
  def read(self, iprot):
12783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12785 
      return
12786 
    iprot.readStructBegin()
12787 
    while True:
12788 
      (fname, ftype, fid) = iprot.readFieldBegin()
12789 
      if ftype == TType.STOP:
12790 
        break
12791 
      else:
12792 
        iprot.skip(ftype)
12793 
      iprot.readFieldEnd()
12794 
    iprot.readStructEnd()
12795 
 
12796 
  def write(self, oprot):
12797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12799 
      return
12800 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12801 
    oprot.writeFieldStop()
12802 
    oprot.writeStructEnd()
12803 
 
3431 rajveer 12804 
  def validate(self):
12805 
    return
12806 
 
12807 
 
3064 chandransh 12808 
  def __repr__(self):
12809 
    L = ['%s=%r' % (key, value)
12810 
      for key, value in self.__dict__.iteritems()]
12811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12812 
 
12813 
  def __eq__(self, other):
12814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12815 
 
12816 
  def __ne__(self, other):
12817 
    return not (self == other)
12818 
 
12819 
class getValidOrdersAmountRange_result:
94 ashish 12820 
  """
12821 
  Attributes:
12822 
   - success
12823 
  """
12824 
 
12825 
  thrift_spec = (
3064 chandransh 12826 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12827 
  )
12828 
 
3064 chandransh 12829 
  def __init__(self, success=None,):
94 ashish 12830 
    self.success = success
12831 
 
12832 
  def read(self, iprot):
12833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12835 
      return
12836 
    iprot.readStructBegin()
12837 
    while True:
12838 
      (fname, ftype, fid) = iprot.readFieldBegin()
12839 
      if ftype == TType.STOP:
12840 
        break
12841 
      if fid == 0:
483 rajveer 12842 
        if ftype == TType.LIST:
12843 
          self.success = []
6188 rajveer 12844 
          (_etype249, _size246) = iprot.readListBegin()
12845 
          for _i250 in xrange(_size246):
12846 
            _elem251 = iprot.readDouble();
12847 
            self.success.append(_elem251)
483 rajveer 12848 
          iprot.readListEnd()
94 ashish 12849 
        else:
12850 
          iprot.skip(ftype)
12851 
      else:
12852 
        iprot.skip(ftype)
12853 
      iprot.readFieldEnd()
12854 
    iprot.readStructEnd()
12855 
 
12856 
  def write(self, oprot):
12857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12859 
      return
3064 chandransh 12860 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12861 
    if self.success is not None:
483 rajveer 12862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12863 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12864 
      for iter252 in self.success:
12865 
        oprot.writeDouble(iter252)
483 rajveer 12866 
      oprot.writeListEnd()
94 ashish 12867 
      oprot.writeFieldEnd()
12868 
    oprot.writeFieldStop()
12869 
    oprot.writeStructEnd()
12870 
 
3431 rajveer 12871 
  def validate(self):
12872 
    return
12873 
 
12874 
 
94 ashish 12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
3064 chandransh 12886 
class getValidOrders_args:
1528 ankur.sing 12887 
  """
12888 
  Attributes:
3064 chandransh 12889 
   - limit
5874 rajveer 12890 
   - onlyStore
1528 ankur.sing 12891 
  """
12892 
 
12893 
  thrift_spec = (
12894 
    None, # 0
3064 chandransh 12895 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12896 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12897 
  )
12898 
 
5874 rajveer 12899 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12900 
    self.limit = limit
5874 rajveer 12901 
    self.onlyStore = onlyStore
1528 ankur.sing 12902 
 
12903 
  def read(self, iprot):
12904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12906 
      return
12907 
    iprot.readStructBegin()
12908 
    while True:
12909 
      (fname, ftype, fid) = iprot.readFieldBegin()
12910 
      if ftype == TType.STOP:
12911 
        break
12912 
      if fid == 1:
12913 
        if ftype == TType.I64:
3064 chandransh 12914 
          self.limit = iprot.readI64();
1528 ankur.sing 12915 
        else:
12916 
          iprot.skip(ftype)
5874 rajveer 12917 
      elif fid == 2:
12918 
        if ftype == TType.BOOL:
12919 
          self.onlyStore = iprot.readBool();
12920 
        else:
12921 
          iprot.skip(ftype)
1528 ankur.sing 12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
3064 chandransh 12931 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12932 
    if self.limit is not None:
3064 chandransh 12933 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12934 
      oprot.writeI64(self.limit)
1528 ankur.sing 12935 
      oprot.writeFieldEnd()
5874 rajveer 12936 
    if self.onlyStore is not None:
12937 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12938 
      oprot.writeBool(self.onlyStore)
12939 
      oprot.writeFieldEnd()
1528 ankur.sing 12940 
    oprot.writeFieldStop()
12941 
    oprot.writeStructEnd()
12942 
 
3431 rajveer 12943 
  def validate(self):
12944 
    return
12945 
 
12946 
 
1528 ankur.sing 12947 
  def __repr__(self):
12948 
    L = ['%s=%r' % (key, value)
12949 
      for key, value in self.__dict__.iteritems()]
12950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12951 
 
12952 
  def __eq__(self, other):
12953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12954 
 
12955 
  def __ne__(self, other):
12956 
    return not (self == other)
12957 
 
3064 chandransh 12958 
class getValidOrders_result:
1528 ankur.sing 12959 
  """
12960 
  Attributes:
12961 
   - success
12962 
  """
12963 
 
12964 
  thrift_spec = (
3064 chandransh 12965 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12966 
  )
12967 
 
3064 chandransh 12968 
  def __init__(self, success=None,):
1528 ankur.sing 12969 
    self.success = success
12970 
 
12971 
  def read(self, iprot):
12972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12974 
      return
12975 
    iprot.readStructBegin()
12976 
    while True:
12977 
      (fname, ftype, fid) = iprot.readFieldBegin()
12978 
      if ftype == TType.STOP:
12979 
        break
12980 
      if fid == 0:
3064 chandransh 12981 
        if ftype == TType.LIST:
12982 
          self.success = []
6188 rajveer 12983 
          (_etype256, _size253) = iprot.readListBegin()
12984 
          for _i257 in xrange(_size253):
12985 
            _elem258 = Order()
12986 
            _elem258.read(iprot)
12987 
            self.success.append(_elem258)
3064 chandransh 12988 
          iprot.readListEnd()
1528 ankur.sing 12989 
        else:
12990 
          iprot.skip(ftype)
12991 
      else:
12992 
        iprot.skip(ftype)
12993 
      iprot.readFieldEnd()
12994 
    iprot.readStructEnd()
12995 
 
12996 
  def write(self, oprot):
12997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12999 
      return
3064 chandransh 13000 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13001 
    if self.success is not None:
3064 chandransh 13002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13003 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13004 
      for iter259 in self.success:
13005 
        iter259.write(oprot)
3064 chandransh 13006 
      oprot.writeListEnd()
1528 ankur.sing 13007 
      oprot.writeFieldEnd()
13008 
    oprot.writeFieldStop()
13009 
    oprot.writeStructEnd()
13010 
 
3431 rajveer 13011 
  def validate(self):
13012 
    return
13013 
 
13014 
 
1528 ankur.sing 13015 
  def __repr__(self):
13016 
    L = ['%s=%r' % (key, value)
13017 
      for key, value in self.__dict__.iteritems()]
13018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13019 
 
13020 
  def __eq__(self, other):
13021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13022 
 
13023 
  def __ne__(self, other):
13024 
    return not (self == other)
13025 
 
1220 chandransh 13026 
class batchOrders_args:
13027 
  """
13028 
  Attributes:
13029 
   - warehouseId
13030 
  """
13031 
 
13032 
  thrift_spec = (
13033 
    None, # 0
13034 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13035 
  )
13036 
 
13037 
  def __init__(self, warehouseId=None,):
13038 
    self.warehouseId = warehouseId
13039 
 
13040 
  def read(self, iprot):
13041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13043 
      return
13044 
    iprot.readStructBegin()
13045 
    while True:
13046 
      (fname, ftype, fid) = iprot.readFieldBegin()
13047 
      if ftype == TType.STOP:
13048 
        break
13049 
      if fid == 1:
13050 
        if ftype == TType.I64:
13051 
          self.warehouseId = iprot.readI64();
13052 
        else:
13053 
          iprot.skip(ftype)
13054 
      else:
13055 
        iprot.skip(ftype)
13056 
      iprot.readFieldEnd()
13057 
    iprot.readStructEnd()
13058 
 
13059 
  def write(self, oprot):
13060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13062 
      return
13063 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13064 
    if self.warehouseId is not None:
1220 chandransh 13065 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13066 
      oprot.writeI64(self.warehouseId)
13067 
      oprot.writeFieldEnd()
13068 
    oprot.writeFieldStop()
13069 
    oprot.writeStructEnd()
13070 
 
3431 rajveer 13071 
  def validate(self):
13072 
    return
13073 
 
13074 
 
1220 chandransh 13075 
  def __repr__(self):
13076 
    L = ['%s=%r' % (key, value)
13077 
      for key, value in self.__dict__.iteritems()]
13078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13079 
 
13080 
  def __eq__(self, other):
13081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13082 
 
13083 
  def __ne__(self, other):
13084 
    return not (self == other)
13085 
 
13086 
class batchOrders_result:
13087 
  """
13088 
  Attributes:
13089 
   - success
13090 
   - ex
13091 
  """
13092 
 
13093 
  thrift_spec = (
13094 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13096 
  )
13097 
 
13098 
  def __init__(self, success=None, ex=None,):
13099 
    self.success = success
13100 
    self.ex = ex
13101 
 
13102 
  def read(self, iprot):
13103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13105 
      return
13106 
    iprot.readStructBegin()
13107 
    while True:
13108 
      (fname, ftype, fid) = iprot.readFieldBegin()
13109 
      if ftype == TType.STOP:
13110 
        break
13111 
      if fid == 0:
13112 
        if ftype == TType.LIST:
13113 
          self.success = []
6188 rajveer 13114 
          (_etype263, _size260) = iprot.readListBegin()
13115 
          for _i264 in xrange(_size260):
13116 
            _elem265 = Order()
13117 
            _elem265.read(iprot)
13118 
            self.success.append(_elem265)
1220 chandransh 13119 
          iprot.readListEnd()
13120 
        else:
13121 
          iprot.skip(ftype)
13122 
      elif fid == 1:
13123 
        if ftype == TType.STRUCT:
13124 
          self.ex = TransactionServiceException()
13125 
          self.ex.read(iprot)
13126 
        else:
13127 
          iprot.skip(ftype)
13128 
      else:
13129 
        iprot.skip(ftype)
13130 
      iprot.readFieldEnd()
13131 
    iprot.readStructEnd()
13132 
 
13133 
  def write(self, oprot):
13134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13136 
      return
13137 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13138 
    if self.success is not None:
1220 chandransh 13139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13141 
      for iter266 in self.success:
13142 
        iter266.write(oprot)
1220 chandransh 13143 
      oprot.writeListEnd()
13144 
      oprot.writeFieldEnd()
3431 rajveer 13145 
    if self.ex is not None:
1220 chandransh 13146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13147 
      self.ex.write(oprot)
13148 
      oprot.writeFieldEnd()
13149 
    oprot.writeFieldStop()
13150 
    oprot.writeStructEnd()
13151 
 
3431 rajveer 13152 
  def validate(self):
13153 
    return
13154 
 
13155 
 
1220 chandransh 13156 
  def __repr__(self):
13157 
    L = ['%s=%r' % (key, value)
13158 
      for key, value in self.__dict__.iteritems()]
13159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13160 
 
13161 
  def __eq__(self, other):
13162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13163 
 
13164 
  def __ne__(self, other):
13165 
    return not (self == other)
13166 
 
1208 chandransh 13167 
class markOrderAsOutOfStock_args:
13168 
  """
13169 
  Attributes:
13170 
   - orderId
13171 
  """
13172 
 
13173 
  thrift_spec = (
13174 
    None, # 0
13175 
    (1, TType.I64, 'orderId', None, None, ), # 1
13176 
  )
13177 
 
13178 
  def __init__(self, orderId=None,):
13179 
    self.orderId = orderId
13180 
 
13181 
  def read(self, iprot):
13182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13184 
      return
13185 
    iprot.readStructBegin()
13186 
    while True:
13187 
      (fname, ftype, fid) = iprot.readFieldBegin()
13188 
      if ftype == TType.STOP:
13189 
        break
13190 
      if fid == 1:
13191 
        if ftype == TType.I64:
13192 
          self.orderId = iprot.readI64();
13193 
        else:
13194 
          iprot.skip(ftype)
13195 
      else:
13196 
        iprot.skip(ftype)
13197 
      iprot.readFieldEnd()
13198 
    iprot.readStructEnd()
13199 
 
13200 
  def write(self, oprot):
13201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13203 
      return
13204 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13205 
    if self.orderId is not None:
1208 chandransh 13206 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13207 
      oprot.writeI64(self.orderId)
13208 
      oprot.writeFieldEnd()
13209 
    oprot.writeFieldStop()
13210 
    oprot.writeStructEnd()
13211 
 
3431 rajveer 13212 
  def validate(self):
13213 
    return
13214 
 
13215 
 
1208 chandransh 13216 
  def __repr__(self):
13217 
    L = ['%s=%r' % (key, value)
13218 
      for key, value in self.__dict__.iteritems()]
13219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13220 
 
13221 
  def __eq__(self, other):
13222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13223 
 
13224 
  def __ne__(self, other):
13225 
    return not (self == other)
13226 
 
13227 
class markOrderAsOutOfStock_result:
13228 
  """
13229 
  Attributes:
13230 
   - success
13231 
   - ex
13232 
  """
13233 
 
13234 
  thrift_spec = (
13235 
    (0, TType.BOOL, 'success', None, None, ), # 0
13236 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13237 
  )
13238 
 
13239 
  def __init__(self, success=None, ex=None,):
13240 
    self.success = success
13241 
    self.ex = ex
13242 
 
13243 
  def read(self, iprot):
13244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13246 
      return
13247 
    iprot.readStructBegin()
13248 
    while True:
13249 
      (fname, ftype, fid) = iprot.readFieldBegin()
13250 
      if ftype == TType.STOP:
13251 
        break
13252 
      if fid == 0:
13253 
        if ftype == TType.BOOL:
13254 
          self.success = iprot.readBool();
13255 
        else:
13256 
          iprot.skip(ftype)
13257 
      elif fid == 1:
13258 
        if ftype == TType.STRUCT:
13259 
          self.ex = TransactionServiceException()
13260 
          self.ex.read(iprot)
13261 
        else:
13262 
          iprot.skip(ftype)
13263 
      else:
13264 
        iprot.skip(ftype)
13265 
      iprot.readFieldEnd()
13266 
    iprot.readStructEnd()
13267 
 
13268 
  def write(self, oprot):
13269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13271 
      return
13272 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13273 
    if self.success is not None:
1208 chandransh 13274 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13275 
      oprot.writeBool(self.success)
13276 
      oprot.writeFieldEnd()
3431 rajveer 13277 
    if self.ex is not None:
1208 chandransh 13278 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13279 
      self.ex.write(oprot)
13280 
      oprot.writeFieldEnd()
13281 
    oprot.writeFieldStop()
13282 
    oprot.writeStructEnd()
13283 
 
3431 rajveer 13284 
  def validate(self):
13285 
    return
13286 
 
13287 
 
1208 chandransh 13288 
  def __repr__(self):
13289 
    L = ['%s=%r' % (key, value)
13290 
      for key, value in self.__dict__.iteritems()]
13291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13292 
 
13293 
  def __eq__(self, other):
13294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13295 
 
13296 
  def __ne__(self, other):
13297 
    return not (self == other)
13298 
 
3064 chandransh 13299 
class verifyOrder_args:
759 chandransh 13300 
  """
13301 
  Attributes:
3064 chandransh 13302 
   - orderId
759 chandransh 13303 
  """
13304 
 
13305 
  thrift_spec = (
13306 
    None, # 0
3064 chandransh 13307 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13308 
  )
13309 
 
3064 chandransh 13310 
  def __init__(self, orderId=None,):
13311 
    self.orderId = orderId
759 chandransh 13312 
 
13313 
  def read(self, iprot):
13314 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13315 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13316 
      return
13317 
    iprot.readStructBegin()
13318 
    while True:
13319 
      (fname, ftype, fid) = iprot.readFieldBegin()
13320 
      if ftype == TType.STOP:
13321 
        break
13322 
      if fid == 1:
13323 
        if ftype == TType.I64:
3064 chandransh 13324 
          self.orderId = iprot.readI64();
759 chandransh 13325 
        else:
13326 
          iprot.skip(ftype)
13327 
      else:
13328 
        iprot.skip(ftype)
13329 
      iprot.readFieldEnd()
13330 
    iprot.readStructEnd()
13331 
 
13332 
  def write(self, oprot):
13333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13335 
      return
3064 chandransh 13336 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13337 
    if self.orderId is not None:
3064 chandransh 13338 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13339 
      oprot.writeI64(self.orderId)
759 chandransh 13340 
      oprot.writeFieldEnd()
13341 
    oprot.writeFieldStop()
13342 
    oprot.writeStructEnd()
13343 
 
3431 rajveer 13344 
  def validate(self):
13345 
    return
13346 
 
13347 
 
759 chandransh 13348 
  def __repr__(self):
13349 
    L = ['%s=%r' % (key, value)
13350 
      for key, value in self.__dict__.iteritems()]
13351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13352 
 
13353 
  def __eq__(self, other):
13354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13355 
 
13356 
  def __ne__(self, other):
13357 
    return not (self == other)
13358 
 
3064 chandransh 13359 
class verifyOrder_result:
759 chandransh 13360 
  """
13361 
  Attributes:
13362 
   - success
13363 
   - ex
13364 
  """
13365 
 
13366 
  thrift_spec = (
13367 
    (0, TType.BOOL, 'success', None, None, ), # 0
13368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13369 
  )
13370 
 
13371 
  def __init__(self, success=None, ex=None,):
13372 
    self.success = success
13373 
    self.ex = ex
13374 
 
13375 
  def read(self, iprot):
13376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13378 
      return
13379 
    iprot.readStructBegin()
13380 
    while True:
13381 
      (fname, ftype, fid) = iprot.readFieldBegin()
13382 
      if ftype == TType.STOP:
13383 
        break
13384 
      if fid == 0:
13385 
        if ftype == TType.BOOL:
13386 
          self.success = iprot.readBool();
13387 
        else:
13388 
          iprot.skip(ftype)
13389 
      elif fid == 1:
13390 
        if ftype == TType.STRUCT:
13391 
          self.ex = TransactionServiceException()
13392 
          self.ex.read(iprot)
13393 
        else:
13394 
          iprot.skip(ftype)
13395 
      else:
13396 
        iprot.skip(ftype)
13397 
      iprot.readFieldEnd()
13398 
    iprot.readStructEnd()
13399 
 
13400 
  def write(self, oprot):
13401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13403 
      return
3064 chandransh 13404 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13405 
    if self.success is not None:
759 chandransh 13406 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13407 
      oprot.writeBool(self.success)
13408 
      oprot.writeFieldEnd()
3431 rajveer 13409 
    if self.ex is not None:
759 chandransh 13410 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13411 
      self.ex.write(oprot)
13412 
      oprot.writeFieldEnd()
13413 
    oprot.writeFieldStop()
13414 
    oprot.writeStructEnd()
13415 
 
3431 rajveer 13416 
  def validate(self):
13417 
    return
13418 
 
13419 
 
759 chandransh 13420 
  def __repr__(self):
13421 
    L = ['%s=%r' % (key, value)
13422 
      for key, value in self.__dict__.iteritems()]
13423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13424 
 
13425 
  def __eq__(self, other):
13426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13427 
 
13428 
  def __ne__(self, other):
13429 
    return not (self == other)
13430 
 
3064 chandransh 13431 
class acceptOrder_args:
1113 chandransh 13432 
  """
13433 
  Attributes:
3064 chandransh 13434 
   - orderId
1113 chandransh 13435 
  """
13436 
 
13437 
  thrift_spec = (
13438 
    None, # 0
3064 chandransh 13439 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13440 
  )
13441 
 
3064 chandransh 13442 
  def __init__(self, orderId=None,):
13443 
    self.orderId = orderId
1113 chandransh 13444 
 
13445 
  def read(self, iprot):
13446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13448 
      return
13449 
    iprot.readStructBegin()
13450 
    while True:
13451 
      (fname, ftype, fid) = iprot.readFieldBegin()
13452 
      if ftype == TType.STOP:
13453 
        break
13454 
      if fid == 1:
13455 
        if ftype == TType.I64:
3064 chandransh 13456 
          self.orderId = iprot.readI64();
1113 chandransh 13457 
        else:
13458 
          iprot.skip(ftype)
13459 
      else:
13460 
        iprot.skip(ftype)
13461 
      iprot.readFieldEnd()
13462 
    iprot.readStructEnd()
13463 
 
13464 
  def write(self, oprot):
13465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13467 
      return
3064 chandransh 13468 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13469 
    if self.orderId is not None:
3064 chandransh 13470 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13471 
      oprot.writeI64(self.orderId)
1113 chandransh 13472 
      oprot.writeFieldEnd()
13473 
    oprot.writeFieldStop()
13474 
    oprot.writeStructEnd()
13475 
 
3431 rajveer 13476 
  def validate(self):
13477 
    return
13478 
 
13479 
 
1113 chandransh 13480 
  def __repr__(self):
13481 
    L = ['%s=%r' % (key, value)
13482 
      for key, value in self.__dict__.iteritems()]
13483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13484 
 
13485 
  def __eq__(self, other):
13486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13487 
 
13488 
  def __ne__(self, other):
13489 
    return not (self == other)
13490 
 
3064 chandransh 13491 
class acceptOrder_result:
1113 chandransh 13492 
  """
13493 
  Attributes:
13494 
   - success
13495 
   - ex
13496 
  """
13497 
 
13498 
  thrift_spec = (
3064 chandransh 13499 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13500 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13501 
  )
13502 
 
13503 
  def __init__(self, success=None, ex=None,):
13504 
    self.success = success
13505 
    self.ex = ex
13506 
 
13507 
  def read(self, iprot):
13508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13510 
      return
13511 
    iprot.readStructBegin()
13512 
    while True:
13513 
      (fname, ftype, fid) = iprot.readFieldBegin()
13514 
      if ftype == TType.STOP:
13515 
        break
13516 
      if fid == 0:
3064 chandransh 13517 
        if ftype == TType.BOOL:
13518 
          self.success = iprot.readBool();
1113 chandransh 13519 
        else:
13520 
          iprot.skip(ftype)
13521 
      elif fid == 1:
13522 
        if ftype == TType.STRUCT:
13523 
          self.ex = TransactionServiceException()
13524 
          self.ex.read(iprot)
13525 
        else:
13526 
          iprot.skip(ftype)
13527 
      else:
13528 
        iprot.skip(ftype)
13529 
      iprot.readFieldEnd()
13530 
    iprot.readStructEnd()
13531 
 
13532 
  def write(self, oprot):
13533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13535 
      return
3064 chandransh 13536 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13537 
    if self.success is not None:
3064 chandransh 13538 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13539 
      oprot.writeBool(self.success)
1113 chandransh 13540 
      oprot.writeFieldEnd()
3431 rajveer 13541 
    if self.ex is not None:
1113 chandransh 13542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13543 
      self.ex.write(oprot)
13544 
      oprot.writeFieldEnd()
13545 
    oprot.writeFieldStop()
13546 
    oprot.writeStructEnd()
13547 
 
3431 rajveer 13548 
  def validate(self):
13549 
    return
13550 
 
13551 
 
1113 chandransh 13552 
  def __repr__(self):
13553 
    L = ['%s=%r' % (key, value)
13554 
      for key, value in self.__dict__.iteritems()]
13555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13556 
 
13557 
  def __eq__(self, other):
13558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13559 
 
13560 
  def __ne__(self, other):
13561 
    return not (self == other)
13562 
 
3064 chandransh 13563 
class addBillingDetails_args:
1135 chandransh 13564 
  """
13565 
  Attributes:
3064 chandransh 13566 
   - orderId
13567 
   - invoice_number
4658 mandeep.dh 13568 
   - serialNumber
4283 anupam.sin 13569 
   - itemNumber
3064 chandransh 13570 
   - billed_by
4264 rajveer 13571 
   - jacketNumber
4283 anupam.sin 13572 
   - billingType
5110 mandeep.dh 13573 
   - fulfilmentWarehouseId
4763 rajveer 13574 
   - authorize
1135 chandransh 13575 
  """
13576 
 
13577 
  thrift_spec = (
13578 
    None, # 0
3064 chandransh 13579 
    (1, TType.I64, 'orderId', None, None, ), # 1
13580 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13581 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13582 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13583 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13584 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13585 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13586 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13587 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13588 
  )
13589 
 
5110 mandeep.dh 13590 
  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 13591 
    self.orderId = orderId
13592 
    self.invoice_number = invoice_number
4658 mandeep.dh 13593 
    self.serialNumber = serialNumber
4283 anupam.sin 13594 
    self.itemNumber = itemNumber
3064 chandransh 13595 
    self.billed_by = billed_by
4264 rajveer 13596 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13597 
    self.billingType = billingType
5110 mandeep.dh 13598 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13599 
    self.authorize = authorize
1135 chandransh 13600 
 
13601 
  def read(self, iprot):
13602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13604 
      return
13605 
    iprot.readStructBegin()
13606 
    while True:
13607 
      (fname, ftype, fid) = iprot.readFieldBegin()
13608 
      if ftype == TType.STOP:
13609 
        break
13610 
      if fid == 1:
13611 
        if ftype == TType.I64:
3064 chandransh 13612 
          self.orderId = iprot.readI64();
1135 chandransh 13613 
        else:
13614 
          iprot.skip(ftype)
13615 
      elif fid == 2:
3064 chandransh 13616 
        if ftype == TType.STRING:
13617 
          self.invoice_number = iprot.readString();
1135 chandransh 13618 
        else:
13619 
          iprot.skip(ftype)
3064 chandransh 13620 
      elif fid == 3:
5411 rajveer 13621 
        if ftype == TType.LIST:
13622 
          self.serialNumber = []
6188 rajveer 13623 
          (_etype270, _size267) = iprot.readListBegin()
13624 
          for _i271 in xrange(_size267):
13625 
            _elem272 = iprot.readString();
13626 
            self.serialNumber.append(_elem272)
5411 rajveer 13627 
          iprot.readListEnd()
3064 chandransh 13628 
        else:
13629 
          iprot.skip(ftype)
13630 
      elif fid == 4:
5411 rajveer 13631 
        if ftype == TType.LIST:
13632 
          self.itemNumber = []
6188 rajveer 13633 
          (_etype276, _size273) = iprot.readListBegin()
13634 
          for _i277 in xrange(_size273):
13635 
            _elem278 = iprot.readString();
13636 
            self.itemNumber.append(_elem278)
5411 rajveer 13637 
          iprot.readListEnd()
3064 chandransh 13638 
        else:
13639 
          iprot.skip(ftype)
13640 
      elif fid == 5:
13641 
        if ftype == TType.STRING:
4283 anupam.sin 13642 
          self.billed_by = iprot.readString();
3064 chandransh 13643 
        else:
13644 
          iprot.skip(ftype)
13645 
      elif fid == 6:
13646 
        if ftype == TType.I64:
4283 anupam.sin 13647 
          self.jacketNumber = iprot.readI64();
13648 
        else:
13649 
          iprot.skip(ftype)
13650 
      elif fid == 7:
13651 
        if ftype == TType.I64:
3064 chandransh 13652 
          self.billingType = iprot.readI64();
13653 
        else:
13654 
          iprot.skip(ftype)
4283 anupam.sin 13655 
      elif fid == 8:
13656 
        if ftype == TType.I64:
5110 mandeep.dh 13657 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13658 
        else:
13659 
          iprot.skip(ftype)
4763 rajveer 13660 
      elif fid == 9:
13661 
        if ftype == TType.BOOL:
13662 
          self.authorize = iprot.readBool();
13663 
        else:
13664 
          iprot.skip(ftype)
1246 chandransh 13665 
      else:
13666 
        iprot.skip(ftype)
13667 
      iprot.readFieldEnd()
13668 
    iprot.readStructEnd()
13669 
 
13670 
  def write(self, oprot):
13671 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13672 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13673 
      return
4283 anupam.sin 13674 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13675 
    if self.orderId is not None:
3064 chandransh 13676 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13677 
      oprot.writeI64(self.orderId)
1246 chandransh 13678 
      oprot.writeFieldEnd()
4283 anupam.sin 13679 
    if self.invoice_number is not None:
13680 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13681 
      oprot.writeString(self.invoice_number)
1246 chandransh 13682 
      oprot.writeFieldEnd()
4658 mandeep.dh 13683 
    if self.serialNumber is not None:
5411 rajveer 13684 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13685 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13686 
      for iter279 in self.serialNumber:
13687 
        oprot.writeString(iter279)
5411 rajveer 13688 
      oprot.writeListEnd()
3064 chandransh 13689 
      oprot.writeFieldEnd()
3431 rajveer 13690 
    if self.itemNumber is not None:
5411 rajveer 13691 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13692 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13693 
      for iter280 in self.itemNumber:
13694 
        oprot.writeString(iter280)
5411 rajveer 13695 
      oprot.writeListEnd()
3064 chandransh 13696 
      oprot.writeFieldEnd()
4283 anupam.sin 13697 
    if self.billed_by is not None:
13698 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13699 
      oprot.writeString(self.billed_by)
3064 chandransh 13700 
      oprot.writeFieldEnd()
4283 anupam.sin 13701 
    if self.jacketNumber is not None:
13702 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13703 
      oprot.writeI64(self.jacketNumber)
13704 
      oprot.writeFieldEnd()
3431 rajveer 13705 
    if self.billingType is not None:
4283 anupam.sin 13706 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13707 
      oprot.writeI64(self.billingType)
13708 
      oprot.writeFieldEnd()
5110 mandeep.dh 13709 
    if self.fulfilmentWarehouseId is not None:
13710 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13711 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13712 
      oprot.writeFieldEnd()
4763 rajveer 13713 
    if self.authorize is not None:
13714 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13715 
      oprot.writeBool(self.authorize)
13716 
      oprot.writeFieldEnd()
1246 chandransh 13717 
    oprot.writeFieldStop()
13718 
    oprot.writeStructEnd()
13719 
 
3431 rajveer 13720 
  def validate(self):
13721 
    return
13722 
 
13723 
 
1246 chandransh 13724 
  def __repr__(self):
13725 
    L = ['%s=%r' % (key, value)
13726 
      for key, value in self.__dict__.iteritems()]
13727 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13728 
 
13729 
  def __eq__(self, other):
13730 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13731 
 
13732 
  def __ne__(self, other):
13733 
    return not (self == other)
13734 
 
4283 anupam.sin 13735 
class addBillingDetails_result:
1246 chandransh 13736 
  """
13737 
  Attributes:
3064 chandransh 13738 
   - success
1246 chandransh 13739 
   - ex
13740 
  """
13741 
 
13742 
  thrift_spec = (
3064 chandransh 13743 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13744 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13745 
  )
13746 
 
3064 chandransh 13747 
  def __init__(self, success=None, ex=None,):
13748 
    self.success = success
1246 chandransh 13749 
    self.ex = ex
13750 
 
13751 
  def read(self, iprot):
13752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13754 
      return
13755 
    iprot.readStructBegin()
13756 
    while True:
13757 
      (fname, ftype, fid) = iprot.readFieldBegin()
13758 
      if ftype == TType.STOP:
13759 
        break
3064 chandransh 13760 
      if fid == 0:
13761 
        if ftype == TType.BOOL:
13762 
          self.success = iprot.readBool();
13763 
        else:
13764 
          iprot.skip(ftype)
13765 
      elif fid == 1:
1246 chandransh 13766 
        if ftype == TType.STRUCT:
13767 
          self.ex = TransactionServiceException()
13768 
          self.ex.read(iprot)
13769 
        else:
13770 
          iprot.skip(ftype)
13771 
      else:
13772 
        iprot.skip(ftype)
13773 
      iprot.readFieldEnd()
13774 
    iprot.readStructEnd()
13775 
 
13776 
  def write(self, oprot):
13777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13779 
      return
4283 anupam.sin 13780 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13781 
    if self.success is not None:
3064 chandransh 13782 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13783 
      oprot.writeBool(self.success)
13784 
      oprot.writeFieldEnd()
3431 rajveer 13785 
    if self.ex is not None:
1246 chandransh 13786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13787 
      self.ex.write(oprot)
13788 
      oprot.writeFieldEnd()
13789 
    oprot.writeFieldStop()
13790 
    oprot.writeStructEnd()
13791 
 
3431 rajveer 13792 
  def validate(self):
13793 
    return
13794 
 
13795 
 
1246 chandransh 13796 
  def __repr__(self):
13797 
    L = ['%s=%r' % (key, value)
13798 
      for key, value in self.__dict__.iteritems()]
13799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13800 
 
13801 
  def __eq__(self, other):
13802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13803 
 
13804 
  def __ne__(self, other):
13805 
    return not (self == other)
13806 
 
4579 rajveer 13807 
class addInvoiceNumber_args:
13808 
  """
13809 
  Attributes:
13810 
   - orderId
13811 
   - invoiceNumber
4763 rajveer 13812 
   - color
4579 rajveer 13813 
  """
13814 
 
13815 
  thrift_spec = (
13816 
    None, # 0
13817 
    (1, TType.I64, 'orderId', None, None, ), # 1
13818 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13819 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13820 
  )
13821 
 
4763 rajveer 13822 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13823 
    self.orderId = orderId
13824 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13825 
    self.color = color
4579 rajveer 13826 
 
13827 
  def read(self, iprot):
13828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13830 
      return
13831 
    iprot.readStructBegin()
13832 
    while True:
13833 
      (fname, ftype, fid) = iprot.readFieldBegin()
13834 
      if ftype == TType.STOP:
13835 
        break
13836 
      if fid == 1:
13837 
        if ftype == TType.I64:
13838 
          self.orderId = iprot.readI64();
13839 
        else:
13840 
          iprot.skip(ftype)
13841 
      elif fid == 2:
13842 
        if ftype == TType.STRING:
13843 
          self.invoiceNumber = iprot.readString();
13844 
        else:
13845 
          iprot.skip(ftype)
4763 rajveer 13846 
      elif fid == 3:
13847 
        if ftype == TType.STRING:
13848 
          self.color = iprot.readString();
13849 
        else:
13850 
          iprot.skip(ftype)
4579 rajveer 13851 
      else:
13852 
        iprot.skip(ftype)
13853 
      iprot.readFieldEnd()
13854 
    iprot.readStructEnd()
13855 
 
13856 
  def write(self, oprot):
13857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13859 
      return
13860 
    oprot.writeStructBegin('addInvoiceNumber_args')
13861 
    if self.orderId is not None:
13862 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13863 
      oprot.writeI64(self.orderId)
13864 
      oprot.writeFieldEnd()
13865 
    if self.invoiceNumber is not None:
13866 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13867 
      oprot.writeString(self.invoiceNumber)
13868 
      oprot.writeFieldEnd()
4763 rajveer 13869 
    if self.color is not None:
13870 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13871 
      oprot.writeString(self.color)
13872 
      oprot.writeFieldEnd()
4579 rajveer 13873 
    oprot.writeFieldStop()
13874 
    oprot.writeStructEnd()
13875 
 
13876 
  def validate(self):
13877 
    return
13878 
 
13879 
 
13880 
  def __repr__(self):
13881 
    L = ['%s=%r' % (key, value)
13882 
      for key, value in self.__dict__.iteritems()]
13883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13884 
 
13885 
  def __eq__(self, other):
13886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13887 
 
13888 
  def __ne__(self, other):
13889 
    return not (self == other)
13890 
 
13891 
class addInvoiceNumber_result:
13892 
  """
13893 
  Attributes:
13894 
   - ex
13895 
  """
13896 
 
13897 
  thrift_spec = (
13898 
    None, # 0
13899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13900 
  )
13901 
 
13902 
  def __init__(self, ex=None,):
13903 
    self.ex = ex
13904 
 
13905 
  def read(self, iprot):
13906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13908 
      return
13909 
    iprot.readStructBegin()
13910 
    while True:
13911 
      (fname, ftype, fid) = iprot.readFieldBegin()
13912 
      if ftype == TType.STOP:
13913 
        break
13914 
      if fid == 1:
13915 
        if ftype == TType.STRUCT:
13916 
          self.ex = TransactionServiceException()
13917 
          self.ex.read(iprot)
13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      else:
13921 
        iprot.skip(ftype)
13922 
      iprot.readFieldEnd()
13923 
    iprot.readStructEnd()
13924 
 
13925 
  def write(self, oprot):
13926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13928 
      return
13929 
    oprot.writeStructBegin('addInvoiceNumber_result')
13930 
    if self.ex is not None:
13931 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13932 
      self.ex.write(oprot)
13933 
      oprot.writeFieldEnd()
13934 
    oprot.writeFieldStop()
13935 
    oprot.writeStructEnd()
13936 
 
13937 
  def validate(self):
13938 
    return
13939 
 
13940 
 
13941 
  def __repr__(self):
13942 
    L = ['%s=%r' % (key, value)
13943 
      for key, value in self.__dict__.iteritems()]
13944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13945 
 
13946 
  def __eq__(self, other):
13947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13948 
 
13949 
  def __ne__(self, other):
13950 
    return not (self == other)
13951 
 
4910 phani.kuma 13952 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13953 
  """
13954 
  Attributes:
3064 chandransh 13955 
   - warehouseId
1408 ankur.sing 13956 
   - providerId
3064 chandransh 13957 
   - cod
4910 phani.kuma 13958 
   - orderIds
1408 ankur.sing 13959 
  """
13960 
 
13961 
  thrift_spec = (
13962 
    None, # 0
3064 chandransh 13963 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13964 
    (2, TType.I64, 'providerId', None, None, ), # 2
13965 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13966 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13967 
  )
13968 
 
4910 phani.kuma 13969 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13970 
    self.warehouseId = warehouseId
1408 ankur.sing 13971 
    self.providerId = providerId
3064 chandransh 13972 
    self.cod = cod
4910 phani.kuma 13973 
    self.orderIds = orderIds
1408 ankur.sing 13974 
 
13975 
  def read(self, iprot):
13976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13978 
      return
13979 
    iprot.readStructBegin()
13980 
    while True:
13981 
      (fname, ftype, fid) = iprot.readFieldBegin()
13982 
      if ftype == TType.STOP:
13983 
        break
13984 
      if fid == 1:
13985 
        if ftype == TType.I64:
3064 chandransh 13986 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13987 
        else:
13988 
          iprot.skip(ftype)
13989 
      elif fid == 2:
13990 
        if ftype == TType.I64:
3064 chandransh 13991 
          self.providerId = iprot.readI64();
1408 ankur.sing 13992 
        else:
13993 
          iprot.skip(ftype)
3064 chandransh 13994 
      elif fid == 3:
13995 
        if ftype == TType.BOOL:
13996 
          self.cod = iprot.readBool();
13997 
        else:
13998 
          iprot.skip(ftype)
4910 phani.kuma 13999 
      elif fid == 4:
14000 
        if ftype == TType.LIST:
14001 
          self.orderIds = []
6188 rajveer 14002 
          (_etype284, _size281) = iprot.readListBegin()
14003 
          for _i285 in xrange(_size281):
14004 
            _elem286 = iprot.readI64();
14005 
            self.orderIds.append(_elem286)
4910 phani.kuma 14006 
          iprot.readListEnd()
14007 
        else:
14008 
          iprot.skip(ftype)
1408 ankur.sing 14009 
      else:
14010 
        iprot.skip(ftype)
14011 
      iprot.readFieldEnd()
14012 
    iprot.readStructEnd()
14013 
 
14014 
  def write(self, oprot):
14015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14017 
      return
4910 phani.kuma 14018 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14019 
    if self.warehouseId is not None:
3064 chandransh 14020 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14021 
      oprot.writeI64(self.warehouseId)
14022 
      oprot.writeFieldEnd()
3431 rajveer 14023 
    if self.providerId is not None:
3064 chandransh 14024 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14025 
      oprot.writeI64(self.providerId)
14026 
      oprot.writeFieldEnd()
3431 rajveer 14027 
    if self.cod is not None:
3064 chandransh 14028 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14029 
      oprot.writeBool(self.cod)
1408 ankur.sing 14030 
      oprot.writeFieldEnd()
4910 phani.kuma 14031 
    if self.orderIds is not None:
14032 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14033 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14034 
      for iter287 in self.orderIds:
14035 
        oprot.writeI64(iter287)
4910 phani.kuma 14036 
      oprot.writeListEnd()
14037 
      oprot.writeFieldEnd()
1408 ankur.sing 14038 
    oprot.writeFieldStop()
14039 
    oprot.writeStructEnd()
14040 
 
3431 rajveer 14041 
  def validate(self):
14042 
    return
14043 
 
14044 
 
1408 ankur.sing 14045 
  def __repr__(self):
14046 
    L = ['%s=%r' % (key, value)
14047 
      for key, value in self.__dict__.iteritems()]
14048 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14049 
 
14050 
  def __eq__(self, other):
14051 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14052 
 
14053 
  def __ne__(self, other):
14054 
    return not (self == other)
14055 
 
4910 phani.kuma 14056 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14057 
  """
14058 
  Attributes:
14059 
   - success
3064 chandransh 14060 
   - ex
1408 ankur.sing 14061 
  """
14062 
 
14063 
  thrift_spec = (
3064 chandransh 14064 
    (0, TType.BOOL, 'success', None, None, ), # 0
14065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14066 
  )
14067 
 
3064 chandransh 14068 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14069 
    self.success = success
3064 chandransh 14070 
    self.ex = ex
1408 ankur.sing 14071 
 
14072 
  def read(self, iprot):
14073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14075 
      return
14076 
    iprot.readStructBegin()
14077 
    while True:
14078 
      (fname, ftype, fid) = iprot.readFieldBegin()
14079 
      if ftype == TType.STOP:
14080 
        break
14081 
      if fid == 0:
3064 chandransh 14082 
        if ftype == TType.BOOL:
14083 
          self.success = iprot.readBool();
1408 ankur.sing 14084 
        else:
14085 
          iprot.skip(ftype)
3064 chandransh 14086 
      elif fid == 1:
14087 
        if ftype == TType.STRUCT:
14088 
          self.ex = TransactionServiceException()
14089 
          self.ex.read(iprot)
14090 
        else:
14091 
          iprot.skip(ftype)
1408 ankur.sing 14092 
      else:
14093 
        iprot.skip(ftype)
14094 
      iprot.readFieldEnd()
14095 
    iprot.readStructEnd()
14096 
 
14097 
  def write(self, oprot):
14098 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14099 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14100 
      return
4910 phani.kuma 14101 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14102 
    if self.success is not None:
3064 chandransh 14103 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14104 
      oprot.writeBool(self.success)
1408 ankur.sing 14105 
      oprot.writeFieldEnd()
3431 rajveer 14106 
    if self.ex is not None:
3064 chandransh 14107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14108 
      self.ex.write(oprot)
14109 
      oprot.writeFieldEnd()
1408 ankur.sing 14110 
    oprot.writeFieldStop()
14111 
    oprot.writeStructEnd()
14112 
 
3431 rajveer 14113 
  def validate(self):
14114 
    return
14115 
 
14116 
 
1408 ankur.sing 14117 
  def __repr__(self):
14118 
    L = ['%s=%r' % (key, value)
14119 
      for key, value in self.__dict__.iteritems()]
14120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14121 
 
14122 
  def __eq__(self, other):
14123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14124 
 
14125 
  def __ne__(self, other):
14126 
    return not (self == other)
14127 
 
5676 rajveer 14128 
class markOrdersAsReturnedFromStore_args:
14129 
  """
14130 
  Attributes:
14131 
   - providerId
14132 
   - orderIds
5713 rajveer 14133 
   - awbs
5676 rajveer 14134 
  """
14135 
 
14136 
  thrift_spec = (
14137 
    None, # 0
14138 
    (1, TType.I64, 'providerId', None, None, ), # 1
14139 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14140 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14141 
  )
14142 
 
5713 rajveer 14143 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14144 
    self.providerId = providerId
14145 
    self.orderIds = orderIds
5713 rajveer 14146 
    self.awbs = awbs
5676 rajveer 14147 
 
14148 
  def read(self, iprot):
14149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14151 
      return
14152 
    iprot.readStructBegin()
14153 
    while True:
14154 
      (fname, ftype, fid) = iprot.readFieldBegin()
14155 
      if ftype == TType.STOP:
14156 
        break
14157 
      if fid == 1:
14158 
        if ftype == TType.I64:
14159 
          self.providerId = iprot.readI64();
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      elif fid == 2:
14163 
        if ftype == TType.LIST:
14164 
          self.orderIds = []
6188 rajveer 14165 
          (_etype291, _size288) = iprot.readListBegin()
14166 
          for _i292 in xrange(_size288):
14167 
            _elem293 = iprot.readI64();
14168 
            self.orderIds.append(_elem293)
5676 rajveer 14169 
          iprot.readListEnd()
14170 
        else:
14171 
          iprot.skip(ftype)
5713 rajveer 14172 
      elif fid == 3:
14173 
        if ftype == TType.LIST:
14174 
          self.awbs = []
6188 rajveer 14175 
          (_etype297, _size294) = iprot.readListBegin()
14176 
          for _i298 in xrange(_size294):
14177 
            _elem299 = iprot.readString();
14178 
            self.awbs.append(_elem299)
5713 rajveer 14179 
          iprot.readListEnd()
14180 
        else:
14181 
          iprot.skip(ftype)
5676 rajveer 14182 
      else:
14183 
        iprot.skip(ftype)
14184 
      iprot.readFieldEnd()
14185 
    iprot.readStructEnd()
14186 
 
14187 
  def write(self, oprot):
14188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14190 
      return
14191 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14192 
    if self.providerId is not None:
14193 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14194 
      oprot.writeI64(self.providerId)
14195 
      oprot.writeFieldEnd()
14196 
    if self.orderIds is not None:
14197 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14198 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14199 
      for iter300 in self.orderIds:
14200 
        oprot.writeI64(iter300)
5676 rajveer 14201 
      oprot.writeListEnd()
14202 
      oprot.writeFieldEnd()
5713 rajveer 14203 
    if self.awbs is not None:
14204 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14205 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14206 
      for iter301 in self.awbs:
14207 
        oprot.writeString(iter301)
5713 rajveer 14208 
      oprot.writeListEnd()
14209 
      oprot.writeFieldEnd()
5676 rajveer 14210 
    oprot.writeFieldStop()
14211 
    oprot.writeStructEnd()
14212 
 
14213 
  def validate(self):
14214 
    return
14215 
 
14216 
 
14217 
  def __repr__(self):
14218 
    L = ['%s=%r' % (key, value)
14219 
      for key, value in self.__dict__.iteritems()]
14220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14221 
 
14222 
  def __eq__(self, other):
14223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14224 
 
14225 
  def __ne__(self, other):
14226 
    return not (self == other)
14227 
 
14228 
class markOrdersAsReturnedFromStore_result:
14229 
  """
14230 
  Attributes:
14231 
   - success
14232 
   - ex
14233 
  """
14234 
 
14235 
  thrift_spec = (
14236 
    (0, TType.BOOL, 'success', None, None, ), # 0
14237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14238 
  )
14239 
 
14240 
  def __init__(self, success=None, ex=None,):
14241 
    self.success = success
14242 
    self.ex = ex
14243 
 
14244 
  def read(self, iprot):
14245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14247 
      return
14248 
    iprot.readStructBegin()
14249 
    while True:
14250 
      (fname, ftype, fid) = iprot.readFieldBegin()
14251 
      if ftype == TType.STOP:
14252 
        break
14253 
      if fid == 0:
14254 
        if ftype == TType.BOOL:
14255 
          self.success = iprot.readBool();
14256 
        else:
14257 
          iprot.skip(ftype)
14258 
      elif fid == 1:
14259 
        if ftype == TType.STRUCT:
14260 
          self.ex = TransactionServiceException()
14261 
          self.ex.read(iprot)
14262 
        else:
14263 
          iprot.skip(ftype)
14264 
      else:
14265 
        iprot.skip(ftype)
14266 
      iprot.readFieldEnd()
14267 
    iprot.readStructEnd()
14268 
 
14269 
  def write(self, oprot):
14270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14272 
      return
14273 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14274 
    if self.success is not None:
14275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14276 
      oprot.writeBool(self.success)
14277 
      oprot.writeFieldEnd()
14278 
    if self.ex is not None:
14279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14280 
      self.ex.write(oprot)
14281 
      oprot.writeFieldEnd()
14282 
    oprot.writeFieldStop()
14283 
    oprot.writeStructEnd()
14284 
 
14285 
  def validate(self):
14286 
    return
14287 
 
14288 
 
14289 
  def __repr__(self):
14290 
    L = ['%s=%r' % (key, value)
14291 
      for key, value in self.__dict__.iteritems()]
14292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14293 
 
14294 
  def __eq__(self, other):
14295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14296 
 
14297 
  def __ne__(self, other):
14298 
    return not (self == other)
14299 
 
4910 phani.kuma 14300 
class markOrdersAsPickedUp_args:
4410 rajveer 14301 
  """
14302 
  Attributes:
14303 
   - providerId
4910 phani.kuma 14304 
   - pickupDetails
4410 rajveer 14305 
  """
14306 
 
14307 
  thrift_spec = (
14308 
    None, # 0
4910 phani.kuma 14309 
    (1, TType.I64, 'providerId', None, None, ), # 1
14310 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14311 
  )
14312 
 
4910 phani.kuma 14313 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14314 
    self.providerId = providerId
4910 phani.kuma 14315 
    self.pickupDetails = pickupDetails
4410 rajveer 14316 
 
14317 
  def read(self, iprot):
14318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14320 
      return
14321 
    iprot.readStructBegin()
14322 
    while True:
14323 
      (fname, ftype, fid) = iprot.readFieldBegin()
14324 
      if ftype == TType.STOP:
14325 
        break
14326 
      if fid == 1:
14327 
        if ftype == TType.I64:
4910 phani.kuma 14328 
          self.providerId = iprot.readI64();
4410 rajveer 14329 
        else:
14330 
          iprot.skip(ftype)
14331 
      elif fid == 2:
4910 phani.kuma 14332 
        if ftype == TType.MAP:
14333 
          self.pickupDetails = {}
6188 rajveer 14334 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14335 
          for _i306 in xrange(_size302):
14336 
            _key307 = iprot.readString();
14337 
            _val308 = iprot.readString();
14338 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14339 
          iprot.readMapEnd()
4410 rajveer 14340 
        else:
14341 
          iprot.skip(ftype)
14342 
      else:
14343 
        iprot.skip(ftype)
14344 
      iprot.readFieldEnd()
14345 
    iprot.readStructEnd()
14346 
 
14347 
  def write(self, oprot):
14348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14350 
      return
4910 phani.kuma 14351 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14352 
    if self.providerId is not None:
4910 phani.kuma 14353 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14354 
      oprot.writeI64(self.providerId)
14355 
      oprot.writeFieldEnd()
4910 phani.kuma 14356 
    if self.pickupDetails is not None:
14357 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14358 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14359 
      for kiter309,viter310 in self.pickupDetails.items():
14360 
        oprot.writeString(kiter309)
14361 
        oprot.writeString(viter310)
4910 phani.kuma 14362 
      oprot.writeMapEnd()
4410 rajveer 14363 
      oprot.writeFieldEnd()
14364 
    oprot.writeFieldStop()
14365 
    oprot.writeStructEnd()
14366 
 
14367 
  def validate(self):
14368 
    return
14369 
 
14370 
 
14371 
  def __repr__(self):
14372 
    L = ['%s=%r' % (key, value)
14373 
      for key, value in self.__dict__.iteritems()]
14374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14375 
 
14376 
  def __eq__(self, other):
14377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14378 
 
14379 
  def __ne__(self, other):
14380 
    return not (self == other)
14381 
 
4910 phani.kuma 14382 
class markOrdersAsPickedUp_result:
4410 rajveer 14383 
  """
14384 
  Attributes:
14385 
   - ex
14386 
  """
14387 
 
14388 
  thrift_spec = (
4910 phani.kuma 14389 
    None, # 0
4410 rajveer 14390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14391 
  )
14392 
 
4910 phani.kuma 14393 
  def __init__(self, ex=None,):
4410 rajveer 14394 
    self.ex = ex
14395 
 
14396 
  def read(self, iprot):
14397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14399 
      return
14400 
    iprot.readStructBegin()
14401 
    while True:
14402 
      (fname, ftype, fid) = iprot.readFieldBegin()
14403 
      if ftype == TType.STOP:
14404 
        break
4910 phani.kuma 14405 
      if fid == 1:
4410 rajveer 14406 
        if ftype == TType.STRUCT:
14407 
          self.ex = TransactionServiceException()
14408 
          self.ex.read(iprot)
14409 
        else:
14410 
          iprot.skip(ftype)
14411 
      else:
14412 
        iprot.skip(ftype)
14413 
      iprot.readFieldEnd()
14414 
    iprot.readStructEnd()
14415 
 
14416 
  def write(self, oprot):
14417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14419 
      return
4910 phani.kuma 14420 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14421 
    if self.ex is not None:
14422 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14423 
      self.ex.write(oprot)
14424 
      oprot.writeFieldEnd()
14425 
    oprot.writeFieldStop()
14426 
    oprot.writeStructEnd()
14427 
 
14428 
  def validate(self):
14429 
    return
14430 
 
14431 
 
14432 
  def __repr__(self):
14433 
    L = ['%s=%r' % (key, value)
14434 
      for key, value in self.__dict__.iteritems()]
14435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14436 
 
14437 
  def __eq__(self, other):
14438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14439 
 
14440 
  def __ne__(self, other):
14441 
    return not (self == other)
14442 
 
4910 phani.kuma 14443 
class getOrdersNotPickedUp_args:
304 ashish 14444 
  """
14445 
  Attributes:
3064 chandransh 14446 
   - providerId
304 ashish 14447 
  """
94 ashish 14448 
 
304 ashish 14449 
  thrift_spec = (
14450 
    None, # 0
3064 chandransh 14451 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14452 
  )
14453 
 
4910 phani.kuma 14454 
  def __init__(self, providerId=None,):
3064 chandransh 14455 
    self.providerId = providerId
304 ashish 14456 
 
14457 
  def read(self, iprot):
14458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14460 
      return
14461 
    iprot.readStructBegin()
14462 
    while True:
14463 
      (fname, ftype, fid) = iprot.readFieldBegin()
14464 
      if ftype == TType.STOP:
14465 
        break
14466 
      if fid == 1:
14467 
        if ftype == TType.I64:
3064 chandransh 14468 
          self.providerId = iprot.readI64();
304 ashish 14469 
        else:
14470 
          iprot.skip(ftype)
14471 
      else:
14472 
        iprot.skip(ftype)
14473 
      iprot.readFieldEnd()
14474 
    iprot.readStructEnd()
14475 
 
14476 
  def write(self, oprot):
14477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14479 
      return
4910 phani.kuma 14480 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14481 
    if self.providerId is not None:
3064 chandransh 14482 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14483 
      oprot.writeI64(self.providerId)
304 ashish 14484 
      oprot.writeFieldEnd()
14485 
    oprot.writeFieldStop()
14486 
    oprot.writeStructEnd()
14487 
 
3431 rajveer 14488 
  def validate(self):
14489 
    return
14490 
 
14491 
 
304 ashish 14492 
  def __repr__(self):
14493 
    L = ['%s=%r' % (key, value)
14494 
      for key, value in self.__dict__.iteritems()]
14495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14496 
 
14497 
  def __eq__(self, other):
14498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14499 
 
14500 
  def __ne__(self, other):
14501 
    return not (self == other)
14502 
 
4910 phani.kuma 14503 
class getOrdersNotPickedUp_result:
304 ashish 14504 
  """
14505 
  Attributes:
14506 
   - success
14507 
  """
14508 
 
14509 
  thrift_spec = (
3064 chandransh 14510 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14511 
  )
14512 
 
4910 phani.kuma 14513 
  def __init__(self, success=None,):
304 ashish 14514 
    self.success = success
14515 
 
14516 
  def read(self, iprot):
14517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14519 
      return
14520 
    iprot.readStructBegin()
14521 
    while True:
14522 
      (fname, ftype, fid) = iprot.readFieldBegin()
14523 
      if ftype == TType.STOP:
14524 
        break
14525 
      if fid == 0:
14526 
        if ftype == TType.LIST:
14527 
          self.success = []
6188 rajveer 14528 
          (_etype314, _size311) = iprot.readListBegin()
14529 
          for _i315 in xrange(_size311):
14530 
            _elem316 = Order()
14531 
            _elem316.read(iprot)
14532 
            self.success.append(_elem316)
304 ashish 14533 
          iprot.readListEnd()
14534 
        else:
14535 
          iprot.skip(ftype)
14536 
      else:
14537 
        iprot.skip(ftype)
14538 
      iprot.readFieldEnd()
14539 
    iprot.readStructEnd()
14540 
 
14541 
  def write(self, oprot):
14542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14544 
      return
4910 phani.kuma 14545 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14546 
    if self.success is not None:
304 ashish 14547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14549 
      for iter317 in self.success:
14550 
        iter317.write(oprot)
304 ashish 14551 
      oprot.writeListEnd()
14552 
      oprot.writeFieldEnd()
14553 
    oprot.writeFieldStop()
14554 
    oprot.writeStructEnd()
14555 
 
3431 rajveer 14556 
  def validate(self):
14557 
    return
14558 
 
14559 
 
304 ashish 14560 
  def __repr__(self):
14561 
    L = ['%s=%r' % (key, value)
14562 
      for key, value in self.__dict__.iteritems()]
14563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14564 
 
14565 
  def __eq__(self, other):
14566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14567 
 
14568 
  def __ne__(self, other):
14569 
    return not (self == other)
14570 
 
3064 chandransh 14571 
class markOrdersAsDelivered_args:
304 ashish 14572 
  """
14573 
  Attributes:
3064 chandransh 14574 
   - providerId
14575 
   - deliveredOrders
304 ashish 14576 
  """
14577 
 
14578 
  thrift_spec = (
14579 
    None, # 0
3064 chandransh 14580 
    (1, TType.I64, 'providerId', None, None, ), # 1
14581 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14582 
  )
14583 
 
3064 chandransh 14584 
  def __init__(self, providerId=None, deliveredOrders=None,):
14585 
    self.providerId = providerId
14586 
    self.deliveredOrders = deliveredOrders
304 ashish 14587 
 
14588 
  def read(self, iprot):
14589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14591 
      return
14592 
    iprot.readStructBegin()
14593 
    while True:
14594 
      (fname, ftype, fid) = iprot.readFieldBegin()
14595 
      if ftype == TType.STOP:
14596 
        break
14597 
      if fid == 1:
14598 
        if ftype == TType.I64:
3064 chandransh 14599 
          self.providerId = iprot.readI64();
304 ashish 14600 
        else:
14601 
          iprot.skip(ftype)
14602 
      elif fid == 2:
3064 chandransh 14603 
        if ftype == TType.MAP:
14604 
          self.deliveredOrders = {}
6188 rajveer 14605 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14606 
          for _i322 in xrange(_size318):
14607 
            _key323 = iprot.readString();
14608 
            _val324 = iprot.readString();
14609 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14610 
          iprot.readMapEnd()
304 ashish 14611 
        else:
14612 
          iprot.skip(ftype)
14613 
      else:
14614 
        iprot.skip(ftype)
14615 
      iprot.readFieldEnd()
14616 
    iprot.readStructEnd()
14617 
 
14618 
  def write(self, oprot):
14619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14621 
      return
3064 chandransh 14622 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14623 
    if self.providerId is not None:
3064 chandransh 14624 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14625 
      oprot.writeI64(self.providerId)
304 ashish 14626 
      oprot.writeFieldEnd()
3431 rajveer 14627 
    if self.deliveredOrders is not None:
3064 chandransh 14628 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14629 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14630 
      for kiter325,viter326 in self.deliveredOrders.items():
14631 
        oprot.writeString(kiter325)
14632 
        oprot.writeString(viter326)
3064 chandransh 14633 
      oprot.writeMapEnd()
304 ashish 14634 
      oprot.writeFieldEnd()
14635 
    oprot.writeFieldStop()
14636 
    oprot.writeStructEnd()
14637 
 
3431 rajveer 14638 
  def validate(self):
14639 
    return
14640 
 
14641 
 
304 ashish 14642 
  def __repr__(self):
14643 
    L = ['%s=%r' % (key, value)
14644 
      for key, value in self.__dict__.iteritems()]
14645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14646 
 
14647 
  def __eq__(self, other):
14648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14649 
 
14650 
  def __ne__(self, other):
14651 
    return not (self == other)
14652 
 
3064 chandransh 14653 
class markOrdersAsDelivered_result:
14654 
  """
14655 
  Attributes:
14656 
   - ex
14657 
  """
304 ashish 14658 
 
14659 
  thrift_spec = (
3064 chandransh 14660 
    None, # 0
14661 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14662 
  )
14663 
 
3064 chandransh 14664 
  def __init__(self, ex=None,):
14665 
    self.ex = ex
304 ashish 14666 
 
1596 ankur.sing 14667 
  def read(self, iprot):
14668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14670 
      return
14671 
    iprot.readStructBegin()
14672 
    while True:
14673 
      (fname, ftype, fid) = iprot.readFieldBegin()
14674 
      if ftype == TType.STOP:
14675 
        break
3064 chandransh 14676 
      if fid == 1:
14677 
        if ftype == TType.STRUCT:
14678 
          self.ex = TransactionServiceException()
14679 
          self.ex.read(iprot)
14680 
        else:
14681 
          iprot.skip(ftype)
1596 ankur.sing 14682 
      else:
14683 
        iprot.skip(ftype)
14684 
      iprot.readFieldEnd()
14685 
    iprot.readStructEnd()
14686 
 
14687 
  def write(self, oprot):
14688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14690 
      return
3064 chandransh 14691 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14692 
    if self.ex is not None:
3064 chandransh 14693 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14694 
      self.ex.write(oprot)
14695 
      oprot.writeFieldEnd()
1596 ankur.sing 14696 
    oprot.writeFieldStop()
14697 
    oprot.writeStructEnd()
14698 
 
3431 rajveer 14699 
  def validate(self):
14700 
    return
14701 
 
14702 
 
1596 ankur.sing 14703 
  def __repr__(self):
14704 
    L = ['%s=%r' % (key, value)
14705 
      for key, value in self.__dict__.iteritems()]
14706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14707 
 
14708 
  def __eq__(self, other):
14709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14710 
 
14711 
  def __ne__(self, other):
14712 
    return not (self == other)
14713 
 
4910 phani.kuma 14714 
class markAsRTOrders_args:
1596 ankur.sing 14715 
  """
14716 
  Attributes:
3064 chandransh 14717 
   - providerId
14718 
   - returnedOrders
1596 ankur.sing 14719 
  """
14720 
 
14721 
  thrift_spec = (
3064 chandransh 14722 
    None, # 0
14723 
    (1, TType.I64, 'providerId', None, None, ), # 1
14724 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14725 
  )
14726 
 
3064 chandransh 14727 
  def __init__(self, providerId=None, returnedOrders=None,):
14728 
    self.providerId = providerId
14729 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14730 
 
14731 
  def read(self, iprot):
14732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14734 
      return
14735 
    iprot.readStructBegin()
14736 
    while True:
14737 
      (fname, ftype, fid) = iprot.readFieldBegin()
14738 
      if ftype == TType.STOP:
14739 
        break
3064 chandransh 14740 
      if fid == 1:
1596 ankur.sing 14741 
        if ftype == TType.I64:
3064 chandransh 14742 
          self.providerId = iprot.readI64();
1596 ankur.sing 14743 
        else:
14744 
          iprot.skip(ftype)
3064 chandransh 14745 
      elif fid == 2:
14746 
        if ftype == TType.MAP:
14747 
          self.returnedOrders = {}
6188 rajveer 14748 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14749 
          for _i331 in xrange(_size327):
14750 
            _key332 = iprot.readString();
14751 
            _val333 = iprot.readString();
14752 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14753 
          iprot.readMapEnd()
14754 
        else:
14755 
          iprot.skip(ftype)
1596 ankur.sing 14756 
      else:
14757 
        iprot.skip(ftype)
14758 
      iprot.readFieldEnd()
14759 
    iprot.readStructEnd()
14760 
 
14761 
  def write(self, oprot):
14762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14764 
      return
4910 phani.kuma 14765 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14766 
    if self.providerId is not None:
3064 chandransh 14767 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14768 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14769 
      oprot.writeFieldEnd()
3431 rajveer 14770 
    if self.returnedOrders is not None:
3064 chandransh 14771 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14772 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14773 
      for kiter334,viter335 in self.returnedOrders.items():
14774 
        oprot.writeString(kiter334)
14775 
        oprot.writeString(viter335)
3064 chandransh 14776 
      oprot.writeMapEnd()
14777 
      oprot.writeFieldEnd()
1596 ankur.sing 14778 
    oprot.writeFieldStop()
14779 
    oprot.writeStructEnd()
14780 
 
3431 rajveer 14781 
  def validate(self):
14782 
    return
14783 
 
14784 
 
1596 ankur.sing 14785 
  def __repr__(self):
14786 
    L = ['%s=%r' % (key, value)
14787 
      for key, value in self.__dict__.iteritems()]
14788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14789 
 
14790 
  def __eq__(self, other):
14791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14792 
 
14793 
  def __ne__(self, other):
14794 
    return not (self == other)
14795 
 
4910 phani.kuma 14796 
class markAsRTOrders_result:
3064 chandransh 14797 
  """
14798 
  Attributes:
14799 
   - ex
14800 
  """
1596 ankur.sing 14801 
 
1627 ankur.sing 14802 
  thrift_spec = (
3064 chandransh 14803 
    None, # 0
14804 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14805 
  )
14806 
 
3064 chandransh 14807 
  def __init__(self, ex=None,):
14808 
    self.ex = ex
14809 
 
1627 ankur.sing 14810 
  def read(self, iprot):
14811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14813 
      return
14814 
    iprot.readStructBegin()
14815 
    while True:
14816 
      (fname, ftype, fid) = iprot.readFieldBegin()
14817 
      if ftype == TType.STOP:
14818 
        break
3064 chandransh 14819 
      if fid == 1:
14820 
        if ftype == TType.STRUCT:
14821 
          self.ex = TransactionServiceException()
14822 
          self.ex.read(iprot)
14823 
        else:
14824 
          iprot.skip(ftype)
1627 ankur.sing 14825 
      else:
14826 
        iprot.skip(ftype)
14827 
      iprot.readFieldEnd()
14828 
    iprot.readStructEnd()
14829 
 
14830 
  def write(self, oprot):
14831 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14832 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14833 
      return
4910 phani.kuma 14834 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14835 
    if self.ex is not None:
3064 chandransh 14836 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14837 
      self.ex.write(oprot)
14838 
      oprot.writeFieldEnd()
1627 ankur.sing 14839 
    oprot.writeFieldStop()
14840 
    oprot.writeStructEnd()
14841 
 
3431 rajveer 14842 
  def validate(self):
14843 
    return
14844 
 
14845 
 
1627 ankur.sing 14846 
  def __repr__(self):
14847 
    L = ['%s=%r' % (key, value)
14848 
      for key, value in self.__dict__.iteritems()]
14849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14850 
 
14851 
  def __eq__(self, other):
14852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14853 
 
14854 
  def __ne__(self, other):
14855 
    return not (self == other)
14856 
 
4910 phani.kuma 14857 
class getRTOrders_args:
14858 
  """
14859 
  Attributes:
14860 
   - providerId
14861 
  """
14862 
 
14863 
  thrift_spec = (
14864 
    None, # 0
14865 
    (1, TType.I64, 'providerId', None, None, ), # 1
14866 
  )
14867 
 
14868 
  def __init__(self, providerId=None,):
14869 
    self.providerId = providerId
14870 
 
14871 
  def read(self, iprot):
14872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14874 
      return
14875 
    iprot.readStructBegin()
14876 
    while True:
14877 
      (fname, ftype, fid) = iprot.readFieldBegin()
14878 
      if ftype == TType.STOP:
14879 
        break
14880 
      if fid == 1:
14881 
        if ftype == TType.I64:
14882 
          self.providerId = iprot.readI64();
14883 
        else:
14884 
          iprot.skip(ftype)
14885 
      else:
14886 
        iprot.skip(ftype)
14887 
      iprot.readFieldEnd()
14888 
    iprot.readStructEnd()
14889 
 
14890 
  def write(self, oprot):
14891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14893 
      return
14894 
    oprot.writeStructBegin('getRTOrders_args')
14895 
    if self.providerId is not None:
14896 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14897 
      oprot.writeI64(self.providerId)
14898 
      oprot.writeFieldEnd()
14899 
    oprot.writeFieldStop()
14900 
    oprot.writeStructEnd()
14901 
 
14902 
  def validate(self):
14903 
    return
14904 
 
14905 
 
14906 
  def __repr__(self):
14907 
    L = ['%s=%r' % (key, value)
14908 
      for key, value in self.__dict__.iteritems()]
14909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14910 
 
14911 
  def __eq__(self, other):
14912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14913 
 
14914 
  def __ne__(self, other):
14915 
    return not (self == other)
14916 
 
14917 
class getRTOrders_result:
14918 
  """
14919 
  Attributes:
14920 
   - success
14921 
  """
14922 
 
14923 
  thrift_spec = (
14924 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14925 
  )
14926 
 
14927 
  def __init__(self, success=None,):
14928 
    self.success = success
14929 
 
14930 
  def read(self, iprot):
14931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14933 
      return
14934 
    iprot.readStructBegin()
14935 
    while True:
14936 
      (fname, ftype, fid) = iprot.readFieldBegin()
14937 
      if ftype == TType.STOP:
14938 
        break
14939 
      if fid == 0:
14940 
        if ftype == TType.LIST:
14941 
          self.success = []
6188 rajveer 14942 
          (_etype339, _size336) = iprot.readListBegin()
14943 
          for _i340 in xrange(_size336):
14944 
            _elem341 = Order()
14945 
            _elem341.read(iprot)
14946 
            self.success.append(_elem341)
4910 phani.kuma 14947 
          iprot.readListEnd()
14948 
        else:
14949 
          iprot.skip(ftype)
14950 
      else:
14951 
        iprot.skip(ftype)
14952 
      iprot.readFieldEnd()
14953 
    iprot.readStructEnd()
14954 
 
14955 
  def write(self, oprot):
14956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14958 
      return
14959 
    oprot.writeStructBegin('getRTOrders_result')
14960 
    if self.success is not None:
14961 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14962 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14963 
      for iter342 in self.success:
14964 
        iter342.write(oprot)
4910 phani.kuma 14965 
      oprot.writeListEnd()
14966 
      oprot.writeFieldEnd()
14967 
    oprot.writeFieldStop()
14968 
    oprot.writeStructEnd()
14969 
 
14970 
  def validate(self):
14971 
    return
14972 
 
14973 
 
14974 
  def __repr__(self):
14975 
    L = ['%s=%r' % (key, value)
14976 
      for key, value in self.__dict__.iteritems()]
14977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14978 
 
14979 
  def __eq__(self, other):
14980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14981 
 
14982 
  def __ne__(self, other):
14983 
    return not (self == other)
14984 
 
3064 chandransh 14985 
class updateNonDeliveryReason_args:
1627 ankur.sing 14986 
  """
14987 
  Attributes:
3064 chandransh 14988 
   - providerId
14989 
   - undeliveredOrders
1627 ankur.sing 14990 
  """
14991 
 
14992 
  thrift_spec = (
3064 chandransh 14993 
    None, # 0
14994 
    (1, TType.I64, 'providerId', None, None, ), # 1
14995 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14996 
  )
14997 
 
3064 chandransh 14998 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14999 
    self.providerId = providerId
15000 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15001 
 
15002 
  def read(self, iprot):
15003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15005 
      return
15006 
    iprot.readStructBegin()
15007 
    while True:
15008 
      (fname, ftype, fid) = iprot.readFieldBegin()
15009 
      if ftype == TType.STOP:
15010 
        break
3064 chandransh 15011 
      if fid == 1:
1627 ankur.sing 15012 
        if ftype == TType.I64:
3064 chandransh 15013 
          self.providerId = iprot.readI64();
1627 ankur.sing 15014 
        else:
15015 
          iprot.skip(ftype)
3064 chandransh 15016 
      elif fid == 2:
15017 
        if ftype == TType.MAP:
15018 
          self.undeliveredOrders = {}
6188 rajveer 15019 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15020 
          for _i347 in xrange(_size343):
15021 
            _key348 = iprot.readString();
15022 
            _val349 = iprot.readString();
15023 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15024 
          iprot.readMapEnd()
15025 
        else:
15026 
          iprot.skip(ftype)
1627 ankur.sing 15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
3064 chandransh 15036 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15037 
    if self.providerId is not None:
3064 chandransh 15038 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15039 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15040 
      oprot.writeFieldEnd()
3431 rajveer 15041 
    if self.undeliveredOrders is not None:
3064 chandransh 15042 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15043 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15044 
      for kiter350,viter351 in self.undeliveredOrders.items():
15045 
        oprot.writeString(kiter350)
15046 
        oprot.writeString(viter351)
3064 chandransh 15047 
      oprot.writeMapEnd()
15048 
      oprot.writeFieldEnd()
1627 ankur.sing 15049 
    oprot.writeFieldStop()
15050 
    oprot.writeStructEnd()
15051 
 
3431 rajveer 15052 
  def validate(self):
15053 
    return
15054 
 
15055 
 
1627 ankur.sing 15056 
  def __repr__(self):
15057 
    L = ['%s=%r' % (key, value)
15058 
      for key, value in self.__dict__.iteritems()]
15059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15060 
 
15061 
  def __eq__(self, other):
15062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15063 
 
15064 
  def __ne__(self, other):
15065 
    return not (self == other)
15066 
 
3064 chandransh 15067 
class updateNonDeliveryReason_result:
1627 ankur.sing 15068 
  """
15069 
  Attributes:
3064 chandransh 15070 
   - ex
1627 ankur.sing 15071 
  """
15072 
 
15073 
  thrift_spec = (
4910 phani.kuma 15074 
    None, # 0
3064 chandransh 15075 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15076 
  )
15077 
 
4910 phani.kuma 15078 
  def __init__(self, ex=None,):
3064 chandransh 15079 
    self.ex = ex
1627 ankur.sing 15080 
 
15081 
  def read(self, iprot):
15082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15084 
      return
15085 
    iprot.readStructBegin()
15086 
    while True:
15087 
      (fname, ftype, fid) = iprot.readFieldBegin()
15088 
      if ftype == TType.STOP:
15089 
        break
4910 phani.kuma 15090 
      if fid == 1:
15091 
        if ftype == TType.STRUCT:
15092 
          self.ex = TransactionServiceException()
15093 
          self.ex.read(iprot)
15094 
        else:
15095 
          iprot.skip(ftype)
15096 
      else:
15097 
        iprot.skip(ftype)
15098 
      iprot.readFieldEnd()
15099 
    iprot.readStructEnd()
15100 
 
15101 
  def write(self, oprot):
15102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15104 
      return
15105 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15106 
    if self.ex is not None:
15107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15108 
      self.ex.write(oprot)
15109 
      oprot.writeFieldEnd()
15110 
    oprot.writeFieldStop()
15111 
    oprot.writeStructEnd()
15112 
 
15113 
  def validate(self):
15114 
    return
15115 
 
15116 
 
15117 
  def __repr__(self):
15118 
    L = ['%s=%r' % (key, value)
15119 
      for key, value in self.__dict__.iteritems()]
15120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15121 
 
15122 
  def __eq__(self, other):
15123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15124 
 
15125 
  def __ne__(self, other):
15126 
    return not (self == other)
15127 
 
15128 
class getNonDeliveredOrdersbyCourier_args:
15129 
  """
15130 
  Attributes:
15131 
   - providerId
15132 
  """
15133 
 
15134 
  thrift_spec = (
15135 
    None, # 0
15136 
    (1, TType.I64, 'providerId', None, None, ), # 1
15137 
  )
15138 
 
15139 
  def __init__(self, providerId=None,):
15140 
    self.providerId = providerId
15141 
 
15142 
  def read(self, iprot):
15143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15145 
      return
15146 
    iprot.readStructBegin()
15147 
    while True:
15148 
      (fname, ftype, fid) = iprot.readFieldBegin()
15149 
      if ftype == TType.STOP:
15150 
        break
15151 
      if fid == 1:
15152 
        if ftype == TType.I64:
15153 
          self.providerId = iprot.readI64();
15154 
        else:
15155 
          iprot.skip(ftype)
15156 
      else:
15157 
        iprot.skip(ftype)
15158 
      iprot.readFieldEnd()
15159 
    iprot.readStructEnd()
15160 
 
15161 
  def write(self, oprot):
15162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15164 
      return
15165 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15166 
    if self.providerId is not None:
15167 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15168 
      oprot.writeI64(self.providerId)
15169 
      oprot.writeFieldEnd()
15170 
    oprot.writeFieldStop()
15171 
    oprot.writeStructEnd()
15172 
 
15173 
  def validate(self):
15174 
    return
15175 
 
15176 
 
15177 
  def __repr__(self):
15178 
    L = ['%s=%r' % (key, value)
15179 
      for key, value in self.__dict__.iteritems()]
15180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15181 
 
15182 
  def __eq__(self, other):
15183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15184 
 
15185 
  def __ne__(self, other):
15186 
    return not (self == other)
15187 
 
15188 
class getNonDeliveredOrdersbyCourier_result:
15189 
  """
15190 
  Attributes:
15191 
   - success
15192 
  """
15193 
 
15194 
  thrift_spec = (
15195 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15196 
  )
15197 
 
15198 
  def __init__(self, success=None,):
15199 
    self.success = success
15200 
 
15201 
  def read(self, iprot):
15202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15204 
      return
15205 
    iprot.readStructBegin()
15206 
    while True:
15207 
      (fname, ftype, fid) = iprot.readFieldBegin()
15208 
      if ftype == TType.STOP:
15209 
        break
4581 phani.kuma 15210 
      if fid == 0:
15211 
        if ftype == TType.LIST:
15212 
          self.success = []
6188 rajveer 15213 
          (_etype355, _size352) = iprot.readListBegin()
15214 
          for _i356 in xrange(_size352):
15215 
            _elem357 = Order()
15216 
            _elem357.read(iprot)
15217 
            self.success.append(_elem357)
4581 phani.kuma 15218 
          iprot.readListEnd()
15219 
        else:
15220 
          iprot.skip(ftype)
4910 phani.kuma 15221 
      else:
15222 
        iprot.skip(ftype)
15223 
      iprot.readFieldEnd()
15224 
    iprot.readStructEnd()
15225 
 
15226 
  def write(self, oprot):
15227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15229 
      return
15230 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15231 
    if self.success is not None:
15232 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15233 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15234 
      for iter358 in self.success:
15235 
        iter358.write(oprot)
4910 phani.kuma 15236 
      oprot.writeListEnd()
15237 
      oprot.writeFieldEnd()
15238 
    oprot.writeFieldStop()
15239 
    oprot.writeStructEnd()
15240 
 
15241 
  def validate(self):
15242 
    return
15243 
 
15244 
 
15245 
  def __repr__(self):
15246 
    L = ['%s=%r' % (key, value)
15247 
      for key, value in self.__dict__.iteritems()]
15248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15249 
 
15250 
  def __eq__(self, other):
15251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15252 
 
15253 
  def __ne__(self, other):
15254 
    return not (self == other)
15255 
 
15256 
class markOrdersAsLocalConnected_args:
15257 
  """
15258 
  Attributes:
15259 
   - providerId
15260 
   - local_connected_orders
15261 
  """
15262 
 
15263 
  thrift_spec = (
15264 
    None, # 0
15265 
    (1, TType.I64, 'providerId', None, None, ), # 1
15266 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15267 
  )
15268 
 
15269 
  def __init__(self, providerId=None, local_connected_orders=None,):
15270 
    self.providerId = providerId
15271 
    self.local_connected_orders = local_connected_orders
15272 
 
15273 
  def read(self, iprot):
15274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15276 
      return
15277 
    iprot.readStructBegin()
15278 
    while True:
15279 
      (fname, ftype, fid) = iprot.readFieldBegin()
15280 
      if ftype == TType.STOP:
15281 
        break
15282 
      if fid == 1:
15283 
        if ftype == TType.I64:
15284 
          self.providerId = iprot.readI64();
15285 
        else:
15286 
          iprot.skip(ftype)
15287 
      elif fid == 2:
15288 
        if ftype == TType.MAP:
15289 
          self.local_connected_orders = {}
6188 rajveer 15290 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15291 
          for _i363 in xrange(_size359):
15292 
            _key364 = iprot.readString();
15293 
            _val365 = iprot.readString();
15294 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15295 
          iprot.readMapEnd()
15296 
        else:
15297 
          iprot.skip(ftype)
15298 
      else:
15299 
        iprot.skip(ftype)
15300 
      iprot.readFieldEnd()
15301 
    iprot.readStructEnd()
15302 
 
15303 
  def write(self, oprot):
15304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15306 
      return
15307 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15308 
    if self.providerId is not None:
15309 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15310 
      oprot.writeI64(self.providerId)
15311 
      oprot.writeFieldEnd()
15312 
    if self.local_connected_orders is not None:
15313 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15314 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15315 
      for kiter366,viter367 in self.local_connected_orders.items():
15316 
        oprot.writeString(kiter366)
15317 
        oprot.writeString(viter367)
4910 phani.kuma 15318 
      oprot.writeMapEnd()
15319 
      oprot.writeFieldEnd()
15320 
    oprot.writeFieldStop()
15321 
    oprot.writeStructEnd()
15322 
 
15323 
  def validate(self):
15324 
    return
15325 
 
15326 
 
15327 
  def __repr__(self):
15328 
    L = ['%s=%r' % (key, value)
15329 
      for key, value in self.__dict__.iteritems()]
15330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15331 
 
15332 
  def __eq__(self, other):
15333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15334 
 
15335 
  def __ne__(self, other):
15336 
    return not (self == other)
15337 
 
15338 
class markOrdersAsLocalConnected_result:
15339 
  """
15340 
  Attributes:
15341 
   - ex
15342 
  """
15343 
 
15344 
  thrift_spec = (
15345 
    None, # 0
15346 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15347 
  )
15348 
 
15349 
  def __init__(self, ex=None,):
15350 
    self.ex = ex
15351 
 
15352 
  def read(self, iprot):
15353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15355 
      return
15356 
    iprot.readStructBegin()
15357 
    while True:
15358 
      (fname, ftype, fid) = iprot.readFieldBegin()
15359 
      if ftype == TType.STOP:
15360 
        break
15361 
      if fid == 1:
3064 chandransh 15362 
        if ftype == TType.STRUCT:
15363 
          self.ex = TransactionServiceException()
15364 
          self.ex.read(iprot)
1627 ankur.sing 15365 
        else:
15366 
          iprot.skip(ftype)
15367 
      else:
15368 
        iprot.skip(ftype)
15369 
      iprot.readFieldEnd()
15370 
    iprot.readStructEnd()
15371 
 
15372 
  def write(self, oprot):
15373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15375 
      return
4910 phani.kuma 15376 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15377 
    if self.ex is not None:
15378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15379 
      self.ex.write(oprot)
15380 
      oprot.writeFieldEnd()
15381 
    oprot.writeFieldStop()
15382 
    oprot.writeStructEnd()
15383 
 
15384 
  def validate(self):
15385 
    return
15386 
 
15387 
 
15388 
  def __repr__(self):
15389 
    L = ['%s=%r' % (key, value)
15390 
      for key, value in self.__dict__.iteritems()]
15391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15392 
 
15393 
  def __eq__(self, other):
15394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15395 
 
15396 
  def __ne__(self, other):
15397 
    return not (self == other)
15398 
 
15399 
class getOrdersNotLocalConnected_args:
15400 
  """
15401 
  Attributes:
15402 
   - providerId
15403 
  """
15404 
 
15405 
  thrift_spec = (
15406 
    None, # 0
15407 
    (1, TType.I64, 'providerId', None, None, ), # 1
15408 
  )
15409 
 
15410 
  def __init__(self, providerId=None,):
15411 
    self.providerId = providerId
15412 
 
15413 
  def read(self, iprot):
15414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15416 
      return
15417 
    iprot.readStructBegin()
15418 
    while True:
15419 
      (fname, ftype, fid) = iprot.readFieldBegin()
15420 
      if ftype == TType.STOP:
15421 
        break
15422 
      if fid == 1:
15423 
        if ftype == TType.I64:
15424 
          self.providerId = iprot.readI64();
15425 
        else:
15426 
          iprot.skip(ftype)
15427 
      else:
15428 
        iprot.skip(ftype)
15429 
      iprot.readFieldEnd()
15430 
    iprot.readStructEnd()
15431 
 
15432 
  def write(self, oprot):
15433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15435 
      return
15436 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15437 
    if self.providerId is not None:
15438 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15439 
      oprot.writeI64(self.providerId)
15440 
      oprot.writeFieldEnd()
15441 
    oprot.writeFieldStop()
15442 
    oprot.writeStructEnd()
15443 
 
15444 
  def validate(self):
15445 
    return
15446 
 
15447 
 
15448 
  def __repr__(self):
15449 
    L = ['%s=%r' % (key, value)
15450 
      for key, value in self.__dict__.iteritems()]
15451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15452 
 
15453 
  def __eq__(self, other):
15454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15455 
 
15456 
  def __ne__(self, other):
15457 
    return not (self == other)
15458 
 
15459 
class getOrdersNotLocalConnected_result:
15460 
  """
15461 
  Attributes:
15462 
   - success
15463 
  """
15464 
 
15465 
  thrift_spec = (
15466 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15467 
  )
15468 
 
15469 
  def __init__(self, success=None,):
15470 
    self.success = success
15471 
 
15472 
  def read(self, iprot):
15473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15475 
      return
15476 
    iprot.readStructBegin()
15477 
    while True:
15478 
      (fname, ftype, fid) = iprot.readFieldBegin()
15479 
      if ftype == TType.STOP:
15480 
        break
15481 
      if fid == 0:
15482 
        if ftype == TType.LIST:
15483 
          self.success = []
6188 rajveer 15484 
          (_etype371, _size368) = iprot.readListBegin()
15485 
          for _i372 in xrange(_size368):
15486 
            _elem373 = Order()
15487 
            _elem373.read(iprot)
15488 
            self.success.append(_elem373)
4910 phani.kuma 15489 
          iprot.readListEnd()
15490 
        else:
15491 
          iprot.skip(ftype)
15492 
      else:
15493 
        iprot.skip(ftype)
15494 
      iprot.readFieldEnd()
15495 
    iprot.readStructEnd()
15496 
 
15497 
  def write(self, oprot):
15498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15500 
      return
15501 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15502 
    if self.success is not None:
15503 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15504 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15505 
      for iter374 in self.success:
15506 
        iter374.write(oprot)
4581 phani.kuma 15507 
      oprot.writeListEnd()
15508 
      oprot.writeFieldEnd()
4910 phani.kuma 15509 
    oprot.writeFieldStop()
15510 
    oprot.writeStructEnd()
15511 
 
15512 
  def validate(self):
15513 
    return
15514 
 
15515 
 
15516 
  def __repr__(self):
15517 
    L = ['%s=%r' % (key, value)
15518 
      for key, value in self.__dict__.iteritems()]
15519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15520 
 
15521 
  def __eq__(self, other):
15522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15523 
 
15524 
  def __ne__(self, other):
15525 
    return not (self == other)
15526 
 
15527 
class markOrdersAsDestinationCityReached_args:
15528 
  """
15529 
  Attributes:
15530 
   - providerId
15531 
   - destination_city_reached_orders
15532 
  """
15533 
 
15534 
  thrift_spec = (
15535 
    None, # 0
15536 
    (1, TType.I64, 'providerId', None, None, ), # 1
15537 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15538 
  )
15539 
 
15540 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15541 
    self.providerId = providerId
15542 
    self.destination_city_reached_orders = destination_city_reached_orders
15543 
 
15544 
  def read(self, iprot):
15545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15547 
      return
15548 
    iprot.readStructBegin()
15549 
    while True:
15550 
      (fname, ftype, fid) = iprot.readFieldBegin()
15551 
      if ftype == TType.STOP:
15552 
        break
15553 
      if fid == 1:
15554 
        if ftype == TType.I64:
15555 
          self.providerId = iprot.readI64();
15556 
        else:
15557 
          iprot.skip(ftype)
15558 
      elif fid == 2:
15559 
        if ftype == TType.MAP:
15560 
          self.destination_city_reached_orders = {}
6188 rajveer 15561 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15562 
          for _i379 in xrange(_size375):
15563 
            _key380 = iprot.readString();
15564 
            _val381 = iprot.readString();
15565 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15566 
          iprot.readMapEnd()
15567 
        else:
15568 
          iprot.skip(ftype)
15569 
      else:
15570 
        iprot.skip(ftype)
15571 
      iprot.readFieldEnd()
15572 
    iprot.readStructEnd()
15573 
 
15574 
  def write(self, oprot):
15575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15577 
      return
15578 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15579 
    if self.providerId is not None:
15580 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15581 
      oprot.writeI64(self.providerId)
15582 
      oprot.writeFieldEnd()
15583 
    if self.destination_city_reached_orders is not None:
15584 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15585 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15586 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15587 
        oprot.writeString(kiter382)
15588 
        oprot.writeString(viter383)
4910 phani.kuma 15589 
      oprot.writeMapEnd()
15590 
      oprot.writeFieldEnd()
15591 
    oprot.writeFieldStop()
15592 
    oprot.writeStructEnd()
15593 
 
15594 
  def validate(self):
15595 
    return
15596 
 
15597 
 
15598 
  def __repr__(self):
15599 
    L = ['%s=%r' % (key, value)
15600 
      for key, value in self.__dict__.iteritems()]
15601 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15602 
 
15603 
  def __eq__(self, other):
15604 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15605 
 
15606 
  def __ne__(self, other):
15607 
    return not (self == other)
15608 
 
15609 
class markOrdersAsDestinationCityReached_result:
15610 
  """
15611 
  Attributes:
15612 
   - ex
15613 
  """
15614 
 
15615 
  thrift_spec = (
15616 
    None, # 0
15617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15618 
  )
15619 
 
15620 
  def __init__(self, ex=None,):
15621 
    self.ex = ex
15622 
 
15623 
  def read(self, iprot):
15624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15626 
      return
15627 
    iprot.readStructBegin()
15628 
    while True:
15629 
      (fname, ftype, fid) = iprot.readFieldBegin()
15630 
      if ftype == TType.STOP:
15631 
        break
15632 
      if fid == 1:
15633 
        if ftype == TType.STRUCT:
15634 
          self.ex = TransactionServiceException()
15635 
          self.ex.read(iprot)
15636 
        else:
15637 
          iprot.skip(ftype)
15638 
      else:
15639 
        iprot.skip(ftype)
15640 
      iprot.readFieldEnd()
15641 
    iprot.readStructEnd()
15642 
 
15643 
  def write(self, oprot):
15644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15646 
      return
15647 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15648 
    if self.ex is not None:
3064 chandransh 15649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15650 
      self.ex.write(oprot)
1627 ankur.sing 15651 
      oprot.writeFieldEnd()
15652 
    oprot.writeFieldStop()
15653 
    oprot.writeStructEnd()
15654 
 
3431 rajveer 15655 
  def validate(self):
15656 
    return
15657 
 
15658 
 
1627 ankur.sing 15659 
  def __repr__(self):
15660 
    L = ['%s=%r' % (key, value)
15661 
      for key, value in self.__dict__.iteritems()]
15662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15663 
 
15664 
  def __eq__(self, other):
15665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15666 
 
15667 
  def __ne__(self, other):
15668 
    return not (self == other)
15669 
 
4910 phani.kuma 15670 
class markOrdersAsFirstDeliveryAttempted_args:
15671 
  """
15672 
  Attributes:
15673 
   - providerId
15674 
   - first_atdl_orders
15675 
  """
15676 
 
15677 
  thrift_spec = (
15678 
    None, # 0
15679 
    (1, TType.I64, 'providerId', None, None, ), # 1
15680 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15681 
  )
15682 
 
15683 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15684 
    self.providerId = providerId
15685 
    self.first_atdl_orders = first_atdl_orders
15686 
 
15687 
  def read(self, iprot):
15688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15690 
      return
15691 
    iprot.readStructBegin()
15692 
    while True:
15693 
      (fname, ftype, fid) = iprot.readFieldBegin()
15694 
      if ftype == TType.STOP:
15695 
        break
15696 
      if fid == 1:
15697 
        if ftype == TType.I64:
15698 
          self.providerId = iprot.readI64();
15699 
        else:
15700 
          iprot.skip(ftype)
15701 
      elif fid == 2:
15702 
        if ftype == TType.MAP:
15703 
          self.first_atdl_orders = {}
6188 rajveer 15704 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15705 
          for _i388 in xrange(_size384):
15706 
            _key389 = iprot.readString();
15707 
            _val390 = iprot.readString();
15708 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15709 
          iprot.readMapEnd()
15710 
        else:
15711 
          iprot.skip(ftype)
15712 
      else:
15713 
        iprot.skip(ftype)
15714 
      iprot.readFieldEnd()
15715 
    iprot.readStructEnd()
15716 
 
15717 
  def write(self, oprot):
15718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15720 
      return
15721 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15722 
    if self.providerId is not None:
15723 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15724 
      oprot.writeI64(self.providerId)
15725 
      oprot.writeFieldEnd()
15726 
    if self.first_atdl_orders is not None:
15727 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15728 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15729 
      for kiter391,viter392 in self.first_atdl_orders.items():
15730 
        oprot.writeString(kiter391)
15731 
        oprot.writeString(viter392)
4910 phani.kuma 15732 
      oprot.writeMapEnd()
15733 
      oprot.writeFieldEnd()
15734 
    oprot.writeFieldStop()
15735 
    oprot.writeStructEnd()
15736 
 
15737 
  def validate(self):
15738 
    return
15739 
 
15740 
 
15741 
  def __repr__(self):
15742 
    L = ['%s=%r' % (key, value)
15743 
      for key, value in self.__dict__.iteritems()]
15744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15745 
 
15746 
  def __eq__(self, other):
15747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15748 
 
15749 
  def __ne__(self, other):
15750 
    return not (self == other)
15751 
 
15752 
class markOrdersAsFirstDeliveryAttempted_result:
15753 
  """
15754 
  Attributes:
15755 
   - ex
15756 
  """
15757 
 
15758 
  thrift_spec = (
15759 
    None, # 0
15760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15761 
  )
15762 
 
15763 
  def __init__(self, ex=None,):
15764 
    self.ex = ex
15765 
 
15766 
  def read(self, iprot):
15767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15769 
      return
15770 
    iprot.readStructBegin()
15771 
    while True:
15772 
      (fname, ftype, fid) = iprot.readFieldBegin()
15773 
      if ftype == TType.STOP:
15774 
        break
15775 
      if fid == 1:
15776 
        if ftype == TType.STRUCT:
15777 
          self.ex = TransactionServiceException()
15778 
          self.ex.read(iprot)
15779 
        else:
15780 
          iprot.skip(ftype)
15781 
      else:
15782 
        iprot.skip(ftype)
15783 
      iprot.readFieldEnd()
15784 
    iprot.readStructEnd()
15785 
 
15786 
  def write(self, oprot):
15787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15789 
      return
15790 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15791 
    if self.ex is not None:
15792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15793 
      self.ex.write(oprot)
15794 
      oprot.writeFieldEnd()
15795 
    oprot.writeFieldStop()
15796 
    oprot.writeStructEnd()
15797 
 
15798 
  def validate(self):
15799 
    return
15800 
 
15801 
 
15802 
  def __repr__(self):
15803 
    L = ['%s=%r' % (key, value)
15804 
      for key, value in self.__dict__.iteritems()]
15805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15806 
 
15807 
  def __eq__(self, other):
15808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15809 
 
15810 
  def __ne__(self, other):
15811 
    return not (self == other)
15812 
 
3064 chandransh 15813 
class getUndeliveredOrders_args:
1886 ankur.sing 15814 
  """
15815 
  Attributes:
3064 chandransh 15816 
   - providerId
15817 
   - warehouseId
1886 ankur.sing 15818 
  """
1627 ankur.sing 15819 
 
1886 ankur.sing 15820 
  thrift_spec = (
15821 
    None, # 0
3064 chandransh 15822 
    (1, TType.I64, 'providerId', None, None, ), # 1
15823 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15824 
  )
15825 
 
3064 chandransh 15826 
  def __init__(self, providerId=None, warehouseId=None,):
15827 
    self.providerId = providerId
15828 
    self.warehouseId = warehouseId
1886 ankur.sing 15829 
 
15830 
  def read(self, iprot):
15831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15833 
      return
15834 
    iprot.readStructBegin()
15835 
    while True:
15836 
      (fname, ftype, fid) = iprot.readFieldBegin()
15837 
      if ftype == TType.STOP:
15838 
        break
15839 
      if fid == 1:
15840 
        if ftype == TType.I64:
3064 chandransh 15841 
          self.providerId = iprot.readI64();
1886 ankur.sing 15842 
        else:
15843 
          iprot.skip(ftype)
3064 chandransh 15844 
      elif fid == 2:
15845 
        if ftype == TType.I64:
15846 
          self.warehouseId = iprot.readI64();
15847 
        else:
15848 
          iprot.skip(ftype)
1886 ankur.sing 15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
3064 chandransh 15858 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15859 
    if self.providerId is not None:
3064 chandransh 15860 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15861 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15862 
      oprot.writeFieldEnd()
3431 rajveer 15863 
    if self.warehouseId is not None:
3064 chandransh 15864 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15865 
      oprot.writeI64(self.warehouseId)
15866 
      oprot.writeFieldEnd()
1886 ankur.sing 15867 
    oprot.writeFieldStop()
15868 
    oprot.writeStructEnd()
15869 
 
3431 rajveer 15870 
  def validate(self):
15871 
    return
15872 
 
15873 
 
1886 ankur.sing 15874 
  def __repr__(self):
15875 
    L = ['%s=%r' % (key, value)
15876 
      for key, value in self.__dict__.iteritems()]
15877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15878 
 
15879 
  def __eq__(self, other):
15880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15881 
 
15882 
  def __ne__(self, other):
15883 
    return not (self == other)
15884 
 
3064 chandransh 15885 
class getUndeliveredOrders_result:
1886 ankur.sing 15886 
  """
15887 
  Attributes:
15888 
   - success
15889 
  """
15890 
 
15891 
  thrift_spec = (
15892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15893 
  )
15894 
 
15895 
  def __init__(self, success=None,):
15896 
    self.success = success
15897 
 
15898 
  def read(self, iprot):
15899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15901 
      return
15902 
    iprot.readStructBegin()
15903 
    while True:
15904 
      (fname, ftype, fid) = iprot.readFieldBegin()
15905 
      if ftype == TType.STOP:
15906 
        break
15907 
      if fid == 0:
15908 
        if ftype == TType.LIST:
15909 
          self.success = []
6188 rajveer 15910 
          (_etype396, _size393) = iprot.readListBegin()
15911 
          for _i397 in xrange(_size393):
15912 
            _elem398 = Order()
15913 
            _elem398.read(iprot)
15914 
            self.success.append(_elem398)
1886 ankur.sing 15915 
          iprot.readListEnd()
15916 
        else:
15917 
          iprot.skip(ftype)
15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
3064 chandransh 15927 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15928 
    if self.success is not None:
1886 ankur.sing 15929 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15930 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15931 
      for iter399 in self.success:
15932 
        iter399.write(oprot)
1886 ankur.sing 15933 
      oprot.writeListEnd()
15934 
      oprot.writeFieldEnd()
15935 
    oprot.writeFieldStop()
15936 
    oprot.writeStructEnd()
15937 
 
3431 rajveer 15938 
  def validate(self):
15939 
    return
15940 
 
15941 
 
1886 ankur.sing 15942 
  def __repr__(self):
15943 
    L = ['%s=%r' % (key, value)
15944 
      for key, value in self.__dict__.iteritems()]
15945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15946 
 
15947 
  def __eq__(self, other):
15948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15949 
 
15950 
  def __ne__(self, other):
15951 
    return not (self == other)
15952 
 
4783 phani.kuma 15953 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15954 
 
15955 
  thrift_spec = (
15956 
  )
15957 
 
15958 
  def read(self, iprot):
15959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15961 
      return
15962 
    iprot.readStructBegin()
15963 
    while True:
15964 
      (fname, ftype, fid) = iprot.readFieldBegin()
15965 
      if ftype == TType.STOP:
15966 
        break
15967 
      else:
15968 
        iprot.skip(ftype)
15969 
      iprot.readFieldEnd()
15970 
    iprot.readStructEnd()
15971 
 
15972 
  def write(self, oprot):
15973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15975 
      return
15976 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15977 
    oprot.writeFieldStop()
15978 
    oprot.writeStructEnd()
15979 
 
15980 
  def validate(self):
15981 
    return
15982 
 
15983 
 
15984 
  def __repr__(self):
15985 
    L = ['%s=%r' % (key, value)
15986 
      for key, value in self.__dict__.iteritems()]
15987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15988 
 
15989 
  def __eq__(self, other):
15990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15991 
 
15992 
  def __ne__(self, other):
15993 
    return not (self == other)
15994 
 
15995 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15996 
  """
15997 
  Attributes:
15998 
   - success
15999 
  """
16000 
 
16001 
  thrift_spec = (
16002 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16003 
  )
16004 
 
16005 
  def __init__(self, success=None,):
16006 
    self.success = success
16007 
 
16008 
  def read(self, iprot):
16009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16011 
      return
16012 
    iprot.readStructBegin()
16013 
    while True:
16014 
      (fname, ftype, fid) = iprot.readFieldBegin()
16015 
      if ftype == TType.STOP:
16016 
        break
16017 
      if fid == 0:
16018 
        if ftype == TType.LIST:
16019 
          self.success = []
6188 rajveer 16020 
          (_etype403, _size400) = iprot.readListBegin()
16021 
          for _i404 in xrange(_size400):
16022 
            _elem405 = Order()
16023 
            _elem405.read(iprot)
16024 
            self.success.append(_elem405)
4783 phani.kuma 16025 
          iprot.readListEnd()
16026 
        else:
16027 
          iprot.skip(ftype)
16028 
      else:
16029 
        iprot.skip(ftype)
16030 
      iprot.readFieldEnd()
16031 
    iprot.readStructEnd()
16032 
 
16033 
  def write(self, oprot):
16034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16036 
      return
16037 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16038 
    if self.success is not None:
16039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16041 
      for iter406 in self.success:
16042 
        iter406.write(oprot)
4783 phani.kuma 16043 
      oprot.writeListEnd()
16044 
      oprot.writeFieldEnd()
16045 
    oprot.writeFieldStop()
16046 
    oprot.writeStructEnd()
16047 
 
16048 
  def validate(self):
16049 
    return
16050 
 
16051 
 
16052 
  def __repr__(self):
16053 
    L = ['%s=%r' % (key, value)
16054 
      for key, value in self.__dict__.iteritems()]
16055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16056 
 
16057 
  def __eq__(self, other):
16058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16059 
 
16060 
  def __ne__(self, other):
16061 
    return not (self == other)
16062 
 
2536 chandransh 16063 
class toggleDOAFlag_args:
16064 
  """
16065 
  Attributes:
16066 
   - orderId
16067 
  """
1886 ankur.sing 16068 
 
2536 chandransh 16069 
  thrift_spec = (
16070 
    None, # 0
16071 
    (1, TType.I64, 'orderId', None, None, ), # 1
16072 
  )
16073 
 
16074 
  def __init__(self, orderId=None,):
16075 
    self.orderId = orderId
16076 
 
16077 
  def read(self, iprot):
16078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16080 
      return
16081 
    iprot.readStructBegin()
16082 
    while True:
16083 
      (fname, ftype, fid) = iprot.readFieldBegin()
16084 
      if ftype == TType.STOP:
16085 
        break
16086 
      if fid == 1:
16087 
        if ftype == TType.I64:
16088 
          self.orderId = iprot.readI64();
16089 
        else:
16090 
          iprot.skip(ftype)
16091 
      else:
16092 
        iprot.skip(ftype)
16093 
      iprot.readFieldEnd()
16094 
    iprot.readStructEnd()
16095 
 
16096 
  def write(self, oprot):
16097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16099 
      return
16100 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16101 
    if self.orderId is not None:
2536 chandransh 16102 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16103 
      oprot.writeI64(self.orderId)
16104 
      oprot.writeFieldEnd()
16105 
    oprot.writeFieldStop()
16106 
    oprot.writeStructEnd()
16107 
 
3431 rajveer 16108 
  def validate(self):
16109 
    return
16110 
 
16111 
 
2536 chandransh 16112 
  def __repr__(self):
16113 
    L = ['%s=%r' % (key, value)
16114 
      for key, value in self.__dict__.iteritems()]
16115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16116 
 
16117 
  def __eq__(self, other):
16118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16119 
 
16120 
  def __ne__(self, other):
16121 
    return not (self == other)
16122 
 
16123 
class toggleDOAFlag_result:
16124 
  """
16125 
  Attributes:
16126 
   - success
16127 
   - ex
16128 
  """
16129 
 
16130 
  thrift_spec = (
16131 
    (0, TType.BOOL, 'success', None, None, ), # 0
16132 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16133 
  )
16134 
 
16135 
  def __init__(self, success=None, ex=None,):
16136 
    self.success = success
16137 
    self.ex = ex
16138 
 
16139 
  def read(self, iprot):
16140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16142 
      return
16143 
    iprot.readStructBegin()
16144 
    while True:
16145 
      (fname, ftype, fid) = iprot.readFieldBegin()
16146 
      if ftype == TType.STOP:
16147 
        break
16148 
      if fid == 0:
16149 
        if ftype == TType.BOOL:
16150 
          self.success = iprot.readBool();
16151 
        else:
16152 
          iprot.skip(ftype)
16153 
      elif fid == 1:
16154 
        if ftype == TType.STRUCT:
16155 
          self.ex = TransactionServiceException()
16156 
          self.ex.read(iprot)
16157 
        else:
16158 
          iprot.skip(ftype)
16159 
      else:
16160 
        iprot.skip(ftype)
16161 
      iprot.readFieldEnd()
16162 
    iprot.readStructEnd()
16163 
 
16164 
  def write(self, oprot):
16165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16167 
      return
16168 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16169 
    if self.success is not None:
2536 chandransh 16170 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16171 
      oprot.writeBool(self.success)
16172 
      oprot.writeFieldEnd()
3431 rajveer 16173 
    if self.ex is not None:
2536 chandransh 16174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16175 
      self.ex.write(oprot)
16176 
      oprot.writeFieldEnd()
16177 
    oprot.writeFieldStop()
16178 
    oprot.writeStructEnd()
16179 
 
3431 rajveer 16180 
  def validate(self):
16181 
    return
16182 
 
16183 
 
2536 chandransh 16184 
  def __repr__(self):
16185 
    L = ['%s=%r' % (key, value)
16186 
      for key, value in self.__dict__.iteritems()]
16187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16188 
 
16189 
  def __eq__(self, other):
16190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16191 
 
16192 
  def __ne__(self, other):
16193 
    return not (self == other)
16194 
 
4712 rajveer 16195 
class markOrderAsDelivered_args:
16196 
  """
16197 
  Attributes:
16198 
   - orderId
16199 
   - deliveryTimestamp
16200 
   - receiver
16201 
  """
16202 
 
16203 
  thrift_spec = None
16204 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16205 
    self.orderId = orderId
16206 
    self.deliveryTimestamp = deliveryTimestamp
16207 
    self.receiver = receiver
16208 
 
16209 
  def read(self, iprot):
16210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16212 
      return
16213 
    iprot.readStructBegin()
16214 
    while True:
16215 
      (fname, ftype, fid) = iprot.readFieldBegin()
16216 
      if ftype == TType.STOP:
16217 
        break
16218 
      if fid == 1:
16219 
        if ftype == TType.I64:
16220 
          self.orderId = iprot.readI64();
16221 
        else:
16222 
          iprot.skip(ftype)
16223 
      elif fid == 2:
16224 
        if ftype == TType.I64:
16225 
          self.deliveryTimestamp = iprot.readI64();
16226 
        else:
16227 
          iprot.skip(ftype)
16228 
      elif fid == -1:
16229 
        if ftype == TType.STRING:
16230 
          self.receiver = iprot.readString();
16231 
        else:
16232 
          iprot.skip(ftype)
16233 
      else:
16234 
        iprot.skip(ftype)
16235 
      iprot.readFieldEnd()
16236 
    iprot.readStructEnd()
16237 
 
16238 
  def write(self, oprot):
16239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16241 
      return
16242 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16243 
    if self.receiver is not None:
16244 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16245 
      oprot.writeString(self.receiver)
16246 
      oprot.writeFieldEnd()
16247 
    if self.orderId is not None:
16248 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16249 
      oprot.writeI64(self.orderId)
16250 
      oprot.writeFieldEnd()
16251 
    if self.deliveryTimestamp is not None:
16252 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16253 
      oprot.writeI64(self.deliveryTimestamp)
16254 
      oprot.writeFieldEnd()
16255 
    oprot.writeFieldStop()
16256 
    oprot.writeStructEnd()
16257 
 
16258 
  def validate(self):
16259 
    return
16260 
 
16261 
 
16262 
  def __repr__(self):
16263 
    L = ['%s=%r' % (key, value)
16264 
      for key, value in self.__dict__.iteritems()]
16265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16266 
 
16267 
  def __eq__(self, other):
16268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16269 
 
16270 
  def __ne__(self, other):
16271 
    return not (self == other)
16272 
 
16273 
class markOrderAsDelivered_result:
16274 
  """
16275 
  Attributes:
16276 
   - ex
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    None, # 0
16281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16282 
  )
16283 
 
16284 
  def __init__(self, ex=None,):
16285 
    self.ex = ex
16286 
 
16287 
  def read(self, iprot):
16288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16290 
      return
16291 
    iprot.readStructBegin()
16292 
    while True:
16293 
      (fname, ftype, fid) = iprot.readFieldBegin()
16294 
      if ftype == TType.STOP:
16295 
        break
16296 
      if fid == 1:
16297 
        if ftype == TType.STRUCT:
16298 
          self.ex = TransactionServiceException()
16299 
          self.ex.read(iprot)
16300 
        else:
16301 
          iprot.skip(ftype)
16302 
      else:
16303 
        iprot.skip(ftype)
16304 
      iprot.readFieldEnd()
16305 
    iprot.readStructEnd()
16306 
 
16307 
  def write(self, oprot):
16308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16310 
      return
16311 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16312 
    if self.ex is not None:
16313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16314 
      self.ex.write(oprot)
16315 
      oprot.writeFieldEnd()
16316 
    oprot.writeFieldStop()
16317 
    oprot.writeStructEnd()
16318 
 
16319 
  def validate(self):
16320 
    return
16321 
 
16322 
 
16323 
  def __repr__(self):
16324 
    L = ['%s=%r' % (key, value)
16325 
      for key, value in self.__dict__.iteritems()]
16326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16327 
 
16328 
  def __eq__(self, other):
16329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16330 
 
16331 
  def __ne__(self, other):
16332 
    return not (self == other)
16333 
 
5553 rajveer 16334 
class markOrderAsReceivedAtStore_args:
16335 
  """
16336 
  Attributes:
16337 
   - orderId
16338 
   - deliveryTimestamp
16339 
  """
16340 
 
16341 
  thrift_spec = (
16342 
    None, # 0
16343 
    (1, TType.I64, 'orderId', None, None, ), # 1
16344 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16345 
  )
16346 
 
16347 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16348 
    self.orderId = orderId
16349 
    self.deliveryTimestamp = deliveryTimestamp
16350 
 
16351 
  def read(self, iprot):
16352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16354 
      return
16355 
    iprot.readStructBegin()
16356 
    while True:
16357 
      (fname, ftype, fid) = iprot.readFieldBegin()
16358 
      if ftype == TType.STOP:
16359 
        break
16360 
      if fid == 1:
16361 
        if ftype == TType.I64:
16362 
          self.orderId = iprot.readI64();
16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      elif fid == 2:
16366 
        if ftype == TType.I64:
16367 
          self.deliveryTimestamp = iprot.readI64();
16368 
        else:
16369 
          iprot.skip(ftype)
16370 
      else:
16371 
        iprot.skip(ftype)
16372 
      iprot.readFieldEnd()
16373 
    iprot.readStructEnd()
16374 
 
16375 
  def write(self, oprot):
16376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16378 
      return
16379 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16380 
    if self.orderId is not None:
16381 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16382 
      oprot.writeI64(self.orderId)
16383 
      oprot.writeFieldEnd()
16384 
    if self.deliveryTimestamp is not None:
16385 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16386 
      oprot.writeI64(self.deliveryTimestamp)
16387 
      oprot.writeFieldEnd()
16388 
    oprot.writeFieldStop()
16389 
    oprot.writeStructEnd()
16390 
 
16391 
  def validate(self):
16392 
    return
16393 
 
16394 
 
16395 
  def __repr__(self):
16396 
    L = ['%s=%r' % (key, value)
16397 
      for key, value in self.__dict__.iteritems()]
16398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16399 
 
16400 
  def __eq__(self, other):
16401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16402 
 
16403 
  def __ne__(self, other):
16404 
    return not (self == other)
16405 
 
16406 
class markOrderAsReceivedAtStore_result:
16407 
  """
16408 
  Attributes:
16409 
   - ex
16410 
  """
16411 
 
16412 
  thrift_spec = (
16413 
    None, # 0
16414 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16415 
  )
16416 
 
16417 
  def __init__(self, ex=None,):
16418 
    self.ex = ex
16419 
 
16420 
  def read(self, iprot):
16421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16423 
      return
16424 
    iprot.readStructBegin()
16425 
    while True:
16426 
      (fname, ftype, fid) = iprot.readFieldBegin()
16427 
      if ftype == TType.STOP:
16428 
        break
16429 
      if fid == 1:
16430 
        if ftype == TType.STRUCT:
16431 
          self.ex = TransactionServiceException()
16432 
          self.ex.read(iprot)
16433 
        else:
16434 
          iprot.skip(ftype)
16435 
      else:
16436 
        iprot.skip(ftype)
16437 
      iprot.readFieldEnd()
16438 
    iprot.readStructEnd()
16439 
 
16440 
  def write(self, oprot):
16441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16443 
      return
16444 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16445 
    if self.ex is not None:
16446 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16447 
      self.ex.write(oprot)
16448 
      oprot.writeFieldEnd()
16449 
    oprot.writeFieldStop()
16450 
    oprot.writeStructEnd()
16451 
 
16452 
  def validate(self):
16453 
    return
16454 
 
16455 
 
16456 
  def __repr__(self):
16457 
    L = ['%s=%r' % (key, value)
16458 
      for key, value in self.__dict__.iteritems()]
16459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16460 
 
16461 
  def __eq__(self, other):
16462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16463 
 
16464 
  def __ne__(self, other):
16465 
    return not (self == other)
16466 
 
4454 rajveer 16467 
class markOrderDoaRequestReceived_args:
16468 
  """
16469 
  Attributes:
16470 
   - orderId
16471 
  """
16472 
 
16473 
  thrift_spec = (
16474 
    None, # 0
16475 
    (1, TType.I64, 'orderId', None, None, ), # 1
16476 
  )
16477 
 
16478 
  def __init__(self, orderId=None,):
16479 
    self.orderId = orderId
16480 
 
16481 
  def read(self, iprot):
16482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16484 
      return
16485 
    iprot.readStructBegin()
16486 
    while True:
16487 
      (fname, ftype, fid) = iprot.readFieldBegin()
16488 
      if ftype == TType.STOP:
16489 
        break
16490 
      if fid == 1:
16491 
        if ftype == TType.I64:
16492 
          self.orderId = iprot.readI64();
16493 
        else:
16494 
          iprot.skip(ftype)
16495 
      else:
16496 
        iprot.skip(ftype)
16497 
      iprot.readFieldEnd()
16498 
    iprot.readStructEnd()
16499 
 
16500 
  def write(self, oprot):
16501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16503 
      return
16504 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16505 
    if self.orderId is not None:
16506 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16507 
      oprot.writeI64(self.orderId)
16508 
      oprot.writeFieldEnd()
16509 
    oprot.writeFieldStop()
16510 
    oprot.writeStructEnd()
16511 
 
16512 
  def validate(self):
16513 
    return
16514 
 
16515 
 
16516 
  def __repr__(self):
16517 
    L = ['%s=%r' % (key, value)
16518 
      for key, value in self.__dict__.iteritems()]
16519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16520 
 
16521 
  def __eq__(self, other):
16522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16523 
 
16524 
  def __ne__(self, other):
16525 
    return not (self == other)
16526 
 
16527 
class markOrderDoaRequestReceived_result:
16528 
  """
16529 
  Attributes:
16530 
   - success
16531 
   - ex
16532 
  """
16533 
 
16534 
  thrift_spec = (
16535 
    (0, TType.BOOL, 'success', None, None, ), # 0
16536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16537 
  )
16538 
 
16539 
  def __init__(self, success=None, ex=None,):
16540 
    self.success = success
16541 
    self.ex = ex
16542 
 
16543 
  def read(self, iprot):
16544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16546 
      return
16547 
    iprot.readStructBegin()
16548 
    while True:
16549 
      (fname, ftype, fid) = iprot.readFieldBegin()
16550 
      if ftype == TType.STOP:
16551 
        break
16552 
      if fid == 0:
16553 
        if ftype == TType.BOOL:
16554 
          self.success = iprot.readBool();
16555 
        else:
16556 
          iprot.skip(ftype)
16557 
      elif fid == 1:
16558 
        if ftype == TType.STRUCT:
16559 
          self.ex = TransactionServiceException()
16560 
          self.ex.read(iprot)
16561 
        else:
16562 
          iprot.skip(ftype)
16563 
      else:
16564 
        iprot.skip(ftype)
16565 
      iprot.readFieldEnd()
16566 
    iprot.readStructEnd()
16567 
 
16568 
  def write(self, oprot):
16569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16571 
      return
16572 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16573 
    if self.success is not None:
16574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16575 
      oprot.writeBool(self.success)
16576 
      oprot.writeFieldEnd()
16577 
    if self.ex is not None:
16578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16579 
      self.ex.write(oprot)
16580 
      oprot.writeFieldEnd()
16581 
    oprot.writeFieldStop()
16582 
    oprot.writeStructEnd()
16583 
 
16584 
  def validate(self):
16585 
    return
16586 
 
16587 
 
16588 
  def __repr__(self):
16589 
    L = ['%s=%r' % (key, value)
16590 
      for key, value in self.__dict__.iteritems()]
16591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16592 
 
16593 
  def __eq__(self, other):
16594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16595 
 
16596 
  def __ne__(self, other):
16597 
    return not (self == other)
16598 
 
16599 
class markOrderDoaRequestAuthorized_args:
16600 
  """
16601 
  Attributes:
16602 
   - orderId
16603 
   - isAuthorized
16604 
  """
16605 
 
16606 
  thrift_spec = (
16607 
    None, # 0
16608 
    (1, TType.I64, 'orderId', None, None, ), # 1
16609 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16610 
  )
16611 
 
16612 
  def __init__(self, orderId=None, isAuthorized=None,):
16613 
    self.orderId = orderId
16614 
    self.isAuthorized = isAuthorized
16615 
 
16616 
  def read(self, iprot):
16617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16619 
      return
16620 
    iprot.readStructBegin()
16621 
    while True:
16622 
      (fname, ftype, fid) = iprot.readFieldBegin()
16623 
      if ftype == TType.STOP:
16624 
        break
16625 
      if fid == 1:
16626 
        if ftype == TType.I64:
16627 
          self.orderId = iprot.readI64();
16628 
        else:
16629 
          iprot.skip(ftype)
16630 
      elif fid == 2:
16631 
        if ftype == TType.BOOL:
16632 
          self.isAuthorized = iprot.readBool();
16633 
        else:
16634 
          iprot.skip(ftype)
16635 
      else:
16636 
        iprot.skip(ftype)
16637 
      iprot.readFieldEnd()
16638 
    iprot.readStructEnd()
16639 
 
16640 
  def write(self, oprot):
16641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16643 
      return
16644 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16645 
    if self.orderId is not None:
16646 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16647 
      oprot.writeI64(self.orderId)
16648 
      oprot.writeFieldEnd()
16649 
    if self.isAuthorized is not None:
16650 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16651 
      oprot.writeBool(self.isAuthorized)
16652 
      oprot.writeFieldEnd()
16653 
    oprot.writeFieldStop()
16654 
    oprot.writeStructEnd()
16655 
 
16656 
  def validate(self):
16657 
    return
16658 
 
16659 
 
16660 
  def __repr__(self):
16661 
    L = ['%s=%r' % (key, value)
16662 
      for key, value in self.__dict__.iteritems()]
16663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16664 
 
16665 
  def __eq__(self, other):
16666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16667 
 
16668 
  def __ne__(self, other):
16669 
    return not (self == other)
16670 
 
16671 
class markOrderDoaRequestAuthorized_result:
16672 
  """
16673 
  Attributes:
16674 
   - success
16675 
   - ex
16676 
  """
16677 
 
16678 
  thrift_spec = (
16679 
    (0, TType.BOOL, 'success', None, None, ), # 0
16680 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16681 
  )
16682 
 
16683 
  def __init__(self, success=None, ex=None,):
16684 
    self.success = success
16685 
    self.ex = ex
16686 
 
16687 
  def read(self, iprot):
16688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16690 
      return
16691 
    iprot.readStructBegin()
16692 
    while True:
16693 
      (fname, ftype, fid) = iprot.readFieldBegin()
16694 
      if ftype == TType.STOP:
16695 
        break
16696 
      if fid == 0:
16697 
        if ftype == TType.BOOL:
16698 
          self.success = iprot.readBool();
16699 
        else:
16700 
          iprot.skip(ftype)
16701 
      elif fid == 1:
16702 
        if ftype == TType.STRUCT:
16703 
          self.ex = TransactionServiceException()
16704 
          self.ex.read(iprot)
16705 
        else:
16706 
          iprot.skip(ftype)
16707 
      else:
16708 
        iprot.skip(ftype)
16709 
      iprot.readFieldEnd()
16710 
    iprot.readStructEnd()
16711 
 
16712 
  def write(self, oprot):
16713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16715 
      return
16716 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16717 
    if self.success is not None:
16718 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16719 
      oprot.writeBool(self.success)
16720 
      oprot.writeFieldEnd()
16721 
    if self.ex is not None:
16722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16723 
      self.ex.write(oprot)
16724 
      oprot.writeFieldEnd()
16725 
    oprot.writeFieldStop()
16726 
    oprot.writeStructEnd()
16727 
 
16728 
  def validate(self):
16729 
    return
16730 
 
16731 
 
16732 
  def __repr__(self):
16733 
    L = ['%s=%r' % (key, value)
16734 
      for key, value in self.__dict__.iteritems()]
16735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16736 
 
16737 
  def __eq__(self, other):
16738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16739 
 
16740 
  def __ne__(self, other):
16741 
    return not (self == other)
16742 
 
4488 rajveer 16743 
class markOrderReturnRequestReceived_args:
16744 
  """
16745 
  Attributes:
16746 
   - orderId
16747 
  """
16748 
 
16749 
  thrift_spec = (
16750 
    None, # 0
16751 
    (1, TType.I64, 'orderId', None, None, ), # 1
16752 
  )
16753 
 
16754 
  def __init__(self, orderId=None,):
16755 
    self.orderId = orderId
16756 
 
16757 
  def read(self, iprot):
16758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16760 
      return
16761 
    iprot.readStructBegin()
16762 
    while True:
16763 
      (fname, ftype, fid) = iprot.readFieldBegin()
16764 
      if ftype == TType.STOP:
16765 
        break
16766 
      if fid == 1:
16767 
        if ftype == TType.I64:
16768 
          self.orderId = iprot.readI64();
16769 
        else:
16770 
          iprot.skip(ftype)
16771 
      else:
16772 
        iprot.skip(ftype)
16773 
      iprot.readFieldEnd()
16774 
    iprot.readStructEnd()
16775 
 
16776 
  def write(self, oprot):
16777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16779 
      return
16780 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16781 
    if self.orderId is not None:
16782 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16783 
      oprot.writeI64(self.orderId)
16784 
      oprot.writeFieldEnd()
16785 
    oprot.writeFieldStop()
16786 
    oprot.writeStructEnd()
16787 
 
16788 
  def validate(self):
16789 
    return
16790 
 
16791 
 
16792 
  def __repr__(self):
16793 
    L = ['%s=%r' % (key, value)
16794 
      for key, value in self.__dict__.iteritems()]
16795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16796 
 
16797 
  def __eq__(self, other):
16798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16799 
 
16800 
  def __ne__(self, other):
16801 
    return not (self == other)
16802 
 
16803 
class markOrderReturnRequestReceived_result:
16804 
  """
16805 
  Attributes:
16806 
   - success
16807 
   - ex
16808 
  """
16809 
 
16810 
  thrift_spec = (
16811 
    (0, TType.BOOL, 'success', None, None, ), # 0
16812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16813 
  )
16814 
 
16815 
  def __init__(self, success=None, ex=None,):
16816 
    self.success = success
16817 
    self.ex = ex
16818 
 
16819 
  def read(self, iprot):
16820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16822 
      return
16823 
    iprot.readStructBegin()
16824 
    while True:
16825 
      (fname, ftype, fid) = iprot.readFieldBegin()
16826 
      if ftype == TType.STOP:
16827 
        break
16828 
      if fid == 0:
16829 
        if ftype == TType.BOOL:
16830 
          self.success = iprot.readBool();
16831 
        else:
16832 
          iprot.skip(ftype)
16833 
      elif fid == 1:
16834 
        if ftype == TType.STRUCT:
16835 
          self.ex = TransactionServiceException()
16836 
          self.ex.read(iprot)
16837 
        else:
16838 
          iprot.skip(ftype)
16839 
      else:
16840 
        iprot.skip(ftype)
16841 
      iprot.readFieldEnd()
16842 
    iprot.readStructEnd()
16843 
 
16844 
  def write(self, oprot):
16845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16847 
      return
16848 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16849 
    if self.success is not None:
16850 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16851 
      oprot.writeBool(self.success)
16852 
      oprot.writeFieldEnd()
16853 
    if self.ex is not None:
16854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16855 
      self.ex.write(oprot)
16856 
      oprot.writeFieldEnd()
16857 
    oprot.writeFieldStop()
16858 
    oprot.writeStructEnd()
16859 
 
16860 
  def validate(self):
16861 
    return
16862 
 
16863 
 
16864 
  def __repr__(self):
16865 
    L = ['%s=%r' % (key, value)
16866 
      for key, value in self.__dict__.iteritems()]
16867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16868 
 
16869 
  def __eq__(self, other):
16870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16871 
 
16872 
  def __ne__(self, other):
16873 
    return not (self == other)
16874 
 
16875 
class markOrderReturnRequestAuthorized_args:
16876 
  """
16877 
  Attributes:
16878 
   - orderId
16879 
   - isAuthorized
16880 
  """
16881 
 
16882 
  thrift_spec = (
16883 
    None, # 0
16884 
    (1, TType.I64, 'orderId', None, None, ), # 1
16885 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16886 
  )
16887 
 
16888 
  def __init__(self, orderId=None, isAuthorized=None,):
16889 
    self.orderId = orderId
16890 
    self.isAuthorized = isAuthorized
16891 
 
16892 
  def read(self, iprot):
16893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16895 
      return
16896 
    iprot.readStructBegin()
16897 
    while True:
16898 
      (fname, ftype, fid) = iprot.readFieldBegin()
16899 
      if ftype == TType.STOP:
16900 
        break
16901 
      if fid == 1:
16902 
        if ftype == TType.I64:
16903 
          self.orderId = iprot.readI64();
16904 
        else:
16905 
          iprot.skip(ftype)
16906 
      elif fid == 2:
16907 
        if ftype == TType.BOOL:
16908 
          self.isAuthorized = iprot.readBool();
16909 
        else:
16910 
          iprot.skip(ftype)
16911 
      else:
16912 
        iprot.skip(ftype)
16913 
      iprot.readFieldEnd()
16914 
    iprot.readStructEnd()
16915 
 
16916 
  def write(self, oprot):
16917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16919 
      return
16920 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16921 
    if self.orderId is not None:
16922 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16923 
      oprot.writeI64(self.orderId)
16924 
      oprot.writeFieldEnd()
16925 
    if self.isAuthorized is not None:
16926 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16927 
      oprot.writeBool(self.isAuthorized)
16928 
      oprot.writeFieldEnd()
16929 
    oprot.writeFieldStop()
16930 
    oprot.writeStructEnd()
16931 
 
16932 
  def validate(self):
16933 
    return
16934 
 
16935 
 
16936 
  def __repr__(self):
16937 
    L = ['%s=%r' % (key, value)
16938 
      for key, value in self.__dict__.iteritems()]
16939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16940 
 
16941 
  def __eq__(self, other):
16942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16943 
 
16944 
  def __ne__(self, other):
16945 
    return not (self == other)
16946 
 
16947 
class markOrderReturnRequestAuthorized_result:
16948 
  """
16949 
  Attributes:
16950 
   - success
16951 
   - ex
16952 
  """
16953 
 
16954 
  thrift_spec = (
16955 
    (0, TType.BOOL, 'success', None, None, ), # 0
16956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16957 
  )
16958 
 
16959 
  def __init__(self, success=None, ex=None,):
16960 
    self.success = success
16961 
    self.ex = ex
16962 
 
16963 
  def read(self, iprot):
16964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16966 
      return
16967 
    iprot.readStructBegin()
16968 
    while True:
16969 
      (fname, ftype, fid) = iprot.readFieldBegin()
16970 
      if ftype == TType.STOP:
16971 
        break
16972 
      if fid == 0:
16973 
        if ftype == TType.BOOL:
16974 
          self.success = iprot.readBool();
16975 
        else:
16976 
          iprot.skip(ftype)
16977 
      elif fid == 1:
16978 
        if ftype == TType.STRUCT:
16979 
          self.ex = TransactionServiceException()
16980 
          self.ex.read(iprot)
16981 
        else:
16982 
          iprot.skip(ftype)
16983 
      else:
16984 
        iprot.skip(ftype)
16985 
      iprot.readFieldEnd()
16986 
    iprot.readStructEnd()
16987 
 
16988 
  def write(self, oprot):
16989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16991 
      return
16992 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16993 
    if self.success is not None:
16994 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16995 
      oprot.writeBool(self.success)
16996 
      oprot.writeFieldEnd()
16997 
    if self.ex is not None:
16998 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16999 
      self.ex.write(oprot)
17000 
      oprot.writeFieldEnd()
17001 
    oprot.writeFieldStop()
17002 
    oprot.writeStructEnd()
17003 
 
17004 
  def validate(self):
17005 
    return
17006 
 
17007 
 
17008 
  def __repr__(self):
17009 
    L = ['%s=%r' % (key, value)
17010 
      for key, value in self.__dict__.iteritems()]
17011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17012 
 
17013 
  def __eq__(self, other):
17014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17015 
 
17016 
  def __ne__(self, other):
17017 
    return not (self == other)
17018 
 
2536 chandransh 17019 
class requestPickupNumber_args:
17020 
  """
17021 
  Attributes:
17022 
   - orderId
4579 rajveer 17023 
   - providerId
2536 chandransh 17024 
  """
17025 
 
17026 
  thrift_spec = (
17027 
    None, # 0
17028 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17029 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17030 
  )
17031 
 
4579 rajveer 17032 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17033 
    self.orderId = orderId
4579 rajveer 17034 
    self.providerId = providerId
2536 chandransh 17035 
 
17036 
  def read(self, iprot):
17037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17039 
      return
17040 
    iprot.readStructBegin()
17041 
    while True:
17042 
      (fname, ftype, fid) = iprot.readFieldBegin()
17043 
      if ftype == TType.STOP:
17044 
        break
17045 
      if fid == 1:
17046 
        if ftype == TType.I64:
17047 
          self.orderId = iprot.readI64();
17048 
        else:
17049 
          iprot.skip(ftype)
4579 rajveer 17050 
      elif fid == 2:
17051 
        if ftype == TType.I64:
17052 
          self.providerId = iprot.readI64();
17053 
        else:
17054 
          iprot.skip(ftype)
2536 chandransh 17055 
      else:
17056 
        iprot.skip(ftype)
17057 
      iprot.readFieldEnd()
17058 
    iprot.readStructEnd()
17059 
 
17060 
  def write(self, oprot):
17061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17063 
      return
17064 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17065 
    if self.orderId is not None:
2536 chandransh 17066 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17067 
      oprot.writeI64(self.orderId)
17068 
      oprot.writeFieldEnd()
4579 rajveer 17069 
    if self.providerId is not None:
17070 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17071 
      oprot.writeI64(self.providerId)
17072 
      oprot.writeFieldEnd()
2536 chandransh 17073 
    oprot.writeFieldStop()
17074 
    oprot.writeStructEnd()
17075 
 
3431 rajveer 17076 
  def validate(self):
17077 
    return
17078 
 
17079 
 
2536 chandransh 17080 
  def __repr__(self):
17081 
    L = ['%s=%r' % (key, value)
17082 
      for key, value in self.__dict__.iteritems()]
17083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17084 
 
17085 
  def __eq__(self, other):
17086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17087 
 
17088 
  def __ne__(self, other):
17089 
    return not (self == other)
17090 
 
17091 
class requestPickupNumber_result:
17092 
  """
17093 
  Attributes:
17094 
   - success
17095 
   - ex
17096 
  """
17097 
 
17098 
  thrift_spec = (
17099 
    (0, TType.BOOL, 'success', None, None, ), # 0
17100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17101 
  )
17102 
 
17103 
  def __init__(self, success=None, ex=None,):
17104 
    self.success = success
17105 
    self.ex = ex
17106 
 
17107 
  def read(self, iprot):
17108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17110 
      return
17111 
    iprot.readStructBegin()
17112 
    while True:
17113 
      (fname, ftype, fid) = iprot.readFieldBegin()
17114 
      if ftype == TType.STOP:
17115 
        break
17116 
      if fid == 0:
17117 
        if ftype == TType.BOOL:
17118 
          self.success = iprot.readBool();
17119 
        else:
17120 
          iprot.skip(ftype)
17121 
      elif fid == 1:
17122 
        if ftype == TType.STRUCT:
17123 
          self.ex = TransactionServiceException()
17124 
          self.ex.read(iprot)
17125 
        else:
17126 
          iprot.skip(ftype)
17127 
      else:
17128 
        iprot.skip(ftype)
17129 
      iprot.readFieldEnd()
17130 
    iprot.readStructEnd()
17131 
 
17132 
  def write(self, oprot):
17133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17135 
      return
17136 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17137 
    if self.success is not None:
2536 chandransh 17138 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17139 
      oprot.writeBool(self.success)
17140 
      oprot.writeFieldEnd()
3431 rajveer 17141 
    if self.ex is not None:
2536 chandransh 17142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17143 
      self.ex.write(oprot)
17144 
      oprot.writeFieldEnd()
17145 
    oprot.writeFieldStop()
17146 
    oprot.writeStructEnd()
17147 
 
3431 rajveer 17148 
  def validate(self):
17149 
    return
17150 
 
17151 
 
2536 chandransh 17152 
  def __repr__(self):
17153 
    L = ['%s=%r' % (key, value)
17154 
      for key, value in self.__dict__.iteritems()]
17155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17156 
 
17157 
  def __eq__(self, other):
17158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17159 
 
17160 
  def __ne__(self, other):
17161 
    return not (self == other)
17162 
 
17163 
class authorizePickup_args:
17164 
  """
17165 
  Attributes:
17166 
   - orderId
17167 
   - pickupNumber
4602 rajveer 17168 
   - providerId
2536 chandransh 17169 
  """
17170 
 
17171 
  thrift_spec = (
17172 
    None, # 0
17173 
    (1, TType.I64, 'orderId', None, None, ), # 1
17174 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17175 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17176 
  )
17177 
 
4602 rajveer 17178 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17179 
    self.orderId = orderId
17180 
    self.pickupNumber = pickupNumber
4602 rajveer 17181 
    self.providerId = providerId
2536 chandransh 17182 
 
17183 
  def read(self, iprot):
17184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17186 
      return
17187 
    iprot.readStructBegin()
17188 
    while True:
17189 
      (fname, ftype, fid) = iprot.readFieldBegin()
17190 
      if ftype == TType.STOP:
17191 
        break
17192 
      if fid == 1:
17193 
        if ftype == TType.I64:
17194 
          self.orderId = iprot.readI64();
17195 
        else:
17196 
          iprot.skip(ftype)
17197 
      elif fid == 2:
17198 
        if ftype == TType.STRING:
17199 
          self.pickupNumber = iprot.readString();
17200 
        else:
17201 
          iprot.skip(ftype)
4602 rajveer 17202 
      elif fid == 3:
17203 
        if ftype == TType.I64:
17204 
          self.providerId = iprot.readI64();
17205 
        else:
17206 
          iprot.skip(ftype)
2536 chandransh 17207 
      else:
17208 
        iprot.skip(ftype)
17209 
      iprot.readFieldEnd()
17210 
    iprot.readStructEnd()
17211 
 
17212 
  def write(self, oprot):
17213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17215 
      return
17216 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17217 
    if self.orderId is not None:
2536 chandransh 17218 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17219 
      oprot.writeI64(self.orderId)
17220 
      oprot.writeFieldEnd()
3431 rajveer 17221 
    if self.pickupNumber is not None:
2536 chandransh 17222 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17223 
      oprot.writeString(self.pickupNumber)
17224 
      oprot.writeFieldEnd()
4602 rajveer 17225 
    if self.providerId is not None:
17226 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17227 
      oprot.writeI64(self.providerId)
17228 
      oprot.writeFieldEnd()
2536 chandransh 17229 
    oprot.writeFieldStop()
17230 
    oprot.writeStructEnd()
17231 
 
3431 rajveer 17232 
  def validate(self):
17233 
    return
17234 
 
17235 
 
2536 chandransh 17236 
  def __repr__(self):
17237 
    L = ['%s=%r' % (key, value)
17238 
      for key, value in self.__dict__.iteritems()]
17239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17240 
 
17241 
  def __eq__(self, other):
17242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17243 
 
17244 
  def __ne__(self, other):
17245 
    return not (self == other)
17246 
 
17247 
class authorizePickup_result:
17248 
  """
17249 
  Attributes:
17250 
   - success
17251 
   - ex
17252 
  """
17253 
 
17254 
  thrift_spec = (
17255 
    (0, TType.BOOL, 'success', None, None, ), # 0
17256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17257 
  )
17258 
 
17259 
  def __init__(self, success=None, ex=None,):
17260 
    self.success = success
17261 
    self.ex = ex
17262 
 
17263 
  def read(self, iprot):
17264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17266 
      return
17267 
    iprot.readStructBegin()
17268 
    while True:
17269 
      (fname, ftype, fid) = iprot.readFieldBegin()
17270 
      if ftype == TType.STOP:
17271 
        break
17272 
      if fid == 0:
17273 
        if ftype == TType.BOOL:
17274 
          self.success = iprot.readBool();
17275 
        else:
17276 
          iprot.skip(ftype)
17277 
      elif fid == 1:
17278 
        if ftype == TType.STRUCT:
17279 
          self.ex = TransactionServiceException()
17280 
          self.ex.read(iprot)
17281 
        else:
17282 
          iprot.skip(ftype)
17283 
      else:
17284 
        iprot.skip(ftype)
17285 
      iprot.readFieldEnd()
17286 
    iprot.readStructEnd()
17287 
 
17288 
  def write(self, oprot):
17289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17291 
      return
17292 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17293 
    if self.success is not None:
2536 chandransh 17294 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17295 
      oprot.writeBool(self.success)
17296 
      oprot.writeFieldEnd()
3431 rajveer 17297 
    if self.ex is not None:
2536 chandransh 17298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17299 
      self.ex.write(oprot)
17300 
      oprot.writeFieldEnd()
17301 
    oprot.writeFieldStop()
17302 
    oprot.writeStructEnd()
17303 
 
3431 rajveer 17304 
  def validate(self):
17305 
    return
17306 
 
17307 
 
2536 chandransh 17308 
  def __repr__(self):
17309 
    L = ['%s=%r' % (key, value)
17310 
      for key, value in self.__dict__.iteritems()]
17311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17312 
 
17313 
  def __eq__(self, other):
17314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17315 
 
17316 
  def __ne__(self, other):
17317 
    return not (self == other)
17318 
 
2764 chandransh 17319 
class markDoasAsPickedUp_args:
17320 
  """
17321 
  Attributes:
17322 
   - providerId
17323 
   - pickupDetails
17324 
  """
17325 
 
17326 
  thrift_spec = (
17327 
    None, # 0
17328 
    (1, TType.I64, 'providerId', None, None, ), # 1
17329 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17330 
  )
17331 
 
17332 
  def __init__(self, providerId=None, pickupDetails=None,):
17333 
    self.providerId = providerId
17334 
    self.pickupDetails = pickupDetails
17335 
 
17336 
  def read(self, iprot):
17337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17339 
      return
17340 
    iprot.readStructBegin()
17341 
    while True:
17342 
      (fname, ftype, fid) = iprot.readFieldBegin()
17343 
      if ftype == TType.STOP:
17344 
        break
17345 
      if fid == 1:
17346 
        if ftype == TType.I64:
17347 
          self.providerId = iprot.readI64();
17348 
        else:
17349 
          iprot.skip(ftype)
17350 
      elif fid == 2:
17351 
        if ftype == TType.MAP:
17352 
          self.pickupDetails = {}
6188 rajveer 17353 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17354 
          for _i411 in xrange(_size407):
17355 
            _key412 = iprot.readString();
17356 
            _val413 = iprot.readString();
17357 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17358 
          iprot.readMapEnd()
17359 
        else:
17360 
          iprot.skip(ftype)
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_args')
3431 rajveer 17371 
    if self.providerId is not None:
2764 chandransh 17372 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17373 
      oprot.writeI64(self.providerId)
17374 
      oprot.writeFieldEnd()
3431 rajveer 17375 
    if self.pickupDetails is not None:
2764 chandransh 17376 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17377 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17378 
      for kiter414,viter415 in self.pickupDetails.items():
17379 
        oprot.writeString(kiter414)
17380 
        oprot.writeString(viter415)
2764 chandransh 17381 
      oprot.writeMapEnd()
17382 
      oprot.writeFieldEnd()
17383 
    oprot.writeFieldStop()
17384 
    oprot.writeStructEnd()
17385 
 
3431 rajveer 17386 
  def validate(self):
17387 
    return
17388 
 
17389 
 
2764 chandransh 17390 
  def __repr__(self):
17391 
    L = ['%s=%r' % (key, value)
17392 
      for key, value in self.__dict__.iteritems()]
17393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17394 
 
17395 
  def __eq__(self, other):
17396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17397 
 
17398 
  def __ne__(self, other):
17399 
    return not (self == other)
17400 
 
17401 
class markDoasAsPickedUp_result:
4910 phani.kuma 17402 
 
17403 
  thrift_spec = (
17404 
  )
17405 
 
17406 
  def read(self, iprot):
17407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17409 
      return
17410 
    iprot.readStructBegin()
17411 
    while True:
17412 
      (fname, ftype, fid) = iprot.readFieldBegin()
17413 
      if ftype == TType.STOP:
17414 
        break
17415 
      else:
17416 
        iprot.skip(ftype)
17417 
      iprot.readFieldEnd()
17418 
    iprot.readStructEnd()
17419 
 
17420 
  def write(self, oprot):
17421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17423 
      return
17424 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17425 
    oprot.writeFieldStop()
17426 
    oprot.writeStructEnd()
17427 
 
17428 
  def validate(self):
17429 
    return
17430 
 
17431 
 
17432 
  def __repr__(self):
17433 
    L = ['%s=%r' % (key, value)
17434 
      for key, value in self.__dict__.iteritems()]
17435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17436 
 
17437 
  def __eq__(self, other):
17438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17439 
 
17440 
  def __ne__(self, other):
17441 
    return not (self == other)
17442 
 
17443 
class getDoasNotPickedUp_args:
2764 chandransh 17444 
  """
17445 
  Attributes:
4910 phani.kuma 17446 
   - providerId
17447 
  """
17448 
 
17449 
  thrift_spec = (
17450 
    None, # 0
17451 
    (1, TType.I64, 'providerId', None, None, ), # 1
17452 
  )
17453 
 
17454 
  def __init__(self, providerId=None,):
17455 
    self.providerId = providerId
17456 
 
17457 
  def read(self, iprot):
17458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17460 
      return
17461 
    iprot.readStructBegin()
17462 
    while True:
17463 
      (fname, ftype, fid) = iprot.readFieldBegin()
17464 
      if ftype == TType.STOP:
17465 
        break
17466 
      if fid == 1:
17467 
        if ftype == TType.I64:
17468 
          self.providerId = iprot.readI64();
17469 
        else:
17470 
          iprot.skip(ftype)
17471 
      else:
17472 
        iprot.skip(ftype)
17473 
      iprot.readFieldEnd()
17474 
    iprot.readStructEnd()
17475 
 
17476 
  def write(self, oprot):
17477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17479 
      return
17480 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17481 
    if self.providerId is not None:
17482 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17483 
      oprot.writeI64(self.providerId)
17484 
      oprot.writeFieldEnd()
17485 
    oprot.writeFieldStop()
17486 
    oprot.writeStructEnd()
17487 
 
17488 
  def validate(self):
17489 
    return
17490 
 
17491 
 
17492 
  def __repr__(self):
17493 
    L = ['%s=%r' % (key, value)
17494 
      for key, value in self.__dict__.iteritems()]
17495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17496 
 
17497 
  def __eq__(self, other):
17498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17499 
 
17500 
  def __ne__(self, other):
17501 
    return not (self == other)
17502 
 
17503 
class getDoasNotPickedUp_result:
17504 
  """
17505 
  Attributes:
2764 chandransh 17506 
   - success
17507 
  """
17508 
 
17509 
  thrift_spec = (
17510 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17511 
  )
17512 
 
17513 
  def __init__(self, success=None,):
17514 
    self.success = success
17515 
 
17516 
  def read(self, iprot):
17517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17519 
      return
17520 
    iprot.readStructBegin()
17521 
    while True:
17522 
      (fname, ftype, fid) = iprot.readFieldBegin()
17523 
      if ftype == TType.STOP:
17524 
        break
17525 
      if fid == 0:
17526 
        if ftype == TType.LIST:
17527 
          self.success = []
6188 rajveer 17528 
          (_etype419, _size416) = iprot.readListBegin()
17529 
          for _i420 in xrange(_size416):
17530 
            _elem421 = Order()
17531 
            _elem421.read(iprot)
17532 
            self.success.append(_elem421)
2764 chandransh 17533 
          iprot.readListEnd()
17534 
        else:
17535 
          iprot.skip(ftype)
17536 
      else:
17537 
        iprot.skip(ftype)
17538 
      iprot.readFieldEnd()
17539 
    iprot.readStructEnd()
17540 
 
17541 
  def write(self, oprot):
17542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17544 
      return
4910 phani.kuma 17545 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17546 
    if self.success is not None:
2764 chandransh 17547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17549 
      for iter422 in self.success:
17550 
        iter422.write(oprot)
2764 chandransh 17551 
      oprot.writeListEnd()
17552 
      oprot.writeFieldEnd()
17553 
    oprot.writeFieldStop()
17554 
    oprot.writeStructEnd()
17555 
 
3431 rajveer 17556 
  def validate(self):
17557 
    return
17558 
 
17559 
 
2764 chandransh 17560 
  def __repr__(self):
17561 
    L = ['%s=%r' % (key, value)
17562 
      for key, value in self.__dict__.iteritems()]
17563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17564 
 
17565 
  def __eq__(self, other):
17566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17567 
 
17568 
  def __ne__(self, other):
17569 
    return not (self == other)
17570 
 
4741 phani.kuma 17571 
class markReturnOrdersAsPickedUp_args:
17572 
  """
17573 
  Attributes:
17574 
   - providerId
17575 
   - pickupDetails
17576 
  """
17577 
 
17578 
  thrift_spec = (
17579 
    None, # 0
17580 
    (1, TType.I64, 'providerId', None, None, ), # 1
17581 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17582 
  )
17583 
 
17584 
  def __init__(self, providerId=None, pickupDetails=None,):
17585 
    self.providerId = providerId
17586 
    self.pickupDetails = pickupDetails
17587 
 
17588 
  def read(self, iprot):
17589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17591 
      return
17592 
    iprot.readStructBegin()
17593 
    while True:
17594 
      (fname, ftype, fid) = iprot.readFieldBegin()
17595 
      if ftype == TType.STOP:
17596 
        break
17597 
      if fid == 1:
17598 
        if ftype == TType.I64:
17599 
          self.providerId = iprot.readI64();
17600 
        else:
17601 
          iprot.skip(ftype)
17602 
      elif fid == 2:
17603 
        if ftype == TType.MAP:
17604 
          self.pickupDetails = {}
6188 rajveer 17605 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17606 
          for _i427 in xrange(_size423):
17607 
            _key428 = iprot.readString();
17608 
            _val429 = iprot.readString();
17609 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17610 
          iprot.readMapEnd()
17611 
        else:
17612 
          iprot.skip(ftype)
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_args')
17623 
    if self.providerId is not None:
17624 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17625 
      oprot.writeI64(self.providerId)
17626 
      oprot.writeFieldEnd()
17627 
    if self.pickupDetails is not None:
17628 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17629 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17630 
      for kiter430,viter431 in self.pickupDetails.items():
17631 
        oprot.writeString(kiter430)
17632 
        oprot.writeString(viter431)
4741 phani.kuma 17633 
      oprot.writeMapEnd()
17634 
      oprot.writeFieldEnd()
17635 
    oprot.writeFieldStop()
17636 
    oprot.writeStructEnd()
17637 
 
17638 
  def validate(self):
17639 
    return
17640 
 
17641 
 
17642 
  def __repr__(self):
17643 
    L = ['%s=%r' % (key, value)
17644 
      for key, value in self.__dict__.iteritems()]
17645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17646 
 
17647 
  def __eq__(self, other):
17648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17649 
 
17650 
  def __ne__(self, other):
17651 
    return not (self == other)
17652 
 
17653 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17654 
 
17655 
  thrift_spec = (
17656 
  )
17657 
 
17658 
  def read(self, iprot):
17659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17661 
      return
17662 
    iprot.readStructBegin()
17663 
    while True:
17664 
      (fname, ftype, fid) = iprot.readFieldBegin()
17665 
      if ftype == TType.STOP:
17666 
        break
17667 
      else:
17668 
        iprot.skip(ftype)
17669 
      iprot.readFieldEnd()
17670 
    iprot.readStructEnd()
17671 
 
17672 
  def write(self, oprot):
17673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17675 
      return
17676 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17677 
    oprot.writeFieldStop()
17678 
    oprot.writeStructEnd()
17679 
 
17680 
  def validate(self):
17681 
    return
17682 
 
17683 
 
17684 
  def __repr__(self):
17685 
    L = ['%s=%r' % (key, value)
17686 
      for key, value in self.__dict__.iteritems()]
17687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17688 
 
17689 
  def __eq__(self, other):
17690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17691 
 
17692 
  def __ne__(self, other):
17693 
    return not (self == other)
17694 
 
17695 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17696 
  """
17697 
  Attributes:
4910 phani.kuma 17698 
   - providerId
17699 
  """
17700 
 
17701 
  thrift_spec = (
17702 
    None, # 0
17703 
    (1, TType.I64, 'providerId', None, None, ), # 1
17704 
  )
17705 
 
17706 
  def __init__(self, providerId=None,):
17707 
    self.providerId = providerId
17708 
 
17709 
  def read(self, iprot):
17710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17712 
      return
17713 
    iprot.readStructBegin()
17714 
    while True:
17715 
      (fname, ftype, fid) = iprot.readFieldBegin()
17716 
      if ftype == TType.STOP:
17717 
        break
17718 
      if fid == 1:
17719 
        if ftype == TType.I64:
17720 
          self.providerId = iprot.readI64();
17721 
        else:
17722 
          iprot.skip(ftype)
17723 
      else:
17724 
        iprot.skip(ftype)
17725 
      iprot.readFieldEnd()
17726 
    iprot.readStructEnd()
17727 
 
17728 
  def write(self, oprot):
17729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17731 
      return
17732 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17733 
    if self.providerId is not None:
17734 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17735 
      oprot.writeI64(self.providerId)
17736 
      oprot.writeFieldEnd()
17737 
    oprot.writeFieldStop()
17738 
    oprot.writeStructEnd()
17739 
 
17740 
  def validate(self):
17741 
    return
17742 
 
17743 
 
17744 
  def __repr__(self):
17745 
    L = ['%s=%r' % (key, value)
17746 
      for key, value in self.__dict__.iteritems()]
17747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17748 
 
17749 
  def __eq__(self, other):
17750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17751 
 
17752 
  def __ne__(self, other):
17753 
    return not (self == other)
17754 
 
17755 
class getReturnOrdersNotPickedUp_result:
17756 
  """
17757 
  Attributes:
4741 phani.kuma 17758 
   - success
17759 
  """
17760 
 
17761 
  thrift_spec = (
17762 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17763 
  )
17764 
 
17765 
  def __init__(self, success=None,):
17766 
    self.success = success
17767 
 
17768 
  def read(self, iprot):
17769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17771 
      return
17772 
    iprot.readStructBegin()
17773 
    while True:
17774 
      (fname, ftype, fid) = iprot.readFieldBegin()
17775 
      if ftype == TType.STOP:
17776 
        break
17777 
      if fid == 0:
17778 
        if ftype == TType.LIST:
17779 
          self.success = []
6188 rajveer 17780 
          (_etype435, _size432) = iprot.readListBegin()
17781 
          for _i436 in xrange(_size432):
17782 
            _elem437 = Order()
17783 
            _elem437.read(iprot)
17784 
            self.success.append(_elem437)
4741 phani.kuma 17785 
          iprot.readListEnd()
17786 
        else:
17787 
          iprot.skip(ftype)
17788 
      else:
17789 
        iprot.skip(ftype)
17790 
      iprot.readFieldEnd()
17791 
    iprot.readStructEnd()
17792 
 
17793 
  def write(self, oprot):
17794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17796 
      return
4910 phani.kuma 17797 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17798 
    if self.success is not None:
17799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17801 
      for iter438 in self.success:
17802 
        iter438.write(oprot)
4741 phani.kuma 17803 
      oprot.writeListEnd()
17804 
      oprot.writeFieldEnd()
17805 
    oprot.writeFieldStop()
17806 
    oprot.writeStructEnd()
17807 
 
17808 
  def validate(self):
17809 
    return
17810 
 
17811 
 
17812 
  def __repr__(self):
17813 
    L = ['%s=%r' % (key, value)
17814 
      for key, value in self.__dict__.iteritems()]
17815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17816 
 
17817 
  def __eq__(self, other):
17818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17819 
 
17820 
  def __ne__(self, other):
17821 
    return not (self == other)
17822 
 
2616 chandransh 17823 
class receiveReturn_args:
2591 chandransh 17824 
  """
17825 
  Attributes:
17826 
   - orderId
4479 rajveer 17827 
   - receiveCondition
2591 chandransh 17828 
  """
2536 chandransh 17829 
 
2591 chandransh 17830 
  thrift_spec = (
17831 
    None, # 0
17832 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17833 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17834 
  )
17835 
 
4479 rajveer 17836 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17837 
    self.orderId = orderId
4479 rajveer 17838 
    self.receiveCondition = receiveCondition
2591 chandransh 17839 
 
17840 
  def read(self, iprot):
17841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17843 
      return
17844 
    iprot.readStructBegin()
17845 
    while True:
17846 
      (fname, ftype, fid) = iprot.readFieldBegin()
17847 
      if ftype == TType.STOP:
17848 
        break
17849 
      if fid == 1:
17850 
        if ftype == TType.I64:
17851 
          self.orderId = iprot.readI64();
17852 
        else:
17853 
          iprot.skip(ftype)
4479 rajveer 17854 
      elif fid == 2:
17855 
        if ftype == TType.I64:
17856 
          self.receiveCondition = iprot.readI64();
17857 
        else:
17858 
          iprot.skip(ftype)
2591 chandransh 17859 
      else:
17860 
        iprot.skip(ftype)
17861 
      iprot.readFieldEnd()
17862 
    iprot.readStructEnd()
17863 
 
17864 
  def write(self, oprot):
17865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17867 
      return
2616 chandransh 17868 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17869 
    if self.orderId is not None:
2591 chandransh 17870 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17871 
      oprot.writeI64(self.orderId)
17872 
      oprot.writeFieldEnd()
4479 rajveer 17873 
    if self.receiveCondition is not None:
17874 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17875 
      oprot.writeI64(self.receiveCondition)
17876 
      oprot.writeFieldEnd()
2591 chandransh 17877 
    oprot.writeFieldStop()
17878 
    oprot.writeStructEnd()
17879 
 
3431 rajveer 17880 
  def validate(self):
17881 
    return
17882 
 
17883 
 
2591 chandransh 17884 
  def __repr__(self):
17885 
    L = ['%s=%r' % (key, value)
17886 
      for key, value in self.__dict__.iteritems()]
17887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17888 
 
17889 
  def __eq__(self, other):
17890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17891 
 
17892 
  def __ne__(self, other):
17893 
    return not (self == other)
17894 
 
2616 chandransh 17895 
class receiveReturn_result:
2591 chandransh 17896 
  """
17897 
  Attributes:
17898 
   - success
17899 
   - ex
17900 
  """
17901 
 
17902 
  thrift_spec = (
17903 
    (0, TType.BOOL, 'success', None, None, ), # 0
17904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17905 
  )
17906 
 
17907 
  def __init__(self, success=None, ex=None,):
17908 
    self.success = success
17909 
    self.ex = ex
17910 
 
17911 
  def read(self, iprot):
17912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17914 
      return
17915 
    iprot.readStructBegin()
17916 
    while True:
17917 
      (fname, ftype, fid) = iprot.readFieldBegin()
17918 
      if ftype == TType.STOP:
17919 
        break
17920 
      if fid == 0:
17921 
        if ftype == TType.BOOL:
17922 
          self.success = iprot.readBool();
17923 
        else:
17924 
          iprot.skip(ftype)
17925 
      elif fid == 1:
17926 
        if ftype == TType.STRUCT:
17927 
          self.ex = TransactionServiceException()
17928 
          self.ex.read(iprot)
17929 
        else:
17930 
          iprot.skip(ftype)
17931 
      else:
17932 
        iprot.skip(ftype)
17933 
      iprot.readFieldEnd()
17934 
    iprot.readStructEnd()
17935 
 
17936 
  def write(self, oprot):
17937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17939 
      return
2616 chandransh 17940 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17941 
    if self.success is not None:
2591 chandransh 17942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17943 
      oprot.writeBool(self.success)
17944 
      oprot.writeFieldEnd()
3431 rajveer 17945 
    if self.ex is not None:
2591 chandransh 17946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17947 
      self.ex.write(oprot)
17948 
      oprot.writeFieldEnd()
17949 
    oprot.writeFieldStop()
17950 
    oprot.writeStructEnd()
17951 
 
3431 rajveer 17952 
  def validate(self):
17953 
    return
17954 
 
17955 
 
2591 chandransh 17956 
  def __repr__(self):
17957 
    L = ['%s=%r' % (key, value)
17958 
      for key, value in self.__dict__.iteritems()]
17959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17960 
 
17961 
  def __eq__(self, other):
17962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17963 
 
17964 
  def __ne__(self, other):
17965 
    return not (self == other)
17966 
 
17967 
class validateDoa_args:
17968 
  """
17969 
  Attributes:
17970 
   - orderId
17971 
   - isValid
17972 
  """
17973 
 
17974 
  thrift_spec = (
17975 
    None, # 0
17976 
    (1, TType.I64, 'orderId', None, None, ), # 1
17977 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17978 
  )
17979 
 
17980 
  def __init__(self, orderId=None, isValid=None,):
17981 
    self.orderId = orderId
17982 
    self.isValid = isValid
17983 
 
17984 
  def read(self, iprot):
17985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17987 
      return
17988 
    iprot.readStructBegin()
17989 
    while True:
17990 
      (fname, ftype, fid) = iprot.readFieldBegin()
17991 
      if ftype == TType.STOP:
17992 
        break
17993 
      if fid == 1:
17994 
        if ftype == TType.I64:
17995 
          self.orderId = iprot.readI64();
17996 
        else:
17997 
          iprot.skip(ftype)
17998 
      elif fid == 2:
17999 
        if ftype == TType.BOOL:
18000 
          self.isValid = iprot.readBool();
18001 
        else:
18002 
          iprot.skip(ftype)
18003 
      else:
18004 
        iprot.skip(ftype)
18005 
      iprot.readFieldEnd()
18006 
    iprot.readStructEnd()
18007 
 
18008 
  def write(self, oprot):
18009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18011 
      return
18012 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18013 
    if self.orderId is not None:
2591 chandransh 18014 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18015 
      oprot.writeI64(self.orderId)
18016 
      oprot.writeFieldEnd()
3431 rajveer 18017 
    if self.isValid is not None:
2591 chandransh 18018 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18019 
      oprot.writeBool(self.isValid)
18020 
      oprot.writeFieldEnd()
18021 
    oprot.writeFieldStop()
18022 
    oprot.writeStructEnd()
18023 
 
3431 rajveer 18024 
  def validate(self):
18025 
    return
18026 
 
18027 
 
2591 chandransh 18028 
  def __repr__(self):
18029 
    L = ['%s=%r' % (key, value)
18030 
      for key, value in self.__dict__.iteritems()]
18031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18032 
 
18033 
  def __eq__(self, other):
18034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18035 
 
18036 
  def __ne__(self, other):
18037 
    return not (self == other)
18038 
 
18039 
class validateDoa_result:
18040 
  """
18041 
  Attributes:
18042 
   - success
18043 
   - ex
18044 
  """
18045 
 
18046 
  thrift_spec = (
18047 
    (0, TType.BOOL, 'success', None, None, ), # 0
18048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18049 
  )
18050 
 
18051 
  def __init__(self, success=None, ex=None,):
18052 
    self.success = success
18053 
    self.ex = ex
18054 
 
18055 
  def read(self, iprot):
18056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18058 
      return
18059 
    iprot.readStructBegin()
18060 
    while True:
18061 
      (fname, ftype, fid) = iprot.readFieldBegin()
18062 
      if ftype == TType.STOP:
18063 
        break
18064 
      if fid == 0:
18065 
        if ftype == TType.BOOL:
18066 
          self.success = iprot.readBool();
18067 
        else:
18068 
          iprot.skip(ftype)
18069 
      elif fid == 1:
18070 
        if ftype == TType.STRUCT:
18071 
          self.ex = TransactionServiceException()
18072 
          self.ex.read(iprot)
18073 
        else:
18074 
          iprot.skip(ftype)
18075 
      else:
18076 
        iprot.skip(ftype)
18077 
      iprot.readFieldEnd()
18078 
    iprot.readStructEnd()
18079 
 
18080 
  def write(self, oprot):
18081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18083 
      return
18084 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18085 
    if self.success is not None:
2591 chandransh 18086 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18087 
      oprot.writeBool(self.success)
18088 
      oprot.writeFieldEnd()
3431 rajveer 18089 
    if self.ex is not None:
2591 chandransh 18090 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18091 
      self.ex.write(oprot)
18092 
      oprot.writeFieldEnd()
18093 
    oprot.writeFieldStop()
18094 
    oprot.writeStructEnd()
18095 
 
3431 rajveer 18096 
  def validate(self):
18097 
    return
18098 
 
18099 
 
2591 chandransh 18100 
  def __repr__(self):
18101 
    L = ['%s=%r' % (key, value)
18102 
      for key, value in self.__dict__.iteritems()]
18103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18104 
 
18105 
  def __eq__(self, other):
18106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18107 
 
18108 
  def __ne__(self, other):
18109 
    return not (self == other)
18110 
 
4495 rajveer 18111 
class validateReturnProduct_args:
18112 
  """
18113 
  Attributes:
18114 
   - orderId
18115 
   - isUsable
18116 
  """
18117 
 
18118 
  thrift_spec = (
18119 
    None, # 0
18120 
    (1, TType.I64, 'orderId', None, None, ), # 1
18121 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18122 
  )
18123 
 
18124 
  def __init__(self, orderId=None, isUsable=None,):
18125 
    self.orderId = orderId
18126 
    self.isUsable = isUsable
18127 
 
18128 
  def read(self, iprot):
18129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18131 
      return
18132 
    iprot.readStructBegin()
18133 
    while True:
18134 
      (fname, ftype, fid) = iprot.readFieldBegin()
18135 
      if ftype == TType.STOP:
18136 
        break
18137 
      if fid == 1:
18138 
        if ftype == TType.I64:
18139 
          self.orderId = iprot.readI64();
18140 
        else:
18141 
          iprot.skip(ftype)
18142 
      elif fid == 2:
18143 
        if ftype == TType.BOOL:
18144 
          self.isUsable = iprot.readBool();
18145 
        else:
18146 
          iprot.skip(ftype)
18147 
      else:
18148 
        iprot.skip(ftype)
18149 
      iprot.readFieldEnd()
18150 
    iprot.readStructEnd()
18151 
 
18152 
  def write(self, oprot):
18153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18155 
      return
18156 
    oprot.writeStructBegin('validateReturnProduct_args')
18157 
    if self.orderId is not None:
18158 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18159 
      oprot.writeI64(self.orderId)
18160 
      oprot.writeFieldEnd()
18161 
    if self.isUsable is not None:
18162 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18163 
      oprot.writeBool(self.isUsable)
18164 
      oprot.writeFieldEnd()
18165 
    oprot.writeFieldStop()
18166 
    oprot.writeStructEnd()
18167 
 
18168 
  def validate(self):
18169 
    return
18170 
 
18171 
 
18172 
  def __repr__(self):
18173 
    L = ['%s=%r' % (key, value)
18174 
      for key, value in self.__dict__.iteritems()]
18175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18176 
 
18177 
  def __eq__(self, other):
18178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18179 
 
18180 
  def __ne__(self, other):
18181 
    return not (self == other)
18182 
 
18183 
class validateReturnProduct_result:
18184 
  """
18185 
  Attributes:
18186 
   - success
18187 
   - ex
18188 
  """
18189 
 
18190 
  thrift_spec = (
18191 
    (0, TType.BOOL, 'success', None, None, ), # 0
18192 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18193 
  )
18194 
 
18195 
  def __init__(self, success=None, ex=None,):
18196 
    self.success = success
18197 
    self.ex = ex
18198 
 
18199 
  def read(self, iprot):
18200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18202 
      return
18203 
    iprot.readStructBegin()
18204 
    while True:
18205 
      (fname, ftype, fid) = iprot.readFieldBegin()
18206 
      if ftype == TType.STOP:
18207 
        break
18208 
      if fid == 0:
18209 
        if ftype == TType.BOOL:
18210 
          self.success = iprot.readBool();
18211 
        else:
18212 
          iprot.skip(ftype)
18213 
      elif fid == 1:
18214 
        if ftype == TType.STRUCT:
18215 
          self.ex = TransactionServiceException()
18216 
          self.ex.read(iprot)
18217 
        else:
18218 
          iprot.skip(ftype)
18219 
      else:
18220 
        iprot.skip(ftype)
18221 
      iprot.readFieldEnd()
18222 
    iprot.readStructEnd()
18223 
 
18224 
  def write(self, oprot):
18225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18227 
      return
18228 
    oprot.writeStructBegin('validateReturnProduct_result')
18229 
    if self.success is not None:
18230 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18231 
      oprot.writeBool(self.success)
18232 
      oprot.writeFieldEnd()
18233 
    if self.ex is not None:
18234 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18235 
      self.ex.write(oprot)
18236 
      oprot.writeFieldEnd()
18237 
    oprot.writeFieldStop()
18238 
    oprot.writeStructEnd()
18239 
 
18240 
  def validate(self):
18241 
    return
18242 
 
18243 
 
18244 
  def __repr__(self):
18245 
    L = ['%s=%r' % (key, value)
18246 
      for key, value in self.__dict__.iteritems()]
18247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18248 
 
18249 
  def __eq__(self, other):
18250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18251 
 
18252 
  def __ne__(self, other):
18253 
    return not (self == other)
18254 
 
2616 chandransh 18255 
class reshipOrder_args:
18256 
  """
18257 
  Attributes:
18258 
   - orderId
18259 
  """
2591 chandransh 18260 
 
2616 chandransh 18261 
  thrift_spec = (
18262 
    None, # 0
18263 
    (1, TType.I64, 'orderId', None, None, ), # 1
18264 
  )
18265 
 
18266 
  def __init__(self, orderId=None,):
18267 
    self.orderId = orderId
18268 
 
18269 
  def read(self, iprot):
18270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18272 
      return
18273 
    iprot.readStructBegin()
18274 
    while True:
18275 
      (fname, ftype, fid) = iprot.readFieldBegin()
18276 
      if ftype == TType.STOP:
18277 
        break
18278 
      if fid == 1:
18279 
        if ftype == TType.I64:
18280 
          self.orderId = iprot.readI64();
18281 
        else:
18282 
          iprot.skip(ftype)
18283 
      else:
18284 
        iprot.skip(ftype)
18285 
      iprot.readFieldEnd()
18286 
    iprot.readStructEnd()
18287 
 
18288 
  def write(self, oprot):
18289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18291 
      return
18292 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18293 
    if self.orderId is not None:
2616 chandransh 18294 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18295 
      oprot.writeI64(self.orderId)
18296 
      oprot.writeFieldEnd()
18297 
    oprot.writeFieldStop()
18298 
    oprot.writeStructEnd()
18299 
 
3431 rajveer 18300 
  def validate(self):
18301 
    return
18302 
 
18303 
 
2616 chandransh 18304 
  def __repr__(self):
18305 
    L = ['%s=%r' % (key, value)
18306 
      for key, value in self.__dict__.iteritems()]
18307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18308 
 
18309 
  def __eq__(self, other):
18310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18311 
 
18312 
  def __ne__(self, other):
18313 
    return not (self == other)
18314 
 
18315 
class reshipOrder_result:
18316 
  """
18317 
  Attributes:
18318 
   - success
18319 
   - ex
18320 
  """
18321 
 
18322 
  thrift_spec = (
18323 
    (0, TType.I64, 'success', None, None, ), # 0
18324 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18325 
  )
18326 
 
18327 
  def __init__(self, success=None, ex=None,):
18328 
    self.success = success
18329 
    self.ex = ex
18330 
 
18331 
  def read(self, iprot):
18332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18334 
      return
18335 
    iprot.readStructBegin()
18336 
    while True:
18337 
      (fname, ftype, fid) = iprot.readFieldBegin()
18338 
      if ftype == TType.STOP:
18339 
        break
18340 
      if fid == 0:
18341 
        if ftype == TType.I64:
18342 
          self.success = iprot.readI64();
18343 
        else:
18344 
          iprot.skip(ftype)
18345 
      elif fid == 1:
18346 
        if ftype == TType.STRUCT:
18347 
          self.ex = TransactionServiceException()
18348 
          self.ex.read(iprot)
18349 
        else:
18350 
          iprot.skip(ftype)
18351 
      else:
18352 
        iprot.skip(ftype)
18353 
      iprot.readFieldEnd()
18354 
    iprot.readStructEnd()
18355 
 
18356 
  def write(self, oprot):
18357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18359 
      return
18360 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18361 
    if self.success is not None:
2616 chandransh 18362 
      oprot.writeFieldBegin('success', TType.I64, 0)
18363 
      oprot.writeI64(self.success)
18364 
      oprot.writeFieldEnd()
3431 rajveer 18365 
    if self.ex is not None:
2616 chandransh 18366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18367 
      self.ex.write(oprot)
18368 
      oprot.writeFieldEnd()
18369 
    oprot.writeFieldStop()
18370 
    oprot.writeStructEnd()
18371 
 
3431 rajveer 18372 
  def validate(self):
18373 
    return
18374 
 
18375 
 
2616 chandransh 18376 
  def __repr__(self):
18377 
    L = ['%s=%r' % (key, value)
18378 
      for key, value in self.__dict__.iteritems()]
18379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18380 
 
18381 
  def __eq__(self, other):
18382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18383 
 
18384 
  def __ne__(self, other):
18385 
    return not (self == other)
18386 
 
18387 
class refundOrder_args:
18388 
  """
18389 
  Attributes:
18390 
   - orderId
3226 chandransh 18391 
   - refundedBy
18392 
   - reason
2616 chandransh 18393 
  """
18394 
 
18395 
  thrift_spec = (
18396 
    None, # 0
18397 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18398 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18399 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18400 
  )
18401 
 
3226 chandransh 18402 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18403 
    self.orderId = orderId
3226 chandransh 18404 
    self.refundedBy = refundedBy
18405 
    self.reason = reason
2616 chandransh 18406 
 
18407 
  def read(self, iprot):
18408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18410 
      return
18411 
    iprot.readStructBegin()
18412 
    while True:
18413 
      (fname, ftype, fid) = iprot.readFieldBegin()
18414 
      if ftype == TType.STOP:
18415 
        break
18416 
      if fid == 1:
18417 
        if ftype == TType.I64:
18418 
          self.orderId = iprot.readI64();
18419 
        else:
18420 
          iprot.skip(ftype)
3226 chandransh 18421 
      elif fid == 2:
18422 
        if ftype == TType.STRING:
18423 
          self.refundedBy = iprot.readString();
18424 
        else:
18425 
          iprot.skip(ftype)
18426 
      elif fid == 3:
18427 
        if ftype == TType.STRING:
18428 
          self.reason = iprot.readString();
18429 
        else:
18430 
          iprot.skip(ftype)
2616 chandransh 18431 
      else:
18432 
        iprot.skip(ftype)
18433 
      iprot.readFieldEnd()
18434 
    iprot.readStructEnd()
18435 
 
18436 
  def write(self, oprot):
18437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18439 
      return
18440 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18441 
    if self.orderId is not None:
2616 chandransh 18442 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18443 
      oprot.writeI64(self.orderId)
18444 
      oprot.writeFieldEnd()
3431 rajveer 18445 
    if self.refundedBy is not None:
3226 chandransh 18446 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18447 
      oprot.writeString(self.refundedBy)
18448 
      oprot.writeFieldEnd()
3431 rajveer 18449 
    if self.reason is not None:
3226 chandransh 18450 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18451 
      oprot.writeString(self.reason)
18452 
      oprot.writeFieldEnd()
2616 chandransh 18453 
    oprot.writeFieldStop()
18454 
    oprot.writeStructEnd()
18455 
 
3431 rajveer 18456 
  def validate(self):
18457 
    return
18458 
 
18459 
 
2616 chandransh 18460 
  def __repr__(self):
18461 
    L = ['%s=%r' % (key, value)
18462 
      for key, value in self.__dict__.iteritems()]
18463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18464 
 
18465 
  def __eq__(self, other):
18466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18467 
 
18468 
  def __ne__(self, other):
18469 
    return not (self == other)
18470 
 
18471 
class refundOrder_result:
18472 
  """
18473 
  Attributes:
18474 
   - success
18475 
   - ex
18476 
  """
18477 
 
18478 
  thrift_spec = (
18479 
    (0, TType.BOOL, 'success', None, None, ), # 0
18480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18481 
  )
18482 
 
18483 
  def __init__(self, success=None, ex=None,):
18484 
    self.success = success
18485 
    self.ex = ex
18486 
 
18487 
  def read(self, iprot):
18488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18490 
      return
18491 
    iprot.readStructBegin()
18492 
    while True:
18493 
      (fname, ftype, fid) = iprot.readFieldBegin()
18494 
      if ftype == TType.STOP:
18495 
        break
18496 
      if fid == 0:
18497 
        if ftype == TType.BOOL:
18498 
          self.success = iprot.readBool();
18499 
        else:
18500 
          iprot.skip(ftype)
18501 
      elif fid == 1:
18502 
        if ftype == TType.STRUCT:
18503 
          self.ex = TransactionServiceException()
18504 
          self.ex.read(iprot)
18505 
        else:
18506 
          iprot.skip(ftype)
18507 
      else:
18508 
        iprot.skip(ftype)
18509 
      iprot.readFieldEnd()
18510 
    iprot.readStructEnd()
18511 
 
18512 
  def write(self, oprot):
18513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18515 
      return
18516 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18517 
    if self.success is not None:
2616 chandransh 18518 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18519 
      oprot.writeBool(self.success)
18520 
      oprot.writeFieldEnd()
3431 rajveer 18521 
    if self.ex is not None:
2616 chandransh 18522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18523 
      self.ex.write(oprot)
18524 
      oprot.writeFieldEnd()
18525 
    oprot.writeFieldStop()
18526 
    oprot.writeStructEnd()
18527 
 
3431 rajveer 18528 
  def validate(self):
18529 
    return
18530 
 
18531 
 
2616 chandransh 18532 
  def __repr__(self):
18533 
    L = ['%s=%r' % (key, value)
18534 
      for key, value in self.__dict__.iteritems()]
18535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18536 
 
18537 
  def __eq__(self, other):
18538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18539 
 
18540 
  def __ne__(self, other):
18541 
    return not (self == other)
18542 
 
2690 chandransh 18543 
class getReturnOrders_args:
18544 
  """
18545 
  Attributes:
18546 
   - warehouseId
18547 
   - fromDate
18548 
   - toDate
18549 
  """
2616 chandransh 18550 
 
2690 chandransh 18551 
  thrift_spec = (
18552 
    None, # 0
18553 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18554 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18555 
    (3, TType.I64, 'toDate', None, None, ), # 3
18556 
  )
18557 
 
18558 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18559 
    self.warehouseId = warehouseId
18560 
    self.fromDate = fromDate
18561 
    self.toDate = toDate
18562 
 
18563 
  def read(self, iprot):
18564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18566 
      return
18567 
    iprot.readStructBegin()
18568 
    while True:
18569 
      (fname, ftype, fid) = iprot.readFieldBegin()
18570 
      if ftype == TType.STOP:
18571 
        break
18572 
      if fid == 1:
18573 
        if ftype == TType.I64:
18574 
          self.warehouseId = iprot.readI64();
18575 
        else:
18576 
          iprot.skip(ftype)
18577 
      elif fid == 2:
18578 
        if ftype == TType.I64:
18579 
          self.fromDate = iprot.readI64();
18580 
        else:
18581 
          iprot.skip(ftype)
18582 
      elif fid == 3:
18583 
        if ftype == TType.I64:
18584 
          self.toDate = iprot.readI64();
18585 
        else:
18586 
          iprot.skip(ftype)
18587 
      else:
18588 
        iprot.skip(ftype)
18589 
      iprot.readFieldEnd()
18590 
    iprot.readStructEnd()
18591 
 
18592 
  def write(self, oprot):
18593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18595 
      return
18596 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18597 
    if self.warehouseId is not None:
2690 chandransh 18598 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18599 
      oprot.writeI64(self.warehouseId)
18600 
      oprot.writeFieldEnd()
3431 rajveer 18601 
    if self.fromDate is not None:
2690 chandransh 18602 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18603 
      oprot.writeI64(self.fromDate)
18604 
      oprot.writeFieldEnd()
3431 rajveer 18605 
    if self.toDate is not None:
2690 chandransh 18606 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18607 
      oprot.writeI64(self.toDate)
18608 
      oprot.writeFieldEnd()
18609 
    oprot.writeFieldStop()
18610 
    oprot.writeStructEnd()
18611 
 
3431 rajveer 18612 
  def validate(self):
18613 
    return
18614 
 
18615 
 
2690 chandransh 18616 
  def __repr__(self):
18617 
    L = ['%s=%r' % (key, value)
18618 
      for key, value in self.__dict__.iteritems()]
18619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18620 
 
18621 
  def __eq__(self, other):
18622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18623 
 
18624 
  def __ne__(self, other):
18625 
    return not (self == other)
18626 
 
18627 
class getReturnOrders_result:
18628 
  """
18629 
  Attributes:
18630 
   - success
18631 
  """
18632 
 
18633 
  thrift_spec = (
18634 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18635 
  )
18636 
 
18637 
  def __init__(self, success=None,):
18638 
    self.success = success
18639 
 
18640 
  def read(self, iprot):
18641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18643 
      return
18644 
    iprot.readStructBegin()
18645 
    while True:
18646 
      (fname, ftype, fid) = iprot.readFieldBegin()
18647 
      if ftype == TType.STOP:
18648 
        break
18649 
      if fid == 0:
18650 
        if ftype == TType.LIST:
18651 
          self.success = []
6188 rajveer 18652 
          (_etype442, _size439) = iprot.readListBegin()
18653 
          for _i443 in xrange(_size439):
18654 
            _elem444 = ReturnOrder()
18655 
            _elem444.read(iprot)
18656 
            self.success.append(_elem444)
2690 chandransh 18657 
          iprot.readListEnd()
18658 
        else:
18659 
          iprot.skip(ftype)
18660 
      else:
18661 
        iprot.skip(ftype)
18662 
      iprot.readFieldEnd()
18663 
    iprot.readStructEnd()
18664 
 
18665 
  def write(self, oprot):
18666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18668 
      return
18669 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18670 
    if self.success is not None:
2690 chandransh 18671 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18672 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18673 
      for iter445 in self.success:
18674 
        iter445.write(oprot)
2690 chandransh 18675 
      oprot.writeListEnd()
18676 
      oprot.writeFieldEnd()
18677 
    oprot.writeFieldStop()
18678 
    oprot.writeStructEnd()
18679 
 
3431 rajveer 18680 
  def validate(self):
18681 
    return
18682 
 
18683 
 
2690 chandransh 18684 
  def __repr__(self):
18685 
    L = ['%s=%r' % (key, value)
18686 
      for key, value in self.__dict__.iteritems()]
18687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18688 
 
18689 
  def __eq__(self, other):
18690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18691 
 
18692 
  def __ne__(self, other):
18693 
    return not (self == other)
18694 
 
5481 phani.kuma 18695 
class getAllReturnOrders_args:
18696 
  """
18697 
  Attributes:
18698 
   - onlyNotProcessed
18699 
   - fromDate
18700 
   - toDate
18701 
  """
18702 
 
18703 
  thrift_spec = (
18704 
    None, # 0
18705 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18706 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18707 
    (3, TType.I64, 'toDate', None, None, ), # 3
18708 
  )
18709 
 
18710 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18711 
    self.onlyNotProcessed = onlyNotProcessed
18712 
    self.fromDate = fromDate
18713 
    self.toDate = toDate
18714 
 
18715 
  def read(self, iprot):
18716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18718 
      return
18719 
    iprot.readStructBegin()
18720 
    while True:
18721 
      (fname, ftype, fid) = iprot.readFieldBegin()
18722 
      if ftype == TType.STOP:
18723 
        break
18724 
      if fid == 1:
18725 
        if ftype == TType.BOOL:
18726 
          self.onlyNotProcessed = iprot.readBool();
18727 
        else:
18728 
          iprot.skip(ftype)
18729 
      elif fid == 2:
18730 
        if ftype == TType.I64:
18731 
          self.fromDate = iprot.readI64();
18732 
        else:
18733 
          iprot.skip(ftype)
18734 
      elif fid == 3:
18735 
        if ftype == TType.I64:
18736 
          self.toDate = iprot.readI64();
18737 
        else:
18738 
          iprot.skip(ftype)
18739 
      else:
18740 
        iprot.skip(ftype)
18741 
      iprot.readFieldEnd()
18742 
    iprot.readStructEnd()
18743 
 
18744 
  def write(self, oprot):
18745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18747 
      return
18748 
    oprot.writeStructBegin('getAllReturnOrders_args')
18749 
    if self.onlyNotProcessed is not None:
18750 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18751 
      oprot.writeBool(self.onlyNotProcessed)
18752 
      oprot.writeFieldEnd()
18753 
    if self.fromDate is not None:
18754 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18755 
      oprot.writeI64(self.fromDate)
18756 
      oprot.writeFieldEnd()
18757 
    if self.toDate is not None:
18758 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18759 
      oprot.writeI64(self.toDate)
18760 
      oprot.writeFieldEnd()
18761 
    oprot.writeFieldStop()
18762 
    oprot.writeStructEnd()
18763 
 
18764 
  def validate(self):
18765 
    return
18766 
 
18767 
 
18768 
  def __repr__(self):
18769 
    L = ['%s=%r' % (key, value)
18770 
      for key, value in self.__dict__.iteritems()]
18771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18772 
 
18773 
  def __eq__(self, other):
18774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18775 
 
18776 
  def __ne__(self, other):
18777 
    return not (self == other)
18778 
 
18779 
class getAllReturnOrders_result:
18780 
  """
18781 
  Attributes:
18782 
   - success
18783 
  """
18784 
 
18785 
  thrift_spec = (
18786 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18787 
  )
18788 
 
18789 
  def __init__(self, success=None,):
18790 
    self.success = success
18791 
 
18792 
  def read(self, iprot):
18793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18795 
      return
18796 
    iprot.readStructBegin()
18797 
    while True:
18798 
      (fname, ftype, fid) = iprot.readFieldBegin()
18799 
      if ftype == TType.STOP:
18800 
        break
18801 
      if fid == 0:
18802 
        if ftype == TType.LIST:
18803 
          self.success = []
6188 rajveer 18804 
          (_etype449, _size446) = iprot.readListBegin()
18805 
          for _i450 in xrange(_size446):
18806 
            _elem451 = ReturnOrder()
18807 
            _elem451.read(iprot)
18808 
            self.success.append(_elem451)
5481 phani.kuma 18809 
          iprot.readListEnd()
18810 
        else:
18811 
          iprot.skip(ftype)
18812 
      else:
18813 
        iprot.skip(ftype)
18814 
      iprot.readFieldEnd()
18815 
    iprot.readStructEnd()
18816 
 
18817 
  def write(self, oprot):
18818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18820 
      return
18821 
    oprot.writeStructBegin('getAllReturnOrders_result')
18822 
    if self.success is not None:
18823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18825 
      for iter452 in self.success:
18826 
        iter452.write(oprot)
5481 phani.kuma 18827 
      oprot.writeListEnd()
18828 
      oprot.writeFieldEnd()
18829 
    oprot.writeFieldStop()
18830 
    oprot.writeStructEnd()
18831 
 
18832 
  def validate(self):
18833 
    return
18834 
 
18835 
 
18836 
  def __repr__(self):
18837 
    L = ['%s=%r' % (key, value)
18838 
      for key, value in self.__dict__.iteritems()]
18839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18840 
 
18841 
  def __eq__(self, other):
18842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18843 
 
18844 
  def __ne__(self, other):
18845 
    return not (self == other)
18846 
 
2700 chandransh 18847 
class getReturnOrder_args:
18848 
  """
18849 
  Attributes:
18850 
   - id
18851 
  """
18852 
 
18853 
  thrift_spec = (
18854 
    None, # 0
18855 
    (1, TType.I64, 'id', None, None, ), # 1
18856 
  )
18857 
 
18858 
  def __init__(self, id=None,):
18859 
    self.id = id
18860 
 
18861 
  def read(self, iprot):
18862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18864 
      return
18865 
    iprot.readStructBegin()
18866 
    while True:
18867 
      (fname, ftype, fid) = iprot.readFieldBegin()
18868 
      if ftype == TType.STOP:
18869 
        break
18870 
      if fid == 1:
18871 
        if ftype == TType.I64:
18872 
          self.id = iprot.readI64();
18873 
        else:
18874 
          iprot.skip(ftype)
18875 
      else:
18876 
        iprot.skip(ftype)
18877 
      iprot.readFieldEnd()
18878 
    iprot.readStructEnd()
18879 
 
18880 
  def write(self, oprot):
18881 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18882 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18883 
      return
18884 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18885 
    if self.id is not None:
2700 chandransh 18886 
      oprot.writeFieldBegin('id', TType.I64, 1)
18887 
      oprot.writeI64(self.id)
18888 
      oprot.writeFieldEnd()
18889 
    oprot.writeFieldStop()
18890 
    oprot.writeStructEnd()
18891 
 
3431 rajveer 18892 
  def validate(self):
18893 
    return
18894 
 
18895 
 
2700 chandransh 18896 
  def __repr__(self):
18897 
    L = ['%s=%r' % (key, value)
18898 
      for key, value in self.__dict__.iteritems()]
18899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18900 
 
18901 
  def __eq__(self, other):
18902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18903 
 
18904 
  def __ne__(self, other):
18905 
    return not (self == other)
18906 
 
18907 
class getReturnOrder_result:
18908 
  """
18909 
  Attributes:
18910 
   - success
18911 
   - ex
18912 
  """
18913 
 
18914 
  thrift_spec = (
18915 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18917 
  )
18918 
 
18919 
  def __init__(self, success=None, ex=None,):
18920 
    self.success = success
18921 
    self.ex = ex
18922 
 
18923 
  def read(self, iprot):
18924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18926 
      return
18927 
    iprot.readStructBegin()
18928 
    while True:
18929 
      (fname, ftype, fid) = iprot.readFieldBegin()
18930 
      if ftype == TType.STOP:
18931 
        break
18932 
      if fid == 0:
18933 
        if ftype == TType.STRUCT:
18934 
          self.success = ReturnOrder()
18935 
          self.success.read(iprot)
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      elif fid == 1:
18939 
        if ftype == TType.STRUCT:
18940 
          self.ex = TransactionServiceException()
18941 
          self.ex.read(iprot)
18942 
        else:
18943 
          iprot.skip(ftype)
18944 
      else:
18945 
        iprot.skip(ftype)
18946 
      iprot.readFieldEnd()
18947 
    iprot.readStructEnd()
18948 
 
18949 
  def write(self, oprot):
18950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18952 
      return
18953 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18954 
    if self.success is not None:
2700 chandransh 18955 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18956 
      self.success.write(oprot)
18957 
      oprot.writeFieldEnd()
3431 rajveer 18958 
    if self.ex is not None:
2700 chandransh 18959 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18960 
      self.ex.write(oprot)
18961 
      oprot.writeFieldEnd()
18962 
    oprot.writeFieldStop()
18963 
    oprot.writeStructEnd()
18964 
 
3431 rajveer 18965 
  def validate(self):
18966 
    return
18967 
 
18968 
 
2700 chandransh 18969 
  def __repr__(self):
18970 
    L = ['%s=%r' % (key, value)
18971 
      for key, value in self.__dict__.iteritems()]
18972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18973 
 
18974 
  def __eq__(self, other):
18975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18976 
 
18977 
  def __ne__(self, other):
18978 
    return not (self == other)
18979 
 
2690 chandransh 18980 
class processReturn_args:
18981 
  """
18982 
  Attributes:
18983 
   - returnOrderId
18984 
  """
18985 
 
18986 
  thrift_spec = (
18987 
    None, # 0
18988 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18989 
  )
18990 
 
18991 
  def __init__(self, returnOrderId=None,):
18992 
    self.returnOrderId = returnOrderId
18993 
 
18994 
  def read(self, iprot):
18995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18997 
      return
18998 
    iprot.readStructBegin()
18999 
    while True:
19000 
      (fname, ftype, fid) = iprot.readFieldBegin()
19001 
      if ftype == TType.STOP:
19002 
        break
19003 
      if fid == 1:
19004 
        if ftype == TType.I64:
19005 
          self.returnOrderId = iprot.readI64();
19006 
        else:
19007 
          iprot.skip(ftype)
19008 
      else:
19009 
        iprot.skip(ftype)
19010 
      iprot.readFieldEnd()
19011 
    iprot.readStructEnd()
19012 
 
19013 
  def write(self, oprot):
19014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19016 
      return
19017 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19018 
    if self.returnOrderId is not None:
2690 chandransh 19019 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19020 
      oprot.writeI64(self.returnOrderId)
19021 
      oprot.writeFieldEnd()
19022 
    oprot.writeFieldStop()
19023 
    oprot.writeStructEnd()
19024 
 
3431 rajveer 19025 
  def validate(self):
19026 
    return
19027 
 
19028 
 
2690 chandransh 19029 
  def __repr__(self):
19030 
    L = ['%s=%r' % (key, value)
19031 
      for key, value in self.__dict__.iteritems()]
19032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19033 
 
19034 
  def __eq__(self, other):
19035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19036 
 
19037 
  def __ne__(self, other):
19038 
    return not (self == other)
19039 
 
19040 
class processReturn_result:
19041 
  """
19042 
  Attributes:
19043 
   - ex
19044 
  """
19045 
 
19046 
  thrift_spec = (
19047 
    None, # 0
19048 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19049 
  )
19050 
 
19051 
  def __init__(self, ex=None,):
19052 
    self.ex = ex
19053 
 
19054 
  def read(self, iprot):
19055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19057 
      return
19058 
    iprot.readStructBegin()
19059 
    while True:
19060 
      (fname, ftype, fid) = iprot.readFieldBegin()
19061 
      if ftype == TType.STOP:
19062 
        break
19063 
      if fid == 1:
19064 
        if ftype == TType.STRUCT:
19065 
          self.ex = TransactionServiceException()
19066 
          self.ex.read(iprot)
19067 
        else:
19068 
          iprot.skip(ftype)
19069 
      else:
19070 
        iprot.skip(ftype)
19071 
      iprot.readFieldEnd()
19072 
    iprot.readStructEnd()
19073 
 
19074 
  def write(self, oprot):
19075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19077 
      return
19078 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19079 
    if self.ex is not None:
2690 chandransh 19080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19081 
      self.ex.write(oprot)
19082 
      oprot.writeFieldEnd()
19083 
    oprot.writeFieldStop()
19084 
    oprot.writeStructEnd()
19085 
 
3431 rajveer 19086 
  def validate(self):
19087 
    return
19088 
 
19089 
 
2690 chandransh 19090 
  def __repr__(self):
19091 
    L = ['%s=%r' % (key, value)
19092 
      for key, value in self.__dict__.iteritems()]
19093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19094 
 
19095 
  def __eq__(self, other):
19096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19097 
 
19098 
  def __ne__(self, other):
19099 
    return not (self == other)
19100 
 
3451 chandransh 19101 
class updateWeight_args:
19102 
  """
19103 
  Attributes:
19104 
   - orderId
19105 
   - weight
19106 
  """
19107 
 
19108 
  thrift_spec = (
19109 
    None, # 0
19110 
    (1, TType.I64, 'orderId', None, None, ), # 1
19111 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19112 
  )
19113 
 
19114 
  def __init__(self, orderId=None, weight=None,):
19115 
    self.orderId = orderId
19116 
    self.weight = weight
19117 
 
19118 
  def read(self, iprot):
19119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19121 
      return
19122 
    iprot.readStructBegin()
19123 
    while True:
19124 
      (fname, ftype, fid) = iprot.readFieldBegin()
19125 
      if ftype == TType.STOP:
19126 
        break
19127 
      if fid == 1:
19128 
        if ftype == TType.I64:
19129 
          self.orderId = iprot.readI64();
19130 
        else:
19131 
          iprot.skip(ftype)
19132 
      elif fid == 2:
19133 
        if ftype == TType.DOUBLE:
19134 
          self.weight = iprot.readDouble();
19135 
        else:
19136 
          iprot.skip(ftype)
19137 
      else:
19138 
        iprot.skip(ftype)
19139 
      iprot.readFieldEnd()
19140 
    iprot.readStructEnd()
19141 
 
19142 
  def write(self, oprot):
19143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19145 
      return
19146 
    oprot.writeStructBegin('updateWeight_args')
19147 
    if self.orderId is not None:
19148 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19149 
      oprot.writeI64(self.orderId)
19150 
      oprot.writeFieldEnd()
19151 
    if self.weight is not None:
19152 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19153 
      oprot.writeDouble(self.weight)
19154 
      oprot.writeFieldEnd()
19155 
    oprot.writeFieldStop()
19156 
    oprot.writeStructEnd()
19157 
 
19158 
  def validate(self):
19159 
    return
19160 
 
19161 
 
19162 
  def __repr__(self):
19163 
    L = ['%s=%r' % (key, value)
19164 
      for key, value in self.__dict__.iteritems()]
19165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19166 
 
19167 
  def __eq__(self, other):
19168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19169 
 
19170 
  def __ne__(self, other):
19171 
    return not (self == other)
19172 
 
19173 
class updateWeight_result:
19174 
  """
19175 
  Attributes:
19176 
   - success
19177 
   - ex
19178 
  """
19179 
 
19180 
  thrift_spec = (
19181 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19182 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19183 
  )
19184 
 
19185 
  def __init__(self, success=None, ex=None,):
19186 
    self.success = success
19187 
    self.ex = ex
19188 
 
19189 
  def read(self, iprot):
19190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19192 
      return
19193 
    iprot.readStructBegin()
19194 
    while True:
19195 
      (fname, ftype, fid) = iprot.readFieldBegin()
19196 
      if ftype == TType.STOP:
19197 
        break
19198 
      if fid == 0:
19199 
        if ftype == TType.STRUCT:
19200 
          self.success = Order()
19201 
          self.success.read(iprot)
19202 
        else:
19203 
          iprot.skip(ftype)
19204 
      elif fid == 1:
19205 
        if ftype == TType.STRUCT:
19206 
          self.ex = TransactionServiceException()
19207 
          self.ex.read(iprot)
19208 
        else:
19209 
          iprot.skip(ftype)
19210 
      else:
19211 
        iprot.skip(ftype)
19212 
      iprot.readFieldEnd()
19213 
    iprot.readStructEnd()
19214 
 
19215 
  def write(self, oprot):
19216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19218 
      return
19219 
    oprot.writeStructBegin('updateWeight_result')
19220 
    if self.success is not None:
19221 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19222 
      self.success.write(oprot)
19223 
      oprot.writeFieldEnd()
19224 
    if self.ex is not None:
19225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19226 
      self.ex.write(oprot)
19227 
      oprot.writeFieldEnd()
19228 
    oprot.writeFieldStop()
19229 
    oprot.writeStructEnd()
19230 
 
19231 
  def validate(self):
19232 
    return
19233 
 
19234 
 
19235 
  def __repr__(self):
19236 
    L = ['%s=%r' % (key, value)
19237 
      for key, value in self.__dict__.iteritems()]
19238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19239 
 
19240 
  def __eq__(self, other):
19241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19242 
 
19243 
  def __ne__(self, other):
19244 
    return not (self == other)
3469 chandransh 19245 
 
19246 
class changeItem_args:
19247 
  """
19248 
  Attributes:
19249 
   - orderId
19250 
   - itemId
19251 
  """
19252 
 
19253 
  thrift_spec = (
19254 
    None, # 0
19255 
    (1, TType.I64, 'orderId', None, None, ), # 1
19256 
    (2, TType.I64, 'itemId', None, None, ), # 2
19257 
  )
19258 
 
19259 
  def __init__(self, orderId=None, itemId=None,):
19260 
    self.orderId = orderId
19261 
    self.itemId = itemId
19262 
 
19263 
  def read(self, iprot):
19264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19266 
      return
19267 
    iprot.readStructBegin()
19268 
    while True:
19269 
      (fname, ftype, fid) = iprot.readFieldBegin()
19270 
      if ftype == TType.STOP:
19271 
        break
19272 
      if fid == 1:
19273 
        if ftype == TType.I64:
19274 
          self.orderId = iprot.readI64();
19275 
        else:
19276 
          iprot.skip(ftype)
19277 
      elif fid == 2:
19278 
        if ftype == TType.I64:
19279 
          self.itemId = iprot.readI64();
19280 
        else:
19281 
          iprot.skip(ftype)
19282 
      else:
19283 
        iprot.skip(ftype)
19284 
      iprot.readFieldEnd()
19285 
    iprot.readStructEnd()
19286 
 
19287 
  def write(self, oprot):
19288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19290 
      return
19291 
    oprot.writeStructBegin('changeItem_args')
19292 
    if self.orderId is not None:
19293 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19294 
      oprot.writeI64(self.orderId)
19295 
      oprot.writeFieldEnd()
19296 
    if self.itemId is not None:
19297 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19298 
      oprot.writeI64(self.itemId)
19299 
      oprot.writeFieldEnd()
19300 
    oprot.writeFieldStop()
19301 
    oprot.writeStructEnd()
19302 
 
19303 
  def validate(self):
19304 
    return
19305 
 
19306 
 
19307 
  def __repr__(self):
19308 
    L = ['%s=%r' % (key, value)
19309 
      for key, value in self.__dict__.iteritems()]
19310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19311 
 
19312 
  def __eq__(self, other):
19313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19314 
 
19315 
  def __ne__(self, other):
19316 
    return not (self == other)
19317 
 
19318 
class changeItem_result:
19319 
  """
19320 
  Attributes:
19321 
   - success
19322 
   - ex
19323 
  """
19324 
 
19325 
  thrift_spec = (
19326 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19328 
  )
19329 
 
19330 
  def __init__(self, success=None, ex=None,):
19331 
    self.success = success
19332 
    self.ex = ex
19333 
 
19334 
  def read(self, iprot):
19335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19337 
      return
19338 
    iprot.readStructBegin()
19339 
    while True:
19340 
      (fname, ftype, fid) = iprot.readFieldBegin()
19341 
      if ftype == TType.STOP:
19342 
        break
19343 
      if fid == 0:
19344 
        if ftype == TType.STRUCT:
19345 
          self.success = Order()
19346 
          self.success.read(iprot)
19347 
        else:
19348 
          iprot.skip(ftype)
19349 
      elif fid == 1:
19350 
        if ftype == TType.STRUCT:
19351 
          self.ex = TransactionServiceException()
19352 
          self.ex.read(iprot)
19353 
        else:
19354 
          iprot.skip(ftype)
19355 
      else:
19356 
        iprot.skip(ftype)
19357 
      iprot.readFieldEnd()
19358 
    iprot.readStructEnd()
19359 
 
19360 
  def write(self, oprot):
19361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19363 
      return
19364 
    oprot.writeStructBegin('changeItem_result')
19365 
    if self.success is not None:
19366 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19367 
      self.success.write(oprot)
19368 
      oprot.writeFieldEnd()
19369 
    if self.ex is not None:
19370 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19371 
      self.ex.write(oprot)
19372 
      oprot.writeFieldEnd()
19373 
    oprot.writeFieldStop()
19374 
    oprot.writeStructEnd()
19375 
 
19376 
  def validate(self):
19377 
    return
19378 
 
19379 
 
19380 
  def __repr__(self):
19381 
    L = ['%s=%r' % (key, value)
19382 
      for key, value in self.__dict__.iteritems()]
19383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19384 
 
19385 
  def __eq__(self, other):
19386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19387 
 
19388 
  def __ne__(self, other):
19389 
    return not (self == other)
19390 
 
19391 
class shiftToWarehouse_args:
19392 
  """
19393 
  Attributes:
19394 
   - orderId
19395 
   - warehouseId
19396 
  """
19397 
 
19398 
  thrift_spec = (
19399 
    None, # 0
19400 
    (1, TType.I64, 'orderId', None, None, ), # 1
19401 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19402 
  )
19403 
 
19404 
  def __init__(self, orderId=None, warehouseId=None,):
19405 
    self.orderId = orderId
19406 
    self.warehouseId = warehouseId
19407 
 
19408 
  def read(self, iprot):
19409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19411 
      return
19412 
    iprot.readStructBegin()
19413 
    while True:
19414 
      (fname, ftype, fid) = iprot.readFieldBegin()
19415 
      if ftype == TType.STOP:
19416 
        break
19417 
      if fid == 1:
19418 
        if ftype == TType.I64:
19419 
          self.orderId = iprot.readI64();
19420 
        else:
19421 
          iprot.skip(ftype)
19422 
      elif fid == 2:
19423 
        if ftype == TType.I64:
19424 
          self.warehouseId = iprot.readI64();
19425 
        else:
19426 
          iprot.skip(ftype)
19427 
      else:
19428 
        iprot.skip(ftype)
19429 
      iprot.readFieldEnd()
19430 
    iprot.readStructEnd()
19431 
 
19432 
  def write(self, oprot):
19433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19435 
      return
19436 
    oprot.writeStructBegin('shiftToWarehouse_args')
19437 
    if self.orderId is not None:
19438 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19439 
      oprot.writeI64(self.orderId)
19440 
      oprot.writeFieldEnd()
19441 
    if self.warehouseId is not None:
19442 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19443 
      oprot.writeI64(self.warehouseId)
19444 
      oprot.writeFieldEnd()
19445 
    oprot.writeFieldStop()
19446 
    oprot.writeStructEnd()
19447 
 
19448 
  def validate(self):
19449 
    return
19450 
 
19451 
 
19452 
  def __repr__(self):
19453 
    L = ['%s=%r' % (key, value)
19454 
      for key, value in self.__dict__.iteritems()]
19455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19456 
 
19457 
  def __eq__(self, other):
19458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19459 
 
19460 
  def __ne__(self, other):
19461 
    return not (self == other)
19462 
 
19463 
class shiftToWarehouse_result:
19464 
  """
19465 
  Attributes:
19466 
   - success
19467 
   - ex
19468 
  """
19469 
 
19470 
  thrift_spec = (
19471 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19472 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19473 
  )
19474 
 
19475 
  def __init__(self, success=None, ex=None,):
19476 
    self.success = success
19477 
    self.ex = ex
19478 
 
19479 
  def read(self, iprot):
19480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19482 
      return
19483 
    iprot.readStructBegin()
19484 
    while True:
19485 
      (fname, ftype, fid) = iprot.readFieldBegin()
19486 
      if ftype == TType.STOP:
19487 
        break
19488 
      if fid == 0:
19489 
        if ftype == TType.STRUCT:
19490 
          self.success = Order()
19491 
          self.success.read(iprot)
19492 
        else:
19493 
          iprot.skip(ftype)
19494 
      elif fid == 1:
19495 
        if ftype == TType.STRUCT:
19496 
          self.ex = TransactionServiceException()
19497 
          self.ex.read(iprot)
19498 
        else:
19499 
          iprot.skip(ftype)
19500 
      else:
19501 
        iprot.skip(ftype)
19502 
      iprot.readFieldEnd()
19503 
    iprot.readStructEnd()
19504 
 
19505 
  def write(self, oprot):
19506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19508 
      return
19509 
    oprot.writeStructBegin('shiftToWarehouse_result')
19510 
    if self.success is not None:
19511 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19512 
      self.success.write(oprot)
19513 
      oprot.writeFieldEnd()
19514 
    if self.ex is not None:
19515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19516 
      self.ex.write(oprot)
19517 
      oprot.writeFieldEnd()
19518 
    oprot.writeFieldStop()
19519 
    oprot.writeStructEnd()
19520 
 
19521 
  def validate(self):
19522 
    return
19523 
 
19524 
 
19525 
  def __repr__(self):
19526 
    L = ['%s=%r' % (key, value)
19527 
      for key, value in self.__dict__.iteritems()]
19528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19529 
 
19530 
  def __eq__(self, other):
19531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19532 
 
19533 
  def __ne__(self, other):
19534 
    return not (self == other)
3553 chandransh 19535 
 
19536 
class addDelayReason_args:
19537 
  """
19538 
  Attributes:
19539 
   - orderId
19540 
   - delayReason
3986 chandransh 19541 
   - furtherDelay
4647 rajveer 19542 
   - delayReasonText
3553 chandransh 19543 
  """
19544 
 
19545 
  thrift_spec = (
19546 
    None, # 0
19547 
    (1, TType.I64, 'orderId', None, None, ), # 1
19548 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19549 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19550 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19551 
  )
19552 
 
4647 rajveer 19553 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19554 
    self.orderId = orderId
19555 
    self.delayReason = delayReason
3986 chandransh 19556 
    self.furtherDelay = furtherDelay
4647 rajveer 19557 
    self.delayReasonText = delayReasonText
3553 chandransh 19558 
 
19559 
  def read(self, iprot):
19560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19562 
      return
19563 
    iprot.readStructBegin()
19564 
    while True:
19565 
      (fname, ftype, fid) = iprot.readFieldBegin()
19566 
      if ftype == TType.STOP:
19567 
        break
19568 
      if fid == 1:
19569 
        if ftype == TType.I64:
19570 
          self.orderId = iprot.readI64();
19571 
        else:
19572 
          iprot.skip(ftype)
19573 
      elif fid == 2:
19574 
        if ftype == TType.I32:
19575 
          self.delayReason = iprot.readI32();
19576 
        else:
19577 
          iprot.skip(ftype)
3986 chandransh 19578 
      elif fid == 3:
19579 
        if ftype == TType.I64:
19580 
          self.furtherDelay = iprot.readI64();
19581 
        else:
19582 
          iprot.skip(ftype)
4647 rajveer 19583 
      elif fid == 4:
19584 
        if ftype == TType.STRING:
19585 
          self.delayReasonText = iprot.readString();
19586 
        else:
19587 
          iprot.skip(ftype)
3553 chandransh 19588 
      else:
19589 
        iprot.skip(ftype)
19590 
      iprot.readFieldEnd()
19591 
    iprot.readStructEnd()
19592 
 
19593 
  def write(self, oprot):
19594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19596 
      return
19597 
    oprot.writeStructBegin('addDelayReason_args')
19598 
    if self.orderId is not None:
19599 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19600 
      oprot.writeI64(self.orderId)
19601 
      oprot.writeFieldEnd()
19602 
    if self.delayReason is not None:
19603 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19604 
      oprot.writeI32(self.delayReason)
19605 
      oprot.writeFieldEnd()
3986 chandransh 19606 
    if self.furtherDelay is not None:
19607 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19608 
      oprot.writeI64(self.furtherDelay)
19609 
      oprot.writeFieldEnd()
4647 rajveer 19610 
    if self.delayReasonText is not None:
19611 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19612 
      oprot.writeString(self.delayReasonText)
19613 
      oprot.writeFieldEnd()
3553 chandransh 19614 
    oprot.writeFieldStop()
19615 
    oprot.writeStructEnd()
19616 
 
19617 
  def validate(self):
19618 
    return
19619 
 
19620 
 
19621 
  def __repr__(self):
19622 
    L = ['%s=%r' % (key, value)
19623 
      for key, value in self.__dict__.iteritems()]
19624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19625 
 
19626 
  def __eq__(self, other):
19627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19628 
 
19629 
  def __ne__(self, other):
19630 
    return not (self == other)
19631 
 
19632 
class addDelayReason_result:
19633 
  """
19634 
  Attributes:
19635 
   - success
19636 
   - ex
19637 
  """
19638 
 
19639 
  thrift_spec = (
19640 
    (0, TType.BOOL, 'success', None, None, ), # 0
19641 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19642 
  )
19643 
 
19644 
  def __init__(self, success=None, ex=None,):
19645 
    self.success = success
19646 
    self.ex = ex
19647 
 
19648 
  def read(self, iprot):
19649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19651 
      return
19652 
    iprot.readStructBegin()
19653 
    while True:
19654 
      (fname, ftype, fid) = iprot.readFieldBegin()
19655 
      if ftype == TType.STOP:
19656 
        break
19657 
      if fid == 0:
19658 
        if ftype == TType.BOOL:
19659 
          self.success = iprot.readBool();
19660 
        else:
19661 
          iprot.skip(ftype)
19662 
      elif fid == 1:
19663 
        if ftype == TType.STRUCT:
19664 
          self.ex = TransactionServiceException()
19665 
          self.ex.read(iprot)
19666 
        else:
19667 
          iprot.skip(ftype)
19668 
      else:
19669 
        iprot.skip(ftype)
19670 
      iprot.readFieldEnd()
19671 
    iprot.readStructEnd()
19672 
 
19673 
  def write(self, oprot):
19674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19676 
      return
19677 
    oprot.writeStructBegin('addDelayReason_result')
19678 
    if self.success is not None:
19679 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19680 
      oprot.writeBool(self.success)
19681 
      oprot.writeFieldEnd()
19682 
    if self.ex is not None:
19683 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19684 
      self.ex.write(oprot)
19685 
      oprot.writeFieldEnd()
19686 
    oprot.writeFieldStop()
19687 
    oprot.writeStructEnd()
19688 
 
19689 
  def validate(self):
19690 
    return
19691 
 
19692 
 
19693 
  def __repr__(self):
19694 
    L = ['%s=%r' % (key, value)
19695 
      for key, value in self.__dict__.iteritems()]
19696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19697 
 
19698 
  def __eq__(self, other):
19699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19700 
 
19701 
  def __ne__(self, other):
19702 
    return not (self == other)
3956 chandransh 19703 
 
19704 
class reconcileCodCollection_args:
19705 
  """
19706 
  Attributes:
19707 
   - collectedAmountMap
19708 
   - xferBy
19709 
   - xferTxnId
19710 
   - xferDate
19711 
  """
19712 
 
19713 
  thrift_spec = (
19714 
    None, # 0
19715 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19716 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19717 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19718 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19719 
  )
19720 
 
19721 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19722 
    self.collectedAmountMap = collectedAmountMap
19723 
    self.xferBy = xferBy
19724 
    self.xferTxnId = xferTxnId
19725 
    self.xferDate = xferDate
19726 
 
19727 
  def read(self, iprot):
19728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19730 
      return
19731 
    iprot.readStructBegin()
19732 
    while True:
19733 
      (fname, ftype, fid) = iprot.readFieldBegin()
19734 
      if ftype == TType.STOP:
19735 
        break
19736 
      if fid == 1:
19737 
        if ftype == TType.MAP:
19738 
          self.collectedAmountMap = {}
6188 rajveer 19739 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19740 
          for _i457 in xrange(_size453):
19741 
            _key458 = iprot.readString();
19742 
            _val459 = iprot.readDouble();
19743 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19744 
          iprot.readMapEnd()
19745 
        else:
19746 
          iprot.skip(ftype)
19747 
      elif fid == 2:
19748 
        if ftype == TType.STRING:
19749 
          self.xferBy = iprot.readString();
19750 
        else:
19751 
          iprot.skip(ftype)
19752 
      elif fid == 3:
19753 
        if ftype == TType.STRING:
19754 
          self.xferTxnId = iprot.readString();
19755 
        else:
19756 
          iprot.skip(ftype)
19757 
      elif fid == 4:
19758 
        if ftype == TType.I64:
19759 
          self.xferDate = iprot.readI64();
19760 
        else:
19761 
          iprot.skip(ftype)
19762 
      else:
19763 
        iprot.skip(ftype)
19764 
      iprot.readFieldEnd()
19765 
    iprot.readStructEnd()
19766 
 
19767 
  def write(self, oprot):
19768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19770 
      return
19771 
    oprot.writeStructBegin('reconcileCodCollection_args')
19772 
    if self.collectedAmountMap is not None:
19773 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19774 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19775 
      for kiter460,viter461 in self.collectedAmountMap.items():
19776 
        oprot.writeString(kiter460)
19777 
        oprot.writeDouble(viter461)
3956 chandransh 19778 
      oprot.writeMapEnd()
19779 
      oprot.writeFieldEnd()
19780 
    if self.xferBy is not None:
19781 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19782 
      oprot.writeString(self.xferBy)
19783 
      oprot.writeFieldEnd()
19784 
    if self.xferTxnId is not None:
19785 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19786 
      oprot.writeString(self.xferTxnId)
19787 
      oprot.writeFieldEnd()
19788 
    if self.xferDate is not None:
19789 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19790 
      oprot.writeI64(self.xferDate)
19791 
      oprot.writeFieldEnd()
19792 
    oprot.writeFieldStop()
19793 
    oprot.writeStructEnd()
19794 
 
19795 
  def validate(self):
19796 
    return
19797 
 
19798 
 
19799 
  def __repr__(self):
19800 
    L = ['%s=%r' % (key, value)
19801 
      for key, value in self.__dict__.iteritems()]
19802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19803 
 
19804 
  def __eq__(self, other):
19805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19806 
 
19807 
  def __ne__(self, other):
19808 
    return not (self == other)
19809 
 
19810 
class reconcileCodCollection_result:
19811 
  """
19812 
  Attributes:
19813 
   - success
19814 
   - ex
19815 
  """
19816 
 
19817 
  thrift_spec = (
19818 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19819 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19820 
  )
19821 
 
19822 
  def __init__(self, success=None, ex=None,):
19823 
    self.success = success
19824 
    self.ex = ex
19825 
 
19826 
  def read(self, iprot):
19827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19829 
      return
19830 
    iprot.readStructBegin()
19831 
    while True:
19832 
      (fname, ftype, fid) = iprot.readFieldBegin()
19833 
      if ftype == TType.STOP:
19834 
        break
19835 
      if fid == 0:
19836 
        if ftype == TType.MAP:
19837 
          self.success = {}
6188 rajveer 19838 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19839 
          for _i466 in xrange(_size462):
19840 
            _key467 = iprot.readString();
19841 
            _val468 = iprot.readString();
19842 
            self.success[_key467] = _val468
3956 chandransh 19843 
          iprot.readMapEnd()
19844 
        else:
19845 
          iprot.skip(ftype)
19846 
      elif fid == 1:
19847 
        if ftype == TType.STRUCT:
19848 
          self.ex = TransactionServiceException()
19849 
          self.ex.read(iprot)
19850 
        else:
19851 
          iprot.skip(ftype)
19852 
      else:
19853 
        iprot.skip(ftype)
19854 
      iprot.readFieldEnd()
19855 
    iprot.readStructEnd()
19856 
 
19857 
  def write(self, oprot):
19858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19860 
      return
19861 
    oprot.writeStructBegin('reconcileCodCollection_result')
19862 
    if self.success is not None:
19863 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19864 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19865 
      for kiter469,viter470 in self.success.items():
19866 
        oprot.writeString(kiter469)
19867 
        oprot.writeString(viter470)
3956 chandransh 19868 
      oprot.writeMapEnd()
19869 
      oprot.writeFieldEnd()
19870 
    if self.ex is not None:
19871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19872 
      self.ex.write(oprot)
19873 
      oprot.writeFieldEnd()
19874 
    oprot.writeFieldStop()
19875 
    oprot.writeStructEnd()
19876 
 
19877 
  def validate(self):
19878 
    return
19879 
 
19880 
 
19881 
  def __repr__(self):
19882 
    L = ['%s=%r' % (key, value)
19883 
      for key, value in self.__dict__.iteritems()]
19884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19885 
 
19886 
  def __eq__(self, other):
19887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19888 
 
19889 
  def __ne__(self, other):
19890 
    return not (self == other)
4008 mandeep.dh 19891 
 
19892 
class getTransactionsRequiringExtraProcessing_args:
19893 
  """
19894 
  Attributes:
19895 
   - category
19896 
  """
19897 
 
19898 
  thrift_spec = (
19899 
    None, # 0
19900 
    (1, TType.I32, 'category', None, None, ), # 1
19901 
  )
19902 
 
19903 
  def __init__(self, category=None,):
19904 
    self.category = category
19905 
 
19906 
  def read(self, iprot):
19907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19909 
      return
19910 
    iprot.readStructBegin()
19911 
    while True:
19912 
      (fname, ftype, fid) = iprot.readFieldBegin()
19913 
      if ftype == TType.STOP:
19914 
        break
19915 
      if fid == 1:
19916 
        if ftype == TType.I32:
19917 
          self.category = iprot.readI32();
19918 
        else:
19919 
          iprot.skip(ftype)
19920 
      else:
19921 
        iprot.skip(ftype)
19922 
      iprot.readFieldEnd()
19923 
    iprot.readStructEnd()
19924 
 
19925 
  def write(self, oprot):
19926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19928 
      return
19929 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19930 
    if self.category is not None:
19931 
      oprot.writeFieldBegin('category', TType.I32, 1)
19932 
      oprot.writeI32(self.category)
19933 
      oprot.writeFieldEnd()
19934 
    oprot.writeFieldStop()
19935 
    oprot.writeStructEnd()
19936 
 
19937 
  def validate(self):
19938 
    return
19939 
 
19940 
 
19941 
  def __repr__(self):
19942 
    L = ['%s=%r' % (key, value)
19943 
      for key, value in self.__dict__.iteritems()]
19944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19945 
 
19946 
  def __eq__(self, other):
19947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19948 
 
19949 
  def __ne__(self, other):
19950 
    return not (self == other)
19951 
 
19952 
class getTransactionsRequiringExtraProcessing_result:
19953 
  """
19954 
  Attributes:
19955 
   - success
19956 
  """
19957 
 
19958 
  thrift_spec = (
19959 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19960 
  )
19961 
 
19962 
  def __init__(self, success=None,):
19963 
    self.success = success
19964 
 
19965 
  def read(self, iprot):
19966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19968 
      return
19969 
    iprot.readStructBegin()
19970 
    while True:
19971 
      (fname, ftype, fid) = iprot.readFieldBegin()
19972 
      if ftype == TType.STOP:
19973 
        break
19974 
      if fid == 0:
19975 
        if ftype == TType.LIST:
19976 
          self.success = []
6188 rajveer 19977 
          (_etype474, _size471) = iprot.readListBegin()
19978 
          for _i475 in xrange(_size471):
19979 
            _elem476 = iprot.readI64();
19980 
            self.success.append(_elem476)
4008 mandeep.dh 19981 
          iprot.readListEnd()
19982 
        else:
19983 
          iprot.skip(ftype)
19984 
      else:
19985 
        iprot.skip(ftype)
19986 
      iprot.readFieldEnd()
19987 
    iprot.readStructEnd()
19988 
 
19989 
  def write(self, oprot):
19990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19992 
      return
19993 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19994 
    if self.success is not None:
19995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19996 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19997 
      for iter477 in self.success:
19998 
        oprot.writeI64(iter477)
4008 mandeep.dh 19999 
      oprot.writeListEnd()
20000 
      oprot.writeFieldEnd()
20001 
    oprot.writeFieldStop()
20002 
    oprot.writeStructEnd()
20003 
 
20004 
  def validate(self):
20005 
    return
20006 
 
20007 
 
20008 
  def __repr__(self):
20009 
    L = ['%s=%r' % (key, value)
20010 
      for key, value in self.__dict__.iteritems()]
20011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20012 
 
20013 
  def __eq__(self, other):
20014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20015 
 
20016 
  def __ne__(self, other):
20017 
    return not (self == other)
20018 
 
20019 
class markTransactionAsProcessed_args:
20020 
  """
20021 
  Attributes:
20022 
   - transactionId
20023 
   - category
20024 
  """
20025 
 
20026 
  thrift_spec = (
20027 
    None, # 0
20028 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20029 
    (2, TType.I32, 'category', None, None, ), # 2
20030 
  )
20031 
 
20032 
  def __init__(self, transactionId=None, category=None,):
20033 
    self.transactionId = transactionId
20034 
    self.category = category
20035 
 
20036 
  def read(self, iprot):
20037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20039 
      return
20040 
    iprot.readStructBegin()
20041 
    while True:
20042 
      (fname, ftype, fid) = iprot.readFieldBegin()
20043 
      if ftype == TType.STOP:
20044 
        break
20045 
      if fid == 1:
20046 
        if ftype == TType.I64:
20047 
          self.transactionId = iprot.readI64();
20048 
        else:
20049 
          iprot.skip(ftype)
20050 
      elif fid == 2:
20051 
        if ftype == TType.I32:
20052 
          self.category = iprot.readI32();
20053 
        else:
20054 
          iprot.skip(ftype)
20055 
      else:
20056 
        iprot.skip(ftype)
20057 
      iprot.readFieldEnd()
20058 
    iprot.readStructEnd()
20059 
 
20060 
  def write(self, oprot):
20061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20063 
      return
20064 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20065 
    if self.transactionId is not None:
20066 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20067 
      oprot.writeI64(self.transactionId)
20068 
      oprot.writeFieldEnd()
20069 
    if self.category is not None:
20070 
      oprot.writeFieldBegin('category', TType.I32, 2)
20071 
      oprot.writeI32(self.category)
20072 
      oprot.writeFieldEnd()
20073 
    oprot.writeFieldStop()
20074 
    oprot.writeStructEnd()
20075 
 
20076 
  def validate(self):
20077 
    return
20078 
 
20079 
 
20080 
  def __repr__(self):
20081 
    L = ['%s=%r' % (key, value)
20082 
      for key, value in self.__dict__.iteritems()]
20083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20084 
 
20085 
  def __eq__(self, other):
20086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20087 
 
20088 
  def __ne__(self, other):
20089 
    return not (self == other)
20090 
 
20091 
class markTransactionAsProcessed_result:
20092 
 
20093 
  thrift_spec = (
20094 
  )
20095 
 
20096 
  def read(self, iprot):
20097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20099 
      return
20100 
    iprot.readStructBegin()
20101 
    while True:
20102 
      (fname, ftype, fid) = iprot.readFieldBegin()
20103 
      if ftype == TType.STOP:
20104 
        break
20105 
      else:
20106 
        iprot.skip(ftype)
20107 
      iprot.readFieldEnd()
20108 
    iprot.readStructEnd()
20109 
 
20110 
  def write(self, oprot):
20111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20113 
      return
20114 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20115 
    oprot.writeFieldStop()
20116 
    oprot.writeStructEnd()
20117 
 
20118 
  def validate(self):
20119 
    return
20120 
 
20121 
 
20122 
  def __repr__(self):
20123 
    L = ['%s=%r' % (key, value)
20124 
      for key, value in self.__dict__.iteritems()]
20125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20126 
 
20127 
  def __eq__(self, other):
20128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20129 
 
20130 
  def __ne__(self, other):
20131 
    return not (self == other)
4018 chandransh 20132 
 
20133 
class getItemWiseRiskyOrdersCount_args:
20134 
 
20135 
  thrift_spec = (
20136 
  )
20137 
 
20138 
  def read(self, iprot):
20139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20141 
      return
20142 
    iprot.readStructBegin()
20143 
    while True:
20144 
      (fname, ftype, fid) = iprot.readFieldBegin()
20145 
      if ftype == TType.STOP:
20146 
        break
20147 
      else:
20148 
        iprot.skip(ftype)
20149 
      iprot.readFieldEnd()
20150 
    iprot.readStructEnd()
20151 
 
20152 
  def write(self, oprot):
20153 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20154 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20155 
      return
20156 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20157 
    oprot.writeFieldStop()
20158 
    oprot.writeStructEnd()
20159 
 
20160 
  def validate(self):
20161 
    return
20162 
 
20163 
 
20164 
  def __repr__(self):
20165 
    L = ['%s=%r' % (key, value)
20166 
      for key, value in self.__dict__.iteritems()]
20167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20168 
 
20169 
  def __eq__(self, other):
20170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20171 
 
20172 
  def __ne__(self, other):
20173 
    return not (self == other)
20174 
 
20175 
class getItemWiseRiskyOrdersCount_result:
20176 
  """
20177 
  Attributes:
20178 
   - success
20179 
  """
20180 
 
20181 
  thrift_spec = (
20182 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20183 
  )
20184 
 
20185 
  def __init__(self, success=None,):
20186 
    self.success = success
20187 
 
20188 
  def read(self, iprot):
20189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20191 
      return
20192 
    iprot.readStructBegin()
20193 
    while True:
20194 
      (fname, ftype, fid) = iprot.readFieldBegin()
20195 
      if ftype == TType.STOP:
20196 
        break
20197 
      if fid == 0:
20198 
        if ftype == TType.MAP:
20199 
          self.success = {}
6188 rajveer 20200 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20201 
          for _i482 in xrange(_size478):
20202 
            _key483 = iprot.readI64();
20203 
            _val484 = iprot.readI64();
20204 
            self.success[_key483] = _val484
4018 chandransh 20205 
          iprot.readMapEnd()
20206 
        else:
20207 
          iprot.skip(ftype)
20208 
      else:
20209 
        iprot.skip(ftype)
20210 
      iprot.readFieldEnd()
20211 
    iprot.readStructEnd()
20212 
 
20213 
  def write(self, oprot):
20214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20216 
      return
20217 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20218 
    if self.success is not None:
20219 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20220 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20221 
      for kiter485,viter486 in self.success.items():
20222 
        oprot.writeI64(kiter485)
20223 
        oprot.writeI64(viter486)
4018 chandransh 20224 
      oprot.writeMapEnd()
20225 
      oprot.writeFieldEnd()
20226 
    oprot.writeFieldStop()
20227 
    oprot.writeStructEnd()
20228 
 
20229 
  def validate(self):
20230 
    return
20231 
 
20232 
 
20233 
  def __repr__(self):
20234 
    L = ['%s=%r' % (key, value)
20235 
      for key, value in self.__dict__.iteritems()]
20236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20237 
 
20238 
  def __eq__(self, other):
20239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20240 
 
20241 
  def __ne__(self, other):
20242 
    return not (self == other)
4247 rajveer 20243 
 
4295 varun.gupt 20244 
class getOrdersForItemIds_args:
20245 
  """
20246 
  Attributes:
20247 
   - itemIds
20248 
  """
20249 
 
20250 
  thrift_spec = (
20251 
    None, # 0
20252 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20253 
  )
20254 
 
20255 
  def __init__(self, itemIds=None,):
20256 
    self.itemIds = itemIds
20257 
 
20258 
  def read(self, iprot):
20259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20261 
      return
20262 
    iprot.readStructBegin()
20263 
    while True:
20264 
      (fname, ftype, fid) = iprot.readFieldBegin()
20265 
      if ftype == TType.STOP:
20266 
        break
20267 
      if fid == 1:
20268 
        if ftype == TType.LIST:
20269 
          self.itemIds = []
6188 rajveer 20270 
          (_etype490, _size487) = iprot.readListBegin()
20271 
          for _i491 in xrange(_size487):
20272 
            _elem492 = iprot.readI64();
20273 
            self.itemIds.append(_elem492)
4295 varun.gupt 20274 
          iprot.readListEnd()
20275 
        else:
20276 
          iprot.skip(ftype)
20277 
      else:
20278 
        iprot.skip(ftype)
20279 
      iprot.readFieldEnd()
20280 
    iprot.readStructEnd()
20281 
 
20282 
  def write(self, oprot):
20283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20285 
      return
20286 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20287 
    if self.itemIds is not None:
20288 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20289 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20290 
      for iter493 in self.itemIds:
20291 
        oprot.writeI64(iter493)
4295 varun.gupt 20292 
      oprot.writeListEnd()
20293 
      oprot.writeFieldEnd()
20294 
    oprot.writeFieldStop()
20295 
    oprot.writeStructEnd()
20296 
 
20297 
  def validate(self):
20298 
    return
20299 
 
20300 
 
20301 
  def __repr__(self):
20302 
    L = ['%s=%r' % (key, value)
20303 
      for key, value in self.__dict__.iteritems()]
20304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20305 
 
20306 
  def __eq__(self, other):
20307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20308 
 
20309 
  def __ne__(self, other):
20310 
    return not (self == other)
20311 
 
20312 
class getOrdersForItemIds_result:
20313 
  """
20314 
  Attributes:
20315 
   - success
20316 
  """
20317 
 
20318 
  thrift_spec = (
20319 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20320 
  )
20321 
 
20322 
  def __init__(self, success=None,):
20323 
    self.success = success
20324 
 
20325 
  def read(self, iprot):
20326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20328 
      return
20329 
    iprot.readStructBegin()
20330 
    while True:
20331 
      (fname, ftype, fid) = iprot.readFieldBegin()
20332 
      if ftype == TType.STOP:
20333 
        break
20334 
      if fid == 0:
20335 
        if ftype == TType.LIST:
20336 
          self.success = []
6188 rajveer 20337 
          (_etype497, _size494) = iprot.readListBegin()
20338 
          for _i498 in xrange(_size494):
20339 
            _elem499 = Order()
20340 
            _elem499.read(iprot)
20341 
            self.success.append(_elem499)
4295 varun.gupt 20342 
          iprot.readListEnd()
20343 
        else:
20344 
          iprot.skip(ftype)
20345 
      else:
20346 
        iprot.skip(ftype)
20347 
      iprot.readFieldEnd()
20348 
    iprot.readStructEnd()
20349 
 
20350 
  def write(self, oprot):
20351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20353 
      return
20354 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20355 
    if self.success is not None:
20356 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20357 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20358 
      for iter500 in self.success:
20359 
        iter500.write(oprot)
4295 varun.gupt 20360 
      oprot.writeListEnd()
20361 
      oprot.writeFieldEnd()
20362 
    oprot.writeFieldStop()
20363 
    oprot.writeStructEnd()
20364 
 
20365 
  def validate(self):
20366 
    return
20367 
 
20368 
 
20369 
  def __repr__(self):
20370 
    L = ['%s=%r' % (key, value)
20371 
      for key, value in self.__dict__.iteritems()]
20372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20373 
 
20374 
  def __eq__(self, other):
20375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20376 
 
20377 
  def __ne__(self, other):
20378 
    return not (self == other)
20379 
 
4247 rajveer 20380 
class markOrderCancellationRequestReceived_args:
20381 
  """
20382 
  Attributes:
20383 
   - orderId
20384 
  """
20385 
 
20386 
  thrift_spec = (
20387 
    None, # 0
20388 
    (1, TType.I64, 'orderId', None, None, ), # 1
20389 
  )
20390 
 
20391 
  def __init__(self, orderId=None,):
20392 
    self.orderId = orderId
20393 
 
20394 
  def read(self, iprot):
20395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20397 
      return
20398 
    iprot.readStructBegin()
20399 
    while True:
20400 
      (fname, ftype, fid) = iprot.readFieldBegin()
20401 
      if ftype == TType.STOP:
20402 
        break
20403 
      if fid == 1:
20404 
        if ftype == TType.I64:
20405 
          self.orderId = iprot.readI64();
20406 
        else:
20407 
          iprot.skip(ftype)
20408 
      else:
20409 
        iprot.skip(ftype)
20410 
      iprot.readFieldEnd()
20411 
    iprot.readStructEnd()
20412 
 
20413 
  def write(self, oprot):
20414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20416 
      return
20417 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20418 
    if self.orderId is not None:
20419 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20420 
      oprot.writeI64(self.orderId)
20421 
      oprot.writeFieldEnd()
20422 
    oprot.writeFieldStop()
20423 
    oprot.writeStructEnd()
20424 
 
20425 
  def validate(self):
20426 
    return
20427 
 
20428 
 
20429 
  def __repr__(self):
20430 
    L = ['%s=%r' % (key, value)
20431 
      for key, value in self.__dict__.iteritems()]
20432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20433 
 
20434 
  def __eq__(self, other):
20435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20436 
 
20437 
  def __ne__(self, other):
20438 
    return not (self == other)
20439 
 
20440 
class markOrderCancellationRequestReceived_result:
20441 
  """
20442 
  Attributes:
20443 
   - ex
20444 
  """
20445 
 
20446 
  thrift_spec = (
20447 
    None, # 0
20448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20449 
  )
20450 
 
20451 
  def __init__(self, ex=None,):
20452 
    self.ex = ex
20453 
 
20454 
  def read(self, iprot):
20455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20457 
      return
20458 
    iprot.readStructBegin()
20459 
    while True:
20460 
      (fname, ftype, fid) = iprot.readFieldBegin()
20461 
      if ftype == TType.STOP:
20462 
        break
20463 
      if fid == 1:
20464 
        if ftype == TType.STRUCT:
20465 
          self.ex = TransactionServiceException()
20466 
          self.ex.read(iprot)
20467 
        else:
20468 
          iprot.skip(ftype)
20469 
      else:
20470 
        iprot.skip(ftype)
20471 
      iprot.readFieldEnd()
20472 
    iprot.readStructEnd()
20473 
 
20474 
  def write(self, oprot):
20475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20477 
      return
20478 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20479 
    if self.ex is not None:
20480 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20481 
      self.ex.write(oprot)
20482 
      oprot.writeFieldEnd()
20483 
    oprot.writeFieldStop()
20484 
    oprot.writeStructEnd()
20485 
 
20486 
  def validate(self):
20487 
    return
20488 
 
20489 
 
20490 
  def __repr__(self):
20491 
    L = ['%s=%r' % (key, value)
20492 
      for key, value in self.__dict__.iteritems()]
20493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20494 
 
20495 
  def __eq__(self, other):
20496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20497 
 
20498 
  def __ne__(self, other):
20499 
    return not (self == other)
20500 
 
20501 
class markOrderCancellationRequestConfirmed_args:
20502 
  """
20503 
  Attributes:
20504 
   - orderId
20505 
  """
20506 
 
20507 
  thrift_spec = (
20508 
    None, # 0
20509 
    (1, TType.I64, 'orderId', None, None, ), # 1
20510 
  )
20511 
 
20512 
  def __init__(self, orderId=None,):
20513 
    self.orderId = orderId
20514 
 
20515 
  def read(self, iprot):
20516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20518 
      return
20519 
    iprot.readStructBegin()
20520 
    while True:
20521 
      (fname, ftype, fid) = iprot.readFieldBegin()
20522 
      if ftype == TType.STOP:
20523 
        break
20524 
      if fid == 1:
20525 
        if ftype == TType.I64:
20526 
          self.orderId = iprot.readI64();
20527 
        else:
20528 
          iprot.skip(ftype)
20529 
      else:
20530 
        iprot.skip(ftype)
20531 
      iprot.readFieldEnd()
20532 
    iprot.readStructEnd()
20533 
 
20534 
  def write(self, oprot):
20535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20537 
      return
20538 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20539 
    if self.orderId is not None:
20540 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20541 
      oprot.writeI64(self.orderId)
20542 
      oprot.writeFieldEnd()
20543 
    oprot.writeFieldStop()
20544 
    oprot.writeStructEnd()
20545 
 
20546 
  def validate(self):
20547 
    return
20548 
 
20549 
 
20550 
  def __repr__(self):
20551 
    L = ['%s=%r' % (key, value)
20552 
      for key, value in self.__dict__.iteritems()]
20553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20554 
 
20555 
  def __eq__(self, other):
20556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20557 
 
20558 
  def __ne__(self, other):
20559 
    return not (self == other)
20560 
 
20561 
class markOrderCancellationRequestConfirmed_result:
20562 
  """
20563 
  Attributes:
20564 
   - ex
20565 
  """
20566 
 
20567 
  thrift_spec = (
20568 
    None, # 0
20569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20570 
  )
20571 
 
20572 
  def __init__(self, ex=None,):
20573 
    self.ex = ex
20574 
 
20575 
  def read(self, iprot):
20576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20578 
      return
20579 
    iprot.readStructBegin()
20580 
    while True:
20581 
      (fname, ftype, fid) = iprot.readFieldBegin()
20582 
      if ftype == TType.STOP:
20583 
        break
20584 
      if fid == 1:
20585 
        if ftype == TType.STRUCT:
20586 
          self.ex = TransactionServiceException()
20587 
          self.ex.read(iprot)
20588 
        else:
20589 
          iprot.skip(ftype)
20590 
      else:
20591 
        iprot.skip(ftype)
20592 
      iprot.readFieldEnd()
20593 
    iprot.readStructEnd()
20594 
 
20595 
  def write(self, oprot):
20596 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20597 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20598 
      return
20599 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20600 
    if self.ex is not None:
20601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20602 
      self.ex.write(oprot)
20603 
      oprot.writeFieldEnd()
20604 
    oprot.writeFieldStop()
20605 
    oprot.writeStructEnd()
20606 
 
20607 
  def validate(self):
20608 
    return
20609 
 
20610 
 
20611 
  def __repr__(self):
20612 
    L = ['%s=%r' % (key, value)
20613 
      for key, value in self.__dict__.iteritems()]
20614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20615 
 
20616 
  def __eq__(self, other):
20617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20618 
 
20619 
  def __ne__(self, other):
20620 
    return not (self == other)
20621 
 
20622 
class markOrderCancellationRequestDenied_args:
20623 
  """
20624 
  Attributes:
20625 
   - orderId
20626 
  """
20627 
 
20628 
  thrift_spec = (
20629 
    None, # 0
20630 
    (1, TType.I64, 'orderId', None, None, ), # 1
20631 
  )
20632 
 
20633 
  def __init__(self, orderId=None,):
20634 
    self.orderId = orderId
20635 
 
20636 
  def read(self, iprot):
20637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20639 
      return
20640 
    iprot.readStructBegin()
20641 
    while True:
20642 
      (fname, ftype, fid) = iprot.readFieldBegin()
20643 
      if ftype == TType.STOP:
20644 
        break
20645 
      if fid == 1:
20646 
        if ftype == TType.I64:
20647 
          self.orderId = iprot.readI64();
20648 
        else:
20649 
          iprot.skip(ftype)
20650 
      else:
20651 
        iprot.skip(ftype)
20652 
      iprot.readFieldEnd()
20653 
    iprot.readStructEnd()
20654 
 
20655 
  def write(self, oprot):
20656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20658 
      return
20659 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20660 
    if self.orderId is not None:
20661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20662 
      oprot.writeI64(self.orderId)
20663 
      oprot.writeFieldEnd()
20664 
    oprot.writeFieldStop()
20665 
    oprot.writeStructEnd()
20666 
 
20667 
  def validate(self):
20668 
    return
20669 
 
20670 
 
20671 
  def __repr__(self):
20672 
    L = ['%s=%r' % (key, value)
20673 
      for key, value in self.__dict__.iteritems()]
20674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20675 
 
20676 
  def __eq__(self, other):
20677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20678 
 
20679 
  def __ne__(self, other):
20680 
    return not (self == other)
20681 
 
20682 
class markOrderCancellationRequestDenied_result:
20683 
  """
20684 
  Attributes:
20685 
   - ex
20686 
  """
20687 
 
20688 
  thrift_spec = (
20689 
    None, # 0
20690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20691 
  )
20692 
 
20693 
  def __init__(self, ex=None,):
20694 
    self.ex = ex
20695 
 
20696 
  def read(self, iprot):
20697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20699 
      return
20700 
    iprot.readStructBegin()
20701 
    while True:
20702 
      (fname, ftype, fid) = iprot.readFieldBegin()
20703 
      if ftype == TType.STOP:
20704 
        break
20705 
      if fid == 1:
20706 
        if ftype == TType.STRUCT:
20707 
          self.ex = TransactionServiceException()
20708 
          self.ex.read(iprot)
20709 
        else:
20710 
          iprot.skip(ftype)
20711 
      else:
20712 
        iprot.skip(ftype)
20713 
      iprot.readFieldEnd()
20714 
    iprot.readStructEnd()
20715 
 
20716 
  def write(self, oprot):
20717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20719 
      return
20720 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20721 
    if self.ex is not None:
20722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20723 
      self.ex.write(oprot)
20724 
      oprot.writeFieldEnd()
20725 
    oprot.writeFieldStop()
20726 
    oprot.writeStructEnd()
20727 
 
20728 
  def validate(self):
20729 
    return
20730 
 
20731 
 
20732 
  def __repr__(self):
20733 
    L = ['%s=%r' % (key, value)
20734 
      for key, value in self.__dict__.iteritems()]
20735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20736 
 
20737 
  def __eq__(self, other):
20738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20739 
 
20740 
  def __ne__(self, other):
20741 
    return not (self == other)
20742 
 
4258 rajveer 20743 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20744 
  """
20745 
  Attributes:
4258 rajveer 20746 
   - transactionId
4247 rajveer 20747 
  """
20748 
 
20749 
  thrift_spec = (
20750 
    None, # 0
4258 rajveer 20751 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20752 
  )
20753 
 
4258 rajveer 20754 
  def __init__(self, transactionId=None,):
20755 
    self.transactionId = transactionId
4247 rajveer 20756 
 
20757 
  def read(self, iprot):
20758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20760 
      return
20761 
    iprot.readStructBegin()
20762 
    while True:
20763 
      (fname, ftype, fid) = iprot.readFieldBegin()
20764 
      if ftype == TType.STOP:
20765 
        break
20766 
      if fid == 1:
20767 
        if ftype == TType.I64:
4258 rajveer 20768 
          self.transactionId = iprot.readI64();
4247 rajveer 20769 
        else:
20770 
          iprot.skip(ftype)
20771 
      else:
20772 
        iprot.skip(ftype)
20773 
      iprot.readFieldEnd()
20774 
    iprot.readStructEnd()
20775 
 
20776 
  def write(self, oprot):
20777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20779 
      return
4258 rajveer 20780 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20781 
    if self.transactionId is not None:
20782 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20783 
      oprot.writeI64(self.transactionId)
4247 rajveer 20784 
      oprot.writeFieldEnd()
20785 
    oprot.writeFieldStop()
20786 
    oprot.writeStructEnd()
20787 
 
20788 
  def validate(self):
20789 
    return
20790 
 
20791 
 
20792 
  def __repr__(self):
20793 
    L = ['%s=%r' % (key, value)
20794 
      for key, value in self.__dict__.iteritems()]
20795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20796 
 
20797 
  def __eq__(self, other):
20798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20799 
 
20800 
  def __ne__(self, other):
20801 
    return not (self == other)
20802 
 
4258 rajveer 20803 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20804 
  """
20805 
  Attributes:
20806 
   - ex
20807 
  """
20808 
 
20809 
  thrift_spec = (
20810 
    None, # 0
20811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20812 
  )
20813 
 
20814 
  def __init__(self, ex=None,):
20815 
    self.ex = ex
20816 
 
20817 
  def read(self, iprot):
20818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20820 
      return
20821 
    iprot.readStructBegin()
20822 
    while True:
20823 
      (fname, ftype, fid) = iprot.readFieldBegin()
20824 
      if ftype == TType.STOP:
20825 
        break
20826 
      if fid == 1:
20827 
        if ftype == TType.STRUCT:
20828 
          self.ex = TransactionServiceException()
20829 
          self.ex.read(iprot)
20830 
        else:
20831 
          iprot.skip(ftype)
20832 
      else:
20833 
        iprot.skip(ftype)
20834 
      iprot.readFieldEnd()
20835 
    iprot.readStructEnd()
20836 
 
20837 
  def write(self, oprot):
20838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20840 
      return
4258 rajveer 20841 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20842 
    if self.ex is not None:
20843 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20844 
      self.ex.write(oprot)
20845 
      oprot.writeFieldEnd()
20846 
    oprot.writeFieldStop()
20847 
    oprot.writeStructEnd()
20848 
 
20849 
  def validate(self):
20850 
    return
20851 
 
20852 
 
20853 
  def __repr__(self):
20854 
    L = ['%s=%r' % (key, value)
20855 
      for key, value in self.__dict__.iteritems()]
20856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20857 
 
20858 
  def __eq__(self, other):
20859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20860 
 
20861 
  def __ne__(self, other):
20862 
    return not (self == other)
4259 anupam.sin 20863 
 
20864 
class refundTransaction_args:
20865 
  """
20866 
  Attributes:
20867 
   - transactionId
20868 
   - refundedBy
20869 
   - reason
20870 
  """
20871 
 
20872 
  thrift_spec = (
20873 
    None, # 0
20874 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20875 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20876 
    (3, TType.STRING, 'reason', None, None, ), # 3
20877 
  )
20878 
 
20879 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20880 
    self.transactionId = transactionId
20881 
    self.refundedBy = refundedBy
20882 
    self.reason = reason
20883 
 
20884 
  def read(self, iprot):
20885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20887 
      return
20888 
    iprot.readStructBegin()
20889 
    while True:
20890 
      (fname, ftype, fid) = iprot.readFieldBegin()
20891 
      if ftype == TType.STOP:
20892 
        break
20893 
      if fid == 1:
20894 
        if ftype == TType.I64:
20895 
          self.transactionId = iprot.readI64();
20896 
        else:
20897 
          iprot.skip(ftype)
20898 
      elif fid == 2:
20899 
        if ftype == TType.STRING:
20900 
          self.refundedBy = iprot.readString();
20901 
        else:
20902 
          iprot.skip(ftype)
20903 
      elif fid == 3:
20904 
        if ftype == TType.STRING:
20905 
          self.reason = iprot.readString();
20906 
        else:
20907 
          iprot.skip(ftype)
20908 
      else:
20909 
        iprot.skip(ftype)
20910 
      iprot.readFieldEnd()
20911 
    iprot.readStructEnd()
20912 
 
20913 
  def write(self, oprot):
20914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20916 
      return
20917 
    oprot.writeStructBegin('refundTransaction_args')
20918 
    if self.transactionId is not None:
20919 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20920 
      oprot.writeI64(self.transactionId)
20921 
      oprot.writeFieldEnd()
20922 
    if self.refundedBy is not None:
20923 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20924 
      oprot.writeString(self.refundedBy)
20925 
      oprot.writeFieldEnd()
20926 
    if self.reason is not None:
20927 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20928 
      oprot.writeString(self.reason)
20929 
      oprot.writeFieldEnd()
20930 
    oprot.writeFieldStop()
20931 
    oprot.writeStructEnd()
20932 
 
20933 
  def validate(self):
20934 
    return
20935 
 
20936 
 
20937 
  def __repr__(self):
20938 
    L = ['%s=%r' % (key, value)
20939 
      for key, value in self.__dict__.iteritems()]
20940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20941 
 
20942 
  def __eq__(self, other):
20943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20944 
 
20945 
  def __ne__(self, other):
20946 
    return not (self == other)
20947 
 
20948 
class refundTransaction_result:
20949 
  """
20950 
  Attributes:
20951 
   - ex
20952 
  """
20953 
 
20954 
  thrift_spec = (
20955 
    None, # 0
20956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20957 
  )
20958 
 
20959 
  def __init__(self, ex=None,):
20960 
    self.ex = ex
20961 
 
20962 
  def read(self, iprot):
20963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20965 
      return
20966 
    iprot.readStructBegin()
20967 
    while True:
20968 
      (fname, ftype, fid) = iprot.readFieldBegin()
20969 
      if ftype == TType.STOP:
20970 
        break
20971 
      if fid == 1:
20972 
        if ftype == TType.STRUCT:
20973 
          self.ex = TransactionServiceException()
20974 
          self.ex.read(iprot)
20975 
        else:
20976 
          iprot.skip(ftype)
20977 
      else:
20978 
        iprot.skip(ftype)
20979 
      iprot.readFieldEnd()
20980 
    iprot.readStructEnd()
20981 
 
20982 
  def write(self, oprot):
20983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20985 
      return
20986 
    oprot.writeStructBegin('refundTransaction_result')
20987 
    if self.ex is not None:
20988 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20989 
      self.ex.write(oprot)
20990 
      oprot.writeFieldEnd()
20991 
    oprot.writeFieldStop()
20992 
    oprot.writeStructEnd()
20993 
 
20994 
  def validate(self):
20995 
    return
20996 
 
20997 
 
20998 
  def __repr__(self):
20999 
    L = ['%s=%r' % (key, value)
21000 
      for key, value in self.__dict__.iteritems()]
21001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21002 
 
21003 
  def __eq__(self, other):
21004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21005 
 
21006 
  def __ne__(self, other):
21007 
    return not (self == other)
4285 rajveer 21008 
 
4324 mandeep.dh 21009 
class updateShipmentAddress_args:
21010 
  """
21011 
  Attributes:
21012 
   - orderId
21013 
   - addressId
21014 
  """
21015 
 
21016 
  thrift_spec = (
21017 
    None, # 0
21018 
    (1, TType.I64, 'orderId', None, None, ), # 1
21019 
    (2, TType.I64, 'addressId', None, None, ), # 2
21020 
  )
21021 
 
21022 
  def __init__(self, orderId=None, addressId=None,):
21023 
    self.orderId = orderId
21024 
    self.addressId = addressId
21025 
 
21026 
  def read(self, iprot):
21027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21029 
      return
21030 
    iprot.readStructBegin()
21031 
    while True:
21032 
      (fname, ftype, fid) = iprot.readFieldBegin()
21033 
      if ftype == TType.STOP:
21034 
        break
21035 
      if fid == 1:
21036 
        if ftype == TType.I64:
21037 
          self.orderId = iprot.readI64();
21038 
        else:
21039 
          iprot.skip(ftype)
21040 
      elif fid == 2:
21041 
        if ftype == TType.I64:
21042 
          self.addressId = iprot.readI64();
21043 
        else:
21044 
          iprot.skip(ftype)
21045 
      else:
21046 
        iprot.skip(ftype)
21047 
      iprot.readFieldEnd()
21048 
    iprot.readStructEnd()
21049 
 
21050 
  def write(self, oprot):
21051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21053 
      return
21054 
    oprot.writeStructBegin('updateShipmentAddress_args')
21055 
    if self.orderId is not None:
21056 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21057 
      oprot.writeI64(self.orderId)
21058 
      oprot.writeFieldEnd()
21059 
    if self.addressId is not None:
21060 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21061 
      oprot.writeI64(self.addressId)
21062 
      oprot.writeFieldEnd()
21063 
    oprot.writeFieldStop()
21064 
    oprot.writeStructEnd()
21065 
 
21066 
  def validate(self):
21067 
    return
21068 
 
21069 
 
21070 
  def __repr__(self):
21071 
    L = ['%s=%r' % (key, value)
21072 
      for key, value in self.__dict__.iteritems()]
21073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21074 
 
21075 
  def __eq__(self, other):
21076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21077 
 
21078 
  def __ne__(self, other):
21079 
    return not (self == other)
21080 
 
21081 
class updateShipmentAddress_result:
21082 
  """
21083 
  Attributes:
21084 
   - ex
21085 
  """
21086 
 
21087 
  thrift_spec = (
21088 
    None, # 0
21089 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21090 
  )
21091 
 
21092 
  def __init__(self, ex=None,):
21093 
    self.ex = ex
21094 
 
21095 
  def read(self, iprot):
21096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21098 
      return
21099 
    iprot.readStructBegin()
21100 
    while True:
21101 
      (fname, ftype, fid) = iprot.readFieldBegin()
21102 
      if ftype == TType.STOP:
21103 
        break
21104 
      if fid == 1:
21105 
        if ftype == TType.STRUCT:
21106 
          self.ex = TransactionServiceException()
21107 
          self.ex.read(iprot)
21108 
        else:
21109 
          iprot.skip(ftype)
21110 
      else:
21111 
        iprot.skip(ftype)
21112 
      iprot.readFieldEnd()
21113 
    iprot.readStructEnd()
21114 
 
21115 
  def write(self, oprot):
21116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21118 
      return
21119 
    oprot.writeStructBegin('updateShipmentAddress_result')
21120 
    if self.ex is not None:
21121 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21122 
      self.ex.write(oprot)
21123 
      oprot.writeFieldEnd()
21124 
    oprot.writeFieldStop()
21125 
    oprot.writeStructEnd()
21126 
 
21127 
  def validate(self):
21128 
    return
21129 
 
21130 
 
21131 
  def __repr__(self):
21132 
    L = ['%s=%r' % (key, value)
21133 
      for key, value in self.__dict__.iteritems()]
21134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21135 
 
21136 
  def __eq__(self, other):
21137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21138 
 
21139 
  def __ne__(self, other):
21140 
    return not (self == other)
21141 
 
4285 rajveer 21142 
class acceptOrdersForItemId_args:
21143 
  """
21144 
  Attributes:
21145 
   - itemId
21146 
   - inventory
21147 
  """
21148 
 
21149 
  thrift_spec = (
21150 
    None, # 0
21151 
    (1, TType.I64, 'itemId', None, None, ), # 1
21152 
    (2, TType.I64, 'inventory', None, None, ), # 2
21153 
  )
21154 
 
21155 
  def __init__(self, itemId=None, inventory=None,):
21156 
    self.itemId = itemId
21157 
    self.inventory = inventory
21158 
 
21159 
  def read(self, iprot):
21160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21162 
      return
21163 
    iprot.readStructBegin()
21164 
    while True:
21165 
      (fname, ftype, fid) = iprot.readFieldBegin()
21166 
      if ftype == TType.STOP:
21167 
        break
21168 
      if fid == 1:
21169 
        if ftype == TType.I64:
21170 
          self.itemId = iprot.readI64();
21171 
        else:
21172 
          iprot.skip(ftype)
21173 
      elif fid == 2:
21174 
        if ftype == TType.I64:
21175 
          self.inventory = iprot.readI64();
21176 
        else:
21177 
          iprot.skip(ftype)
21178 
      else:
21179 
        iprot.skip(ftype)
21180 
      iprot.readFieldEnd()
21181 
    iprot.readStructEnd()
21182 
 
21183 
  def write(self, oprot):
21184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21186 
      return
21187 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21188 
    if self.itemId is not None:
21189 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21190 
      oprot.writeI64(self.itemId)
21191 
      oprot.writeFieldEnd()
21192 
    if self.inventory is not None:
21193 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21194 
      oprot.writeI64(self.inventory)
21195 
      oprot.writeFieldEnd()
21196 
    oprot.writeFieldStop()
21197 
    oprot.writeStructEnd()
21198 
 
21199 
  def validate(self):
21200 
    return
21201 
 
21202 
 
21203 
  def __repr__(self):
21204 
    L = ['%s=%r' % (key, value)
21205 
      for key, value in self.__dict__.iteritems()]
21206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21207 
 
21208 
  def __eq__(self, other):
21209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21210 
 
21211 
  def __ne__(self, other):
21212 
    return not (self == other)
21213 
 
21214 
class acceptOrdersForItemId_result:
21215 
  """
21216 
  Attributes:
21217 
   - success
21218 
   - ex
21219 
  """
21220 
 
21221 
  thrift_spec = (
21222 
    (0, TType.BOOL, 'success', None, None, ), # 0
21223 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21224 
  )
21225 
 
21226 
  def __init__(self, success=None, ex=None,):
21227 
    self.success = success
21228 
    self.ex = ex
21229 
 
21230 
  def read(self, iprot):
21231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21233 
      return
21234 
    iprot.readStructBegin()
21235 
    while True:
21236 
      (fname, ftype, fid) = iprot.readFieldBegin()
21237 
      if ftype == TType.STOP:
21238 
        break
21239 
      if fid == 0:
21240 
        if ftype == TType.BOOL:
21241 
          self.success = iprot.readBool();
21242 
        else:
21243 
          iprot.skip(ftype)
21244 
      elif fid == 1:
21245 
        if ftype == TType.STRUCT:
21246 
          self.ex = TransactionServiceException()
21247 
          self.ex.read(iprot)
21248 
        else:
21249 
          iprot.skip(ftype)
21250 
      else:
21251 
        iprot.skip(ftype)
21252 
      iprot.readFieldEnd()
21253 
    iprot.readStructEnd()
21254 
 
21255 
  def write(self, oprot):
21256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21258 
      return
21259 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21260 
    if self.success is not None:
21261 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21262 
      oprot.writeBool(self.success)
21263 
      oprot.writeFieldEnd()
21264 
    if self.ex is not None:
21265 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21266 
      self.ex.write(oprot)
21267 
      oprot.writeFieldEnd()
21268 
    oprot.writeFieldStop()
21269 
    oprot.writeStructEnd()
21270 
 
21271 
  def validate(self):
21272 
    return
21273 
 
21274 
 
21275 
  def __repr__(self):
21276 
    L = ['%s=%r' % (key, value)
21277 
      for key, value in self.__dict__.iteritems()]
21278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21279 
 
21280 
  def __eq__(self, other):
21281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21282 
 
21283 
  def __ne__(self, other):
21284 
    return not (self == other)
4303 rajveer 21285 
 
21286 
class markOrdersAsPORaised_args:
21287 
  """
21288 
  Attributes:
21289 
   - vendorId
21290 
   - itemId
21291 
   - quantity
21292 
   - estimate
4369 rajveer 21293 
   - isReminder
4303 rajveer 21294 
  """
21295 
 
21296 
  thrift_spec = (
21297 
    None, # 0
21298 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21299 
    (2, TType.I64, 'itemId', None, None, ), # 2
21300 
    (3, TType.I64, 'quantity', None, None, ), # 3
21301 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21302 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21303 
  )
21304 
 
4369 rajveer 21305 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21306 
    self.vendorId = vendorId
21307 
    self.itemId = itemId
21308 
    self.quantity = quantity
21309 
    self.estimate = estimate
4369 rajveer 21310 
    self.isReminder = isReminder
4303 rajveer 21311 
 
21312 
  def read(self, iprot):
21313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21315 
      return
21316 
    iprot.readStructBegin()
21317 
    while True:
21318 
      (fname, ftype, fid) = iprot.readFieldBegin()
21319 
      if ftype == TType.STOP:
21320 
        break
21321 
      if fid == 1:
21322 
        if ftype == TType.I64:
21323 
          self.vendorId = iprot.readI64();
21324 
        else:
21325 
          iprot.skip(ftype)
21326 
      elif fid == 2:
21327 
        if ftype == TType.I64:
21328 
          self.itemId = iprot.readI64();
21329 
        else:
21330 
          iprot.skip(ftype)
21331 
      elif fid == 3:
21332 
        if ftype == TType.I64:
21333 
          self.quantity = iprot.readI64();
21334 
        else:
21335 
          iprot.skip(ftype)
21336 
      elif fid == 4:
21337 
        if ftype == TType.I64:
21338 
          self.estimate = iprot.readI64();
21339 
        else:
21340 
          iprot.skip(ftype)
4369 rajveer 21341 
      elif fid == 5:
21342 
        if ftype == TType.BOOL:
21343 
          self.isReminder = iprot.readBool();
21344 
        else:
21345 
          iprot.skip(ftype)
4303 rajveer 21346 
      else:
21347 
        iprot.skip(ftype)
21348 
      iprot.readFieldEnd()
21349 
    iprot.readStructEnd()
21350 
 
21351 
  def write(self, oprot):
21352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21354 
      return
21355 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21356 
    if self.vendorId is not None:
21357 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21358 
      oprot.writeI64(self.vendorId)
21359 
      oprot.writeFieldEnd()
21360 
    if self.itemId is not None:
21361 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21362 
      oprot.writeI64(self.itemId)
21363 
      oprot.writeFieldEnd()
21364 
    if self.quantity is not None:
21365 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21366 
      oprot.writeI64(self.quantity)
21367 
      oprot.writeFieldEnd()
21368 
    if self.estimate is not None:
21369 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21370 
      oprot.writeI64(self.estimate)
21371 
      oprot.writeFieldEnd()
4369 rajveer 21372 
    if self.isReminder is not None:
21373 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21374 
      oprot.writeBool(self.isReminder)
21375 
      oprot.writeFieldEnd()
4303 rajveer 21376 
    oprot.writeFieldStop()
21377 
    oprot.writeStructEnd()
21378 
 
21379 
  def validate(self):
21380 
    return
21381 
 
21382 
 
21383 
  def __repr__(self):
21384 
    L = ['%s=%r' % (key, value)
21385 
      for key, value in self.__dict__.iteritems()]
21386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21387 
 
21388 
  def __eq__(self, other):
21389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21390 
 
21391 
  def __ne__(self, other):
21392 
    return not (self == other)
21393 
 
21394 
class markOrdersAsPORaised_result:
21395 
  """
21396 
  Attributes:
21397 
   - ex
21398 
  """
21399 
 
21400 
  thrift_spec = (
21401 
    None, # 0
21402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21403 
  )
21404 
 
21405 
  def __init__(self, ex=None,):
21406 
    self.ex = ex
21407 
 
21408 
  def read(self, iprot):
21409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21411 
      return
21412 
    iprot.readStructBegin()
21413 
    while True:
21414 
      (fname, ftype, fid) = iprot.readFieldBegin()
21415 
      if ftype == TType.STOP:
21416 
        break
21417 
      if fid == 1:
21418 
        if ftype == TType.STRUCT:
21419 
          self.ex = TransactionServiceException()
21420 
          self.ex.read(iprot)
21421 
        else:
21422 
          iprot.skip(ftype)
21423 
      else:
21424 
        iprot.skip(ftype)
21425 
      iprot.readFieldEnd()
21426 
    iprot.readStructEnd()
21427 
 
21428 
  def write(self, oprot):
21429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21431 
      return
21432 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21433 
    if self.ex is not None:
21434 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21435 
      self.ex.write(oprot)
21436 
      oprot.writeFieldEnd()
21437 
    oprot.writeFieldStop()
21438 
    oprot.writeStructEnd()
21439 
 
21440 
  def validate(self):
21441 
    return
21442 
 
21443 
 
21444 
  def __repr__(self):
21445 
    L = ['%s=%r' % (key, value)
21446 
      for key, value in self.__dict__.iteritems()]
21447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21448 
 
21449 
  def __eq__(self, other):
21450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21451 
 
21452 
  def __ne__(self, other):
21453 
    return not (self == other)
21454 
 
21455 
class markOrdersAsReversalInitiated_args:
21456 
  """
21457 
  Attributes:
21458 
   - vendorId
21459 
   - itemId
21460 
   - quantity
21461 
   - estimate
4369 rajveer 21462 
   - isReminder
4303 rajveer 21463 
  """
21464 
 
21465 
  thrift_spec = (
21466 
    None, # 0
21467 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21468 
    (2, TType.I64, 'itemId', None, None, ), # 2
21469 
    (3, TType.I64, 'quantity', None, None, ), # 3
21470 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21471 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21472 
  )
21473 
 
4369 rajveer 21474 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21475 
    self.vendorId = vendorId
21476 
    self.itemId = itemId
21477 
    self.quantity = quantity
21478 
    self.estimate = estimate
4369 rajveer 21479 
    self.isReminder = isReminder
4303 rajveer 21480 
 
21481 
  def read(self, iprot):
21482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21484 
      return
21485 
    iprot.readStructBegin()
21486 
    while True:
21487 
      (fname, ftype, fid) = iprot.readFieldBegin()
21488 
      if ftype == TType.STOP:
21489 
        break
21490 
      if fid == 1:
21491 
        if ftype == TType.I64:
21492 
          self.vendorId = iprot.readI64();
21493 
        else:
21494 
          iprot.skip(ftype)
21495 
      elif fid == 2:
21496 
        if ftype == TType.I64:
21497 
          self.itemId = iprot.readI64();
21498 
        else:
21499 
          iprot.skip(ftype)
21500 
      elif fid == 3:
21501 
        if ftype == TType.I64:
21502 
          self.quantity = iprot.readI64();
21503 
        else:
21504 
          iprot.skip(ftype)
21505 
      elif fid == 4:
21506 
        if ftype == TType.I64:
21507 
          self.estimate = iprot.readI64();
21508 
        else:
21509 
          iprot.skip(ftype)
4369 rajveer 21510 
      elif fid == 5:
21511 
        if ftype == TType.BOOL:
21512 
          self.isReminder = iprot.readBool();
21513 
        else:
21514 
          iprot.skip(ftype)
4303 rajveer 21515 
      else:
21516 
        iprot.skip(ftype)
21517 
      iprot.readFieldEnd()
21518 
    iprot.readStructEnd()
21519 
 
21520 
  def write(self, oprot):
21521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21523 
      return
21524 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21525 
    if self.vendorId is not None:
21526 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21527 
      oprot.writeI64(self.vendorId)
21528 
      oprot.writeFieldEnd()
21529 
    if self.itemId is not None:
21530 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21531 
      oprot.writeI64(self.itemId)
21532 
      oprot.writeFieldEnd()
21533 
    if self.quantity is not None:
21534 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21535 
      oprot.writeI64(self.quantity)
21536 
      oprot.writeFieldEnd()
21537 
    if self.estimate is not None:
21538 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21539 
      oprot.writeI64(self.estimate)
21540 
      oprot.writeFieldEnd()
4369 rajveer 21541 
    if self.isReminder is not None:
21542 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21543 
      oprot.writeBool(self.isReminder)
21544 
      oprot.writeFieldEnd()
4303 rajveer 21545 
    oprot.writeFieldStop()
21546 
    oprot.writeStructEnd()
21547 
 
21548 
  def validate(self):
21549 
    return
21550 
 
21551 
 
21552 
  def __repr__(self):
21553 
    L = ['%s=%r' % (key, value)
21554 
      for key, value in self.__dict__.iteritems()]
21555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21556 
 
21557 
  def __eq__(self, other):
21558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21559 
 
21560 
  def __ne__(self, other):
21561 
    return not (self == other)
21562 
 
21563 
class markOrdersAsReversalInitiated_result:
21564 
  """
21565 
  Attributes:
21566 
   - ex
21567 
  """
21568 
 
21569 
  thrift_spec = (
21570 
    None, # 0
21571 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21572 
  )
21573 
 
21574 
  def __init__(self, ex=None,):
21575 
    self.ex = ex
21576 
 
21577 
  def read(self, iprot):
21578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21580 
      return
21581 
    iprot.readStructBegin()
21582 
    while True:
21583 
      (fname, ftype, fid) = iprot.readFieldBegin()
21584 
      if ftype == TType.STOP:
21585 
        break
21586 
      if fid == 1:
21587 
        if ftype == TType.STRUCT:
21588 
          self.ex = TransactionServiceException()
21589 
          self.ex.read(iprot)
21590 
        else:
21591 
          iprot.skip(ftype)
21592 
      else:
21593 
        iprot.skip(ftype)
21594 
      iprot.readFieldEnd()
21595 
    iprot.readStructEnd()
21596 
 
21597 
  def write(self, oprot):
21598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21600 
      return
21601 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21602 
    if self.ex is not None:
21603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21604 
      self.ex.write(oprot)
21605 
      oprot.writeFieldEnd()
21606 
    oprot.writeFieldStop()
21607 
    oprot.writeStructEnd()
21608 
 
21609 
  def validate(self):
21610 
    return
21611 
 
21612 
 
21613 
  def __repr__(self):
21614 
    L = ['%s=%r' % (key, value)
21615 
      for key, value in self.__dict__.iteritems()]
21616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21617 
 
21618 
  def __eq__(self, other):
21619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21620 
 
21621 
  def __ne__(self, other):
21622 
    return not (self == other)
21623 
 
21624 
class markOrdersAsNotAvailabke_args:
21625 
  """
21626 
  Attributes:
21627 
   - vendorId
21628 
   - itemId
21629 
   - quantity
21630 
   - estimate
4369 rajveer 21631 
   - isReminder
4303 rajveer 21632 
  """
21633 
 
21634 
  thrift_spec = (
21635 
    None, # 0
21636 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21637 
    (2, TType.I64, 'itemId', None, None, ), # 2
21638 
    (3, TType.I64, 'quantity', None, None, ), # 3
21639 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21640 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21641 
  )
21642 
 
4369 rajveer 21643 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21644 
    self.vendorId = vendorId
21645 
    self.itemId = itemId
21646 
    self.quantity = quantity
21647 
    self.estimate = estimate
4369 rajveer 21648 
    self.isReminder = isReminder
4303 rajveer 21649 
 
21650 
  def read(self, iprot):
21651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21653 
      return
21654 
    iprot.readStructBegin()
21655 
    while True:
21656 
      (fname, ftype, fid) = iprot.readFieldBegin()
21657 
      if ftype == TType.STOP:
21658 
        break
21659 
      if fid == 1:
21660 
        if ftype == TType.I64:
21661 
          self.vendorId = iprot.readI64();
21662 
        else:
21663 
          iprot.skip(ftype)
21664 
      elif fid == 2:
21665 
        if ftype == TType.I64:
21666 
          self.itemId = iprot.readI64();
21667 
        else:
21668 
          iprot.skip(ftype)
21669 
      elif fid == 3:
21670 
        if ftype == TType.I64:
21671 
          self.quantity = iprot.readI64();
21672 
        else:
21673 
          iprot.skip(ftype)
21674 
      elif fid == 4:
21675 
        if ftype == TType.I64:
21676 
          self.estimate = iprot.readI64();
21677 
        else:
21678 
          iprot.skip(ftype)
4369 rajveer 21679 
      elif fid == 5:
21680 
        if ftype == TType.BOOL:
21681 
          self.isReminder = iprot.readBool();
21682 
        else:
21683 
          iprot.skip(ftype)
4303 rajveer 21684 
      else:
21685 
        iprot.skip(ftype)
21686 
      iprot.readFieldEnd()
21687 
    iprot.readStructEnd()
21688 
 
21689 
  def write(self, oprot):
21690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21692 
      return
21693 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21694 
    if self.vendorId is not None:
21695 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21696 
      oprot.writeI64(self.vendorId)
21697 
      oprot.writeFieldEnd()
21698 
    if self.itemId is not None:
21699 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21700 
      oprot.writeI64(self.itemId)
21701 
      oprot.writeFieldEnd()
21702 
    if self.quantity is not None:
21703 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21704 
      oprot.writeI64(self.quantity)
21705 
      oprot.writeFieldEnd()
21706 
    if self.estimate is not None:
21707 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21708 
      oprot.writeI64(self.estimate)
21709 
      oprot.writeFieldEnd()
4369 rajveer 21710 
    if self.isReminder is not None:
21711 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21712 
      oprot.writeBool(self.isReminder)
21713 
      oprot.writeFieldEnd()
4303 rajveer 21714 
    oprot.writeFieldStop()
21715 
    oprot.writeStructEnd()
21716 
 
21717 
  def validate(self):
21718 
    return
21719 
 
21720 
 
21721 
  def __repr__(self):
21722 
    L = ['%s=%r' % (key, value)
21723 
      for key, value in self.__dict__.iteritems()]
21724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21725 
 
21726 
  def __eq__(self, other):
21727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21728 
 
21729 
  def __ne__(self, other):
21730 
    return not (self == other)
21731 
 
21732 
class markOrdersAsNotAvailabke_result:
21733 
  """
21734 
  Attributes:
21735 
   - ex
21736 
  """
21737 
 
21738 
  thrift_spec = (
21739 
    None, # 0
21740 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21741 
  )
21742 
 
21743 
  def __init__(self, ex=None,):
21744 
    self.ex = ex
21745 
 
21746 
  def read(self, iprot):
21747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21749 
      return
21750 
    iprot.readStructBegin()
21751 
    while True:
21752 
      (fname, ftype, fid) = iprot.readFieldBegin()
21753 
      if ftype == TType.STOP:
21754 
        break
21755 
      if fid == 1:
21756 
        if ftype == TType.STRUCT:
21757 
          self.ex = TransactionServiceException()
21758 
          self.ex.read(iprot)
21759 
        else:
21760 
          iprot.skip(ftype)
21761 
      else:
21762 
        iprot.skip(ftype)
21763 
      iprot.readFieldEnd()
21764 
    iprot.readStructEnd()
21765 
 
21766 
  def write(self, oprot):
21767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21769 
      return
21770 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21771 
    if self.ex is not None:
21772 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21773 
      self.ex.write(oprot)
21774 
      oprot.writeFieldEnd()
21775 
    oprot.writeFieldStop()
21776 
    oprot.writeStructEnd()
21777 
 
21778 
  def validate(self):
21779 
    return
21780 
 
21781 
 
21782 
  def __repr__(self):
21783 
    L = ['%s=%r' % (key, value)
21784 
      for key, value in self.__dict__.iteritems()]
21785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21786 
 
21787 
  def __eq__(self, other):
21788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21789 
 
21790 
  def __ne__(self, other):
21791 
    return not (self == other)
4369 rajveer 21792 
 
21793 
class markOrdersAsTimeout_args:
21794 
  """
21795 
  Attributes:
21796 
   - vendorId
21797 
  """
21798 
 
21799 
  thrift_spec = (
21800 
    None, # 0
21801 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21802 
  )
21803 
 
21804 
  def __init__(self, vendorId=None,):
21805 
    self.vendorId = vendorId
21806 
 
21807 
  def read(self, iprot):
21808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21810 
      return
21811 
    iprot.readStructBegin()
21812 
    while True:
21813 
      (fname, ftype, fid) = iprot.readFieldBegin()
21814 
      if ftype == TType.STOP:
21815 
        break
21816 
      if fid == 1:
21817 
        if ftype == TType.I64:
21818 
          self.vendorId = iprot.readI64();
21819 
        else:
21820 
          iprot.skip(ftype)
21821 
      else:
21822 
        iprot.skip(ftype)
21823 
      iprot.readFieldEnd()
21824 
    iprot.readStructEnd()
21825 
 
21826 
  def write(self, oprot):
21827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21829 
      return
21830 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21831 
    if self.vendorId is not None:
21832 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21833 
      oprot.writeI64(self.vendorId)
21834 
      oprot.writeFieldEnd()
21835 
    oprot.writeFieldStop()
21836 
    oprot.writeStructEnd()
21837 
 
21838 
  def validate(self):
21839 
    return
21840 
 
21841 
 
21842 
  def __repr__(self):
21843 
    L = ['%s=%r' % (key, value)
21844 
      for key, value in self.__dict__.iteritems()]
21845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21846 
 
21847 
  def __eq__(self, other):
21848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21849 
 
21850 
  def __ne__(self, other):
21851 
    return not (self == other)
21852 
 
21853 
class markOrdersAsTimeout_result:
21854 
  """
21855 
  Attributes:
21856 
   - success
21857 
   - ex
21858 
  """
21859 
 
21860 
  thrift_spec = (
21861 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21863 
  )
21864 
 
21865 
  def __init__(self, success=None, ex=None,):
21866 
    self.success = success
21867 
    self.ex = ex
21868 
 
21869 
  def read(self, iprot):
21870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21872 
      return
21873 
    iprot.readStructBegin()
21874 
    while True:
21875 
      (fname, ftype, fid) = iprot.readFieldBegin()
21876 
      if ftype == TType.STOP:
21877 
        break
21878 
      if fid == 0:
21879 
        if ftype == TType.MAP:
21880 
          self.success = {}
6188 rajveer 21881 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21882 
          for _i505 in xrange(_size501):
21883 
            _key506 = iprot.readI32();
21884 
            _val507 = TimeoutSummary()
21885 
            _val507.read(iprot)
21886 
            self.success[_key506] = _val507
4369 rajveer 21887 
          iprot.readMapEnd()
21888 
        else:
21889 
          iprot.skip(ftype)
21890 
      elif fid == 1:
21891 
        if ftype == TType.STRUCT:
21892 
          self.ex = TransactionServiceException()
21893 
          self.ex.read(iprot)
21894 
        else:
21895 
          iprot.skip(ftype)
21896 
      else:
21897 
        iprot.skip(ftype)
21898 
      iprot.readFieldEnd()
21899 
    iprot.readStructEnd()
21900 
 
21901 
  def write(self, oprot):
21902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21904 
      return
21905 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21906 
    if self.success is not None:
21907 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21908 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21909 
      for kiter508,viter509 in self.success.items():
21910 
        oprot.writeI32(kiter508)
21911 
        viter509.write(oprot)
4369 rajveer 21912 
      oprot.writeMapEnd()
21913 
      oprot.writeFieldEnd()
21914 
    if self.ex is not None:
21915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21916 
      self.ex.write(oprot)
21917 
      oprot.writeFieldEnd()
21918 
    oprot.writeFieldStop()
21919 
    oprot.writeStructEnd()
21920 
 
21921 
  def validate(self):
21922 
    return
21923 
 
21924 
 
21925 
  def __repr__(self):
21926 
    L = ['%s=%r' % (key, value)
21927 
      for key, value in self.__dict__.iteritems()]
21928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21929 
 
21930 
  def __eq__(self, other):
21931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21932 
 
21933 
  def __ne__(self, other):
21934 
    return not (self == other)
4386 anupam.sin 21935 
 
4662 rajveer 21936 
class markOrderAsLostInTransit_args:
21937 
  """
21938 
  Attributes:
21939 
   - orderId
21940 
  """
21941 
 
21942 
  thrift_spec = (
21943 
    None, # 0
21944 
    (1, TType.I64, 'orderId', None, None, ), # 1
21945 
  )
21946 
 
21947 
  def __init__(self, orderId=None,):
21948 
    self.orderId = orderId
21949 
 
21950 
  def read(self, iprot):
21951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21953 
      return
21954 
    iprot.readStructBegin()
21955 
    while True:
21956 
      (fname, ftype, fid) = iprot.readFieldBegin()
21957 
      if ftype == TType.STOP:
21958 
        break
21959 
      if fid == 1:
21960 
        if ftype == TType.I64:
21961 
          self.orderId = iprot.readI64();
21962 
        else:
21963 
          iprot.skip(ftype)
21964 
      else:
21965 
        iprot.skip(ftype)
21966 
      iprot.readFieldEnd()
21967 
    iprot.readStructEnd()
21968 
 
21969 
  def write(self, oprot):
21970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21972 
      return
21973 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21974 
    if self.orderId is not None:
21975 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21976 
      oprot.writeI64(self.orderId)
21977 
      oprot.writeFieldEnd()
21978 
    oprot.writeFieldStop()
21979 
    oprot.writeStructEnd()
21980 
 
21981 
  def validate(self):
21982 
    return
21983 
 
21984 
 
21985 
  def __repr__(self):
21986 
    L = ['%s=%r' % (key, value)
21987 
      for key, value in self.__dict__.iteritems()]
21988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21989 
 
21990 
  def __eq__(self, other):
21991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21992 
 
21993 
  def __ne__(self, other):
21994 
    return not (self == other)
21995 
 
21996 
class markOrderAsLostInTransit_result:
21997 
  """
21998 
  Attributes:
21999 
   - success
22000 
   - ex
22001 
  """
22002 
 
22003 
  thrift_spec = (
22004 
    (0, TType.BOOL, 'success', None, None, ), # 0
22005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22006 
  )
22007 
 
22008 
  def __init__(self, success=None, ex=None,):
22009 
    self.success = success
22010 
    self.ex = ex
22011 
 
22012 
  def read(self, iprot):
22013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22015 
      return
22016 
    iprot.readStructBegin()
22017 
    while True:
22018 
      (fname, ftype, fid) = iprot.readFieldBegin()
22019 
      if ftype == TType.STOP:
22020 
        break
22021 
      if fid == 0:
22022 
        if ftype == TType.BOOL:
22023 
          self.success = iprot.readBool();
22024 
        else:
22025 
          iprot.skip(ftype)
22026 
      elif fid == 1:
22027 
        if ftype == TType.STRUCT:
22028 
          self.ex = TransactionServiceException()
22029 
          self.ex.read(iprot)
22030 
        else:
22031 
          iprot.skip(ftype)
22032 
      else:
22033 
        iprot.skip(ftype)
22034 
      iprot.readFieldEnd()
22035 
    iprot.readStructEnd()
22036 
 
22037 
  def write(self, oprot):
22038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22040 
      return
22041 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22042 
    if self.success is not None:
22043 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22044 
      oprot.writeBool(self.success)
22045 
      oprot.writeFieldEnd()
22046 
    if self.ex is not None:
22047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22048 
      self.ex.write(oprot)
22049 
      oprot.writeFieldEnd()
22050 
    oprot.writeFieldStop()
22051 
    oprot.writeStructEnd()
22052 
 
22053 
  def validate(self):
22054 
    return
22055 
 
22056 
 
22057 
  def __repr__(self):
22058 
    L = ['%s=%r' % (key, value)
22059 
      for key, value in self.__dict__.iteritems()]
22060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22061 
 
22062 
  def __eq__(self, other):
22063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22064 
 
22065 
  def __ne__(self, other):
22066 
    return not (self == other)
22067 
 
4386 anupam.sin 22068 
class getOrderForAwb_args:
22069 
  """
22070 
  Attributes:
22071 
   - awb
22072 
  """
22073 
 
22074 
  thrift_spec = (
22075 
    None, # 0
22076 
    (1, TType.STRING, 'awb', None, None, ), # 1
22077 
  )
22078 
 
22079 
  def __init__(self, awb=None,):
22080 
    self.awb = awb
22081 
 
22082 
  def read(self, iprot):
22083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22085 
      return
22086 
    iprot.readStructBegin()
22087 
    while True:
22088 
      (fname, ftype, fid) = iprot.readFieldBegin()
22089 
      if ftype == TType.STOP:
22090 
        break
22091 
      if fid == 1:
22092 
        if ftype == TType.STRING:
22093 
          self.awb = iprot.readString();
22094 
        else:
22095 
          iprot.skip(ftype)
22096 
      else:
22097 
        iprot.skip(ftype)
22098 
      iprot.readFieldEnd()
22099 
    iprot.readStructEnd()
22100 
 
22101 
  def write(self, oprot):
22102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22104 
      return
22105 
    oprot.writeStructBegin('getOrderForAwb_args')
22106 
    if self.awb is not None:
22107 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22108 
      oprot.writeString(self.awb)
22109 
      oprot.writeFieldEnd()
22110 
    oprot.writeFieldStop()
22111 
    oprot.writeStructEnd()
22112 
 
22113 
  def validate(self):
22114 
    return
22115 
 
22116 
 
22117 
  def __repr__(self):
22118 
    L = ['%s=%r' % (key, value)
22119 
      for key, value in self.__dict__.iteritems()]
22120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22121 
 
22122 
  def __eq__(self, other):
22123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22124 
 
22125 
  def __ne__(self, other):
22126 
    return not (self == other)
22127 
 
22128 
class getOrderForAwb_result:
22129 
  """
22130 
  Attributes:
22131 
   - success
22132 
   - ex
22133 
  """
22134 
 
22135 
  thrift_spec = (
22136 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22137 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22138 
  )
22139 
 
22140 
  def __init__(self, success=None, ex=None,):
22141 
    self.success = success
22142 
    self.ex = ex
22143 
 
22144 
  def read(self, iprot):
22145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22147 
      return
22148 
    iprot.readStructBegin()
22149 
    while True:
22150 
      (fname, ftype, fid) = iprot.readFieldBegin()
22151 
      if ftype == TType.STOP:
22152 
        break
22153 
      if fid == 0:
22154 
        if ftype == TType.STRUCT:
22155 
          self.success = Order()
22156 
          self.success.read(iprot)
22157 
        else:
22158 
          iprot.skip(ftype)
22159 
      elif fid == 1:
22160 
        if ftype == TType.STRUCT:
22161 
          self.ex = TransactionServiceException()
22162 
          self.ex.read(iprot)
22163 
        else:
22164 
          iprot.skip(ftype)
22165 
      else:
22166 
        iprot.skip(ftype)
22167 
      iprot.readFieldEnd()
22168 
    iprot.readStructEnd()
22169 
 
22170 
  def write(self, oprot):
22171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22173 
      return
22174 
    oprot.writeStructBegin('getOrderForAwb_result')
22175 
    if self.success is not None:
22176 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22177 
      self.success.write(oprot)
22178 
      oprot.writeFieldEnd()
22179 
    if self.ex is not None:
22180 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22181 
      self.ex.write(oprot)
22182 
      oprot.writeFieldEnd()
22183 
    oprot.writeFieldStop()
22184 
    oprot.writeStructEnd()
22185 
 
22186 
  def validate(self):
22187 
    return
22188 
 
22189 
 
22190 
  def __repr__(self):
22191 
    L = ['%s=%r' % (key, value)
22192 
      for key, value in self.__dict__.iteritems()]
22193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22194 
 
22195 
  def __eq__(self, other):
22196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22197 
 
22198 
  def __ne__(self, other):
22199 
    return not (self == other)
4506 phani.kuma 22200 
 
22201 
class getOrdersForProviderForStatus_args:
22202 
  """
22203 
  Attributes:
22204 
   - logistics_provider_id
4910 phani.kuma 22205 
   - order_status_list
4506 phani.kuma 22206 
  """
22207 
 
22208 
  thrift_spec = (
22209 
    None, # 0
22210 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22211 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22212 
  )
22213 
 
4910 phani.kuma 22214 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22215 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22216 
    self.order_status_list = order_status_list
4506 phani.kuma 22217 
 
22218 
  def read(self, iprot):
22219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22221 
      return
22222 
    iprot.readStructBegin()
22223 
    while True:
22224 
      (fname, ftype, fid) = iprot.readFieldBegin()
22225 
      if ftype == TType.STOP:
22226 
        break
22227 
      if fid == 1:
22228 
        if ftype == TType.I64:
22229 
          self.logistics_provider_id = iprot.readI64();
22230 
        else:
22231 
          iprot.skip(ftype)
22232 
      elif fid == 2:
4910 phani.kuma 22233 
        if ftype == TType.LIST:
22234 
          self.order_status_list = []
6188 rajveer 22235 
          (_etype513, _size510) = iprot.readListBegin()
22236 
          for _i514 in xrange(_size510):
22237 
            _elem515 = iprot.readI32();
22238 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22239 
          iprot.readListEnd()
4506 phani.kuma 22240 
        else:
22241 
          iprot.skip(ftype)
22242 
      else:
22243 
        iprot.skip(ftype)
22244 
      iprot.readFieldEnd()
22245 
    iprot.readStructEnd()
22246 
 
22247 
  def write(self, oprot):
22248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22250 
      return
22251 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22252 
    if self.logistics_provider_id is not None:
22253 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22254 
      oprot.writeI64(self.logistics_provider_id)
22255 
      oprot.writeFieldEnd()
4910 phani.kuma 22256 
    if self.order_status_list is not None:
22257 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22258 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22259 
      for iter516 in self.order_status_list:
22260 
        oprot.writeI32(iter516)
4910 phani.kuma 22261 
      oprot.writeListEnd()
4506 phani.kuma 22262 
      oprot.writeFieldEnd()
22263 
    oprot.writeFieldStop()
22264 
    oprot.writeStructEnd()
22265 
 
22266 
  def validate(self):
22267 
    return
22268 
 
22269 
 
22270 
  def __repr__(self):
22271 
    L = ['%s=%r' % (key, value)
22272 
      for key, value in self.__dict__.iteritems()]
22273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22274 
 
22275 
  def __eq__(self, other):
22276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22277 
 
22278 
  def __ne__(self, other):
22279 
    return not (self == other)
22280 
 
22281 
class getOrdersForProviderForStatus_result:
22282 
  """
22283 
  Attributes:
22284 
   - success
22285 
   - ex
22286 
  """
22287 
 
22288 
  thrift_spec = (
22289 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22291 
  )
22292 
 
22293 
  def __init__(self, success=None, ex=None,):
22294 
    self.success = success
22295 
    self.ex = ex
22296 
 
22297 
  def read(self, iprot):
22298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22300 
      return
22301 
    iprot.readStructBegin()
22302 
    while True:
22303 
      (fname, ftype, fid) = iprot.readFieldBegin()
22304 
      if ftype == TType.STOP:
22305 
        break
22306 
      if fid == 0:
22307 
        if ftype == TType.LIST:
22308 
          self.success = []
6188 rajveer 22309 
          (_etype520, _size517) = iprot.readListBegin()
22310 
          for _i521 in xrange(_size517):
22311 
            _elem522 = Order()
22312 
            _elem522.read(iprot)
22313 
            self.success.append(_elem522)
4506 phani.kuma 22314 
          iprot.readListEnd()
22315 
        else:
22316 
          iprot.skip(ftype)
22317 
      elif fid == 1:
22318 
        if ftype == TType.STRUCT:
22319 
          self.ex = TransactionServiceException()
22320 
          self.ex.read(iprot)
22321 
        else:
22322 
          iprot.skip(ftype)
22323 
      else:
22324 
        iprot.skip(ftype)
22325 
      iprot.readFieldEnd()
22326 
    iprot.readStructEnd()
22327 
 
22328 
  def write(self, oprot):
22329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22331 
      return
22332 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22333 
    if self.success is not None:
22334 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22335 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22336 
      for iter523 in self.success:
22337 
        iter523.write(oprot)
4506 phani.kuma 22338 
      oprot.writeListEnd()
22339 
      oprot.writeFieldEnd()
22340 
    if self.ex is not None:
22341 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22342 
      self.ex.write(oprot)
22343 
      oprot.writeFieldEnd()
22344 
    oprot.writeFieldStop()
22345 
    oprot.writeStructEnd()
22346 
 
22347 
  def validate(self):
22348 
    return
22349 
 
22350 
 
22351 
  def __repr__(self):
22352 
    L = ['%s=%r' % (key, value)
22353 
      for key, value in self.__dict__.iteritems()]
22354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22355 
 
22356 
  def __eq__(self, other):
22357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22358 
 
22359 
  def __ne__(self, other):
22360 
    return not (self == other)
4600 varun.gupt 22361 
 
22362 
class getBilledOrdersForVendor_args:
22363 
  """
22364 
  Attributes:
22365 
   - vendorId
22366 
   - billingDateFrom
22367 
   - billingDateTo
22368 
  """
22369 
 
22370 
  thrift_spec = (
22371 
    None, # 0
22372 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22373 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22374 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22375 
  )
22376 
 
22377 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22378 
    self.vendorId = vendorId
22379 
    self.billingDateFrom = billingDateFrom
22380 
    self.billingDateTo = billingDateTo
22381 
 
22382 
  def read(self, iprot):
22383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22385 
      return
22386 
    iprot.readStructBegin()
22387 
    while True:
22388 
      (fname, ftype, fid) = iprot.readFieldBegin()
22389 
      if ftype == TType.STOP:
22390 
        break
22391 
      if fid == 1:
22392 
        if ftype == TType.I64:
22393 
          self.vendorId = iprot.readI64();
22394 
        else:
22395 
          iprot.skip(ftype)
22396 
      elif fid == 2:
22397 
        if ftype == TType.I64:
22398 
          self.billingDateFrom = iprot.readI64();
22399 
        else:
22400 
          iprot.skip(ftype)
22401 
      elif fid == 3:
22402 
        if ftype == TType.I64:
22403 
          self.billingDateTo = iprot.readI64();
22404 
        else:
22405 
          iprot.skip(ftype)
22406 
      else:
22407 
        iprot.skip(ftype)
22408 
      iprot.readFieldEnd()
22409 
    iprot.readStructEnd()
22410 
 
22411 
  def write(self, oprot):
22412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22414 
      return
22415 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22416 
    if self.vendorId is not None:
22417 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22418 
      oprot.writeI64(self.vendorId)
22419 
      oprot.writeFieldEnd()
22420 
    if self.billingDateFrom is not None:
22421 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22422 
      oprot.writeI64(self.billingDateFrom)
22423 
      oprot.writeFieldEnd()
22424 
    if self.billingDateTo is not None:
22425 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22426 
      oprot.writeI64(self.billingDateTo)
22427 
      oprot.writeFieldEnd()
22428 
    oprot.writeFieldStop()
22429 
    oprot.writeStructEnd()
22430 
 
22431 
  def validate(self):
22432 
    return
22433 
 
22434 
 
22435 
  def __repr__(self):
22436 
    L = ['%s=%r' % (key, value)
22437 
      for key, value in self.__dict__.iteritems()]
22438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22439 
 
22440 
  def __eq__(self, other):
22441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22442 
 
22443 
  def __ne__(self, other):
22444 
    return not (self == other)
22445 
 
22446 
class getBilledOrdersForVendor_result:
22447 
  """
22448 
  Attributes:
22449 
   - success
22450 
   - ex
22451 
  """
22452 
 
22453 
  thrift_spec = (
22454 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22456 
  )
22457 
 
22458 
  def __init__(self, success=None, ex=None,):
22459 
    self.success = success
22460 
    self.ex = ex
22461 
 
22462 
  def read(self, iprot):
22463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22465 
      return
22466 
    iprot.readStructBegin()
22467 
    while True:
22468 
      (fname, ftype, fid) = iprot.readFieldBegin()
22469 
      if ftype == TType.STOP:
22470 
        break
22471 
      if fid == 0:
22472 
        if ftype == TType.LIST:
22473 
          self.success = []
6188 rajveer 22474 
          (_etype527, _size524) = iprot.readListBegin()
22475 
          for _i528 in xrange(_size524):
22476 
            _elem529 = Order()
22477 
            _elem529.read(iprot)
22478 
            self.success.append(_elem529)
4600 varun.gupt 22479 
          iprot.readListEnd()
22480 
        else:
22481 
          iprot.skip(ftype)
22482 
      elif fid == 1:
22483 
        if ftype == TType.STRUCT:
22484 
          self.ex = TransactionServiceException()
22485 
          self.ex.read(iprot)
22486 
        else:
22487 
          iprot.skip(ftype)
22488 
      else:
22489 
        iprot.skip(ftype)
22490 
      iprot.readFieldEnd()
22491 
    iprot.readStructEnd()
22492 
 
22493 
  def write(self, oprot):
22494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22496 
      return
22497 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22498 
    if self.success is not None:
22499 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22500 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22501 
      for iter530 in self.success:
22502 
        iter530.write(oprot)
4600 varun.gupt 22503 
      oprot.writeListEnd()
22504 
      oprot.writeFieldEnd()
22505 
    if self.ex is not None:
22506 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22507 
      self.ex.write(oprot)
22508 
      oprot.writeFieldEnd()
22509 
    oprot.writeFieldStop()
22510 
    oprot.writeStructEnd()
22511 
 
22512 
  def validate(self):
22513 
    return
22514 
 
22515 
 
22516 
  def __repr__(self):
22517 
    L = ['%s=%r' % (key, value)
22518 
      for key, value in self.__dict__.iteritems()]
22519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22520 
 
22521 
  def __eq__(self, other):
22522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22523 
 
22524 
  def __ne__(self, other):
22525 
    return not (self == other)
22526 
 
4607 rajveer 22527 
class getSlippedSippingDateOrders_args:
22528 
 
22529 
  thrift_spec = (
22530 
  )
22531 
 
22532 
  def read(self, iprot):
22533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22535 
      return
22536 
    iprot.readStructBegin()
22537 
    while True:
22538 
      (fname, ftype, fid) = iprot.readFieldBegin()
22539 
      if ftype == TType.STOP:
22540 
        break
22541 
      else:
22542 
        iprot.skip(ftype)
22543 
      iprot.readFieldEnd()
22544 
    iprot.readStructEnd()
22545 
 
22546 
  def write(self, oprot):
22547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22549 
      return
22550 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22551 
    oprot.writeFieldStop()
22552 
    oprot.writeStructEnd()
22553 
 
22554 
  def validate(self):
22555 
    return
22556 
 
22557 
 
22558 
  def __repr__(self):
22559 
    L = ['%s=%r' % (key, value)
22560 
      for key, value in self.__dict__.iteritems()]
22561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22562 
 
22563 
  def __eq__(self, other):
22564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22565 
 
22566 
  def __ne__(self, other):
22567 
    return not (self == other)
22568 
 
22569 
class getSlippedSippingDateOrders_result:
22570 
  """
22571 
  Attributes:
22572 
   - success
22573 
   - ex
22574 
  """
22575 
 
22576 
  thrift_spec = (
22577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22579 
  )
22580 
 
22581 
  def __init__(self, success=None, ex=None,):
22582 
    self.success = success
22583 
    self.ex = ex
22584 
 
22585 
  def read(self, iprot):
22586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22588 
      return
22589 
    iprot.readStructBegin()
22590 
    while True:
22591 
      (fname, ftype, fid) = iprot.readFieldBegin()
22592 
      if ftype == TType.STOP:
22593 
        break
22594 
      if fid == 0:
22595 
        if ftype == TType.LIST:
22596 
          self.success = []
6188 rajveer 22597 
          (_etype534, _size531) = iprot.readListBegin()
22598 
          for _i535 in xrange(_size531):
22599 
            _elem536 = Order()
22600 
            _elem536.read(iprot)
22601 
            self.success.append(_elem536)
4607 rajveer 22602 
          iprot.readListEnd()
22603 
        else:
22604 
          iprot.skip(ftype)
22605 
      elif fid == 1:
22606 
        if ftype == TType.STRUCT:
22607 
          self.ex = TransactionServiceException()
22608 
          self.ex.read(iprot)
22609 
        else:
22610 
          iprot.skip(ftype)
22611 
      else:
22612 
        iprot.skip(ftype)
22613 
      iprot.readFieldEnd()
22614 
    iprot.readStructEnd()
22615 
 
22616 
  def write(self, oprot):
22617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22619 
      return
22620 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22621 
    if self.success is not None:
22622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22624 
      for iter537 in self.success:
22625 
        iter537.write(oprot)
4607 rajveer 22626 
      oprot.writeListEnd()
22627 
      oprot.writeFieldEnd()
22628 
    if self.ex is not None:
22629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22630 
      self.ex.write(oprot)
22631 
      oprot.writeFieldEnd()
22632 
    oprot.writeFieldStop()
22633 
    oprot.writeStructEnd()
22634 
 
22635 
  def validate(self):
22636 
    return
22637 
 
22638 
 
22639 
  def __repr__(self):
22640 
    L = ['%s=%r' % (key, value)
22641 
      for key, value in self.__dict__.iteritems()]
22642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22643 
 
22644 
  def __eq__(self, other):
22645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22646 
 
22647 
  def __ne__(self, other):
22648 
    return not (self == other)
22649 
 
4709 rajveer 22650 
class getCancelledOrders_args:
22651 
  """
22652 
  Attributes:
22653 
   - cancelDateFrom
22654 
   - cancelDateTo
22655 
  """
22656 
 
22657 
  thrift_spec = (
22658 
    None, # 0
22659 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22660 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22661 
  )
22662 
 
22663 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22664 
    self.cancelDateFrom = cancelDateFrom
22665 
    self.cancelDateTo = cancelDateTo
22666 
 
22667 
  def read(self, iprot):
22668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22670 
      return
22671 
    iprot.readStructBegin()
22672 
    while True:
22673 
      (fname, ftype, fid) = iprot.readFieldBegin()
22674 
      if ftype == TType.STOP:
22675 
        break
22676 
      if fid == 1:
22677 
        if ftype == TType.I64:
22678 
          self.cancelDateFrom = iprot.readI64();
22679 
        else:
22680 
          iprot.skip(ftype)
22681 
      elif fid == 2:
22682 
        if ftype == TType.I64:
22683 
          self.cancelDateTo = iprot.readI64();
22684 
        else:
22685 
          iprot.skip(ftype)
22686 
      else:
22687 
        iprot.skip(ftype)
22688 
      iprot.readFieldEnd()
22689 
    iprot.readStructEnd()
22690 
 
22691 
  def write(self, oprot):
22692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22694 
      return
22695 
    oprot.writeStructBegin('getCancelledOrders_args')
22696 
    if self.cancelDateFrom is not None:
22697 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22698 
      oprot.writeI64(self.cancelDateFrom)
22699 
      oprot.writeFieldEnd()
22700 
    if self.cancelDateTo is not None:
22701 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22702 
      oprot.writeI64(self.cancelDateTo)
22703 
      oprot.writeFieldEnd()
22704 
    oprot.writeFieldStop()
22705 
    oprot.writeStructEnd()
22706 
 
22707 
  def validate(self):
22708 
    return
22709 
 
22710 
 
22711 
  def __repr__(self):
22712 
    L = ['%s=%r' % (key, value)
22713 
      for key, value in self.__dict__.iteritems()]
22714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22715 
 
22716 
  def __eq__(self, other):
22717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22718 
 
22719 
  def __ne__(self, other):
22720 
    return not (self == other)
22721 
 
22722 
class getCancelledOrders_result:
22723 
  """
22724 
  Attributes:
22725 
   - success
22726 
   - ex
22727 
  """
22728 
 
22729 
  thrift_spec = (
22730 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22731 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22732 
  )
22733 
 
22734 
  def __init__(self, success=None, ex=None,):
22735 
    self.success = success
22736 
    self.ex = ex
22737 
 
22738 
  def read(self, iprot):
22739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22741 
      return
22742 
    iprot.readStructBegin()
22743 
    while True:
22744 
      (fname, ftype, fid) = iprot.readFieldBegin()
22745 
      if ftype == TType.STOP:
22746 
        break
22747 
      if fid == 0:
22748 
        if ftype == TType.LIST:
22749 
          self.success = []
6188 rajveer 22750 
          (_etype541, _size538) = iprot.readListBegin()
22751 
          for _i542 in xrange(_size538):
22752 
            _elem543 = Order()
22753 
            _elem543.read(iprot)
22754 
            self.success.append(_elem543)
4709 rajveer 22755 
          iprot.readListEnd()
22756 
        else:
22757 
          iprot.skip(ftype)
22758 
      elif fid == 1:
22759 
        if ftype == TType.STRUCT:
22760 
          self.ex = TransactionServiceException()
22761 
          self.ex.read(iprot)
22762 
        else:
22763 
          iprot.skip(ftype)
22764 
      else:
22765 
        iprot.skip(ftype)
22766 
      iprot.readFieldEnd()
22767 
    iprot.readStructEnd()
22768 
 
22769 
  def write(self, oprot):
22770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22772 
      return
22773 
    oprot.writeStructBegin('getCancelledOrders_result')
22774 
    if self.success is not None:
22775 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22776 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22777 
      for iter544 in self.success:
22778 
        iter544.write(oprot)
4709 rajveer 22779 
      oprot.writeListEnd()
22780 
      oprot.writeFieldEnd()
22781 
    if self.ex is not None:
22782 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22783 
      self.ex.write(oprot)
22784 
      oprot.writeFieldEnd()
22785 
    oprot.writeFieldStop()
22786 
    oprot.writeStructEnd()
22787 
 
22788 
  def validate(self):
22789 
    return
22790 
 
22791 
 
22792 
  def __repr__(self):
22793 
    L = ['%s=%r' % (key, value)
22794 
      for key, value in self.__dict__.iteritems()]
22795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22796 
 
22797 
  def __eq__(self, other):
22798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22799 
 
22800 
  def __ne__(self, other):
22801 
    return not (self == other)
22802 
 
4600 varun.gupt 22803 
class saveBluedartSettlements_args:
22804 
  """
22805 
  Attributes:
22806 
   - mapAWBAndAmount
22807 
  """
22808 
 
22809 
  thrift_spec = (
22810 
    None, # 0
22811 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22812 
  )
22813 
 
22814 
  def __init__(self, mapAWBAndAmount=None,):
22815 
    self.mapAWBAndAmount = mapAWBAndAmount
22816 
 
22817 
  def read(self, iprot):
22818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22820 
      return
22821 
    iprot.readStructBegin()
22822 
    while True:
22823 
      (fname, ftype, fid) = iprot.readFieldBegin()
22824 
      if ftype == TType.STOP:
22825 
        break
22826 
      if fid == 1:
22827 
        if ftype == TType.MAP:
22828 
          self.mapAWBAndAmount = {}
6188 rajveer 22829 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22830 
          for _i549 in xrange(_size545):
22831 
            _key550 = iprot.readI64();
22832 
            _val551 = iprot.readDouble();
22833 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22834 
          iprot.readMapEnd()
22835 
        else:
22836 
          iprot.skip(ftype)
22837 
      else:
22838 
        iprot.skip(ftype)
22839 
      iprot.readFieldEnd()
22840 
    iprot.readStructEnd()
22841 
 
22842 
  def write(self, oprot):
22843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22845 
      return
22846 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22847 
    if self.mapAWBAndAmount is not None:
22848 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22849 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22850 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22851 
        oprot.writeI64(kiter552)
22852 
        oprot.writeDouble(viter553)
4600 varun.gupt 22853 
      oprot.writeMapEnd()
22854 
      oprot.writeFieldEnd()
22855 
    oprot.writeFieldStop()
22856 
    oprot.writeStructEnd()
22857 
 
22858 
  def validate(self):
22859 
    return
22860 
 
22861 
 
22862 
  def __repr__(self):
22863 
    L = ['%s=%r' % (key, value)
22864 
      for key, value in self.__dict__.iteritems()]
22865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22866 
 
22867 
  def __eq__(self, other):
22868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22869 
 
22870 
  def __ne__(self, other):
22871 
    return not (self == other)
22872 
 
22873 
class saveBluedartSettlements_result:
22874 
  """
22875 
  Attributes:
22876 
   - ex
22877 
  """
22878 
 
22879 
  thrift_spec = (
22880 
    None, # 0
22881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22882 
  )
22883 
 
22884 
  def __init__(self, ex=None,):
22885 
    self.ex = ex
22886 
 
22887 
  def read(self, iprot):
22888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22890 
      return
22891 
    iprot.readStructBegin()
22892 
    while True:
22893 
      (fname, ftype, fid) = iprot.readFieldBegin()
22894 
      if ftype == TType.STOP:
22895 
        break
22896 
      if fid == 1:
22897 
        if ftype == TType.STRUCT:
22898 
          self.ex = TransactionServiceException()
22899 
          self.ex.read(iprot)
22900 
        else:
22901 
          iprot.skip(ftype)
22902 
      else:
22903 
        iprot.skip(ftype)
22904 
      iprot.readFieldEnd()
22905 
    iprot.readStructEnd()
22906 
 
22907 
  def write(self, oprot):
22908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22910 
      return
22911 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22912 
    if self.ex is not None:
22913 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22914 
      self.ex.write(oprot)
22915 
      oprot.writeFieldEnd()
22916 
    oprot.writeFieldStop()
22917 
    oprot.writeStructEnd()
22918 
 
22919 
  def validate(self):
22920 
    return
22921 
 
22922 
 
22923 
  def __repr__(self):
22924 
    L = ['%s=%r' % (key, value)
22925 
      for key, value in self.__dict__.iteritems()]
22926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22927 
 
22928 
  def __eq__(self, other):
22929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22930 
 
22931 
  def __ne__(self, other):
22932 
    return not (self == other)
22933 
 
22934 
class savePaymentSettlements_args:
22935 
  """
22936 
  Attributes:
22937 
   - settlementDate
22938 
   - paymentGatewayId
4905 varun.gupt 22939 
   - referenceId
4600 varun.gupt 22940 
   - serviceTax
22941 
   - otherCharges
22942 
   - netCollection
22943 
  """
22944 
 
22945 
  thrift_spec = (
22946 
    None, # 0
22947 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22948 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22949 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22950 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22951 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22952 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22953 
  )
22954 
 
4905 varun.gupt 22955 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22956 
    self.settlementDate = settlementDate
22957 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22958 
    self.referenceId = referenceId
4600 varun.gupt 22959 
    self.serviceTax = serviceTax
22960 
    self.otherCharges = otherCharges
22961 
    self.netCollection = netCollection
22962 
 
22963 
  def read(self, iprot):
22964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22966 
      return
22967 
    iprot.readStructBegin()
22968 
    while True:
22969 
      (fname, ftype, fid) = iprot.readFieldBegin()
22970 
      if ftype == TType.STOP:
22971 
        break
22972 
      if fid == 1:
22973 
        if ftype == TType.I64:
22974 
          self.settlementDate = iprot.readI64();
22975 
        else:
22976 
          iprot.skip(ftype)
22977 
      elif fid == 2:
22978 
        if ftype == TType.I64:
22979 
          self.paymentGatewayId = iprot.readI64();
22980 
        else:
22981 
          iprot.skip(ftype)
22982 
      elif fid == 3:
22983 
        if ftype == TType.I64:
4905 varun.gupt 22984 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22985 
        else:
22986 
          iprot.skip(ftype)
22987 
      elif fid == 4:
22988 
        if ftype == TType.DOUBLE:
22989 
          self.serviceTax = iprot.readDouble();
22990 
        else:
22991 
          iprot.skip(ftype)
22992 
      elif fid == 5:
22993 
        if ftype == TType.DOUBLE:
22994 
          self.otherCharges = iprot.readDouble();
22995 
        else:
22996 
          iprot.skip(ftype)
22997 
      elif fid == 6:
22998 
        if ftype == TType.DOUBLE:
22999 
          self.netCollection = iprot.readDouble();
23000 
        else:
23001 
          iprot.skip(ftype)
23002 
      else:
23003 
        iprot.skip(ftype)
23004 
      iprot.readFieldEnd()
23005 
    iprot.readStructEnd()
23006 
 
23007 
  def write(self, oprot):
23008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23010 
      return
23011 
    oprot.writeStructBegin('savePaymentSettlements_args')
23012 
    if self.settlementDate is not None:
23013 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23014 
      oprot.writeI64(self.settlementDate)
23015 
      oprot.writeFieldEnd()
23016 
    if self.paymentGatewayId is not None:
23017 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23018 
      oprot.writeI64(self.paymentGatewayId)
23019 
      oprot.writeFieldEnd()
4905 varun.gupt 23020 
    if self.referenceId is not None:
23021 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23022 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23023 
      oprot.writeFieldEnd()
23024 
    if self.serviceTax is not None:
23025 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23026 
      oprot.writeDouble(self.serviceTax)
23027 
      oprot.writeFieldEnd()
23028 
    if self.otherCharges is not None:
23029 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23030 
      oprot.writeDouble(self.otherCharges)
23031 
      oprot.writeFieldEnd()
23032 
    if self.netCollection is not None:
23033 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23034 
      oprot.writeDouble(self.netCollection)
23035 
      oprot.writeFieldEnd()
23036 
    oprot.writeFieldStop()
23037 
    oprot.writeStructEnd()
23038 
 
23039 
  def validate(self):
23040 
    return
23041 
 
23042 
 
23043 
  def __repr__(self):
23044 
    L = ['%s=%r' % (key, value)
23045 
      for key, value in self.__dict__.iteritems()]
23046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23047 
 
23048 
  def __eq__(self, other):
23049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23050 
 
23051 
  def __ne__(self, other):
23052 
    return not (self == other)
23053 
 
23054 
class savePaymentSettlements_result:
23055 
  """
23056 
  Attributes:
23057 
   - ex
23058 
  """
23059 
 
23060 
  thrift_spec = (
23061 
    None, # 0
23062 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23063 
  )
23064 
 
23065 
  def __init__(self, ex=None,):
23066 
    self.ex = ex
23067 
 
23068 
  def read(self, iprot):
23069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23071 
      return
23072 
    iprot.readStructBegin()
23073 
    while True:
23074 
      (fname, ftype, fid) = iprot.readFieldBegin()
23075 
      if ftype == TType.STOP:
23076 
        break
23077 
      if fid == 1:
23078 
        if ftype == TType.STRUCT:
23079 
          self.ex = TransactionServiceException()
23080 
          self.ex.read(iprot)
23081 
        else:
23082 
          iprot.skip(ftype)
23083 
      else:
23084 
        iprot.skip(ftype)
23085 
      iprot.readFieldEnd()
23086 
    iprot.readStructEnd()
23087 
 
23088 
  def write(self, oprot):
23089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23091 
      return
23092 
    oprot.writeStructBegin('savePaymentSettlements_result')
23093 
    if self.ex is not None:
23094 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23095 
      self.ex.write(oprot)
23096 
      oprot.writeFieldEnd()
23097 
    oprot.writeFieldStop()
23098 
    oprot.writeStructEnd()
23099 
 
23100 
  def validate(self):
23101 
    return
23102 
 
23103 
 
23104 
  def __repr__(self):
23105 
    L = ['%s=%r' % (key, value)
23106 
      for key, value in self.__dict__.iteritems()]
23107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23108 
 
23109 
  def __eq__(self, other):
23110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23111 
 
23112 
  def __ne__(self, other):
23113 
    return not (self == other)
23114 
 
23115 
class saveEBSSettlementSummary_args:
23116 
  """
23117 
  Attributes:
23118 
   - settlementId
23119 
   - settlementDate
23120 
   - transactionDateFrom
23121 
   - transactionDateTo
23122 
   - amount
23123 
  """
23124 
 
23125 
  thrift_spec = (
23126 
    None, # 0
23127 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23128 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23129 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23130 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23131 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23132 
  )
23133 
 
23134 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23135 
    self.settlementId = settlementId
23136 
    self.settlementDate = settlementDate
23137 
    self.transactionDateFrom = transactionDateFrom
23138 
    self.transactionDateTo = transactionDateTo
23139 
    self.amount = amount
23140 
 
23141 
  def read(self, iprot):
23142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23144 
      return
23145 
    iprot.readStructBegin()
23146 
    while True:
23147 
      (fname, ftype, fid) = iprot.readFieldBegin()
23148 
      if ftype == TType.STOP:
23149 
        break
23150 
      if fid == 1:
23151 
        if ftype == TType.I64:
23152 
          self.settlementId = iprot.readI64();
23153 
        else:
23154 
          iprot.skip(ftype)
23155 
      elif fid == 2:
23156 
        if ftype == TType.I64:
23157 
          self.settlementDate = iprot.readI64();
23158 
        else:
23159 
          iprot.skip(ftype)
23160 
      elif fid == 3:
23161 
        if ftype == TType.I64:
23162 
          self.transactionDateFrom = iprot.readI64();
23163 
        else:
23164 
          iprot.skip(ftype)
23165 
      elif fid == 4:
23166 
        if ftype == TType.I64:
23167 
          self.transactionDateTo = iprot.readI64();
23168 
        else:
23169 
          iprot.skip(ftype)
23170 
      elif fid == 5:
23171 
        if ftype == TType.DOUBLE:
23172 
          self.amount = iprot.readDouble();
23173 
        else:
23174 
          iprot.skip(ftype)
23175 
      else:
23176 
        iprot.skip(ftype)
23177 
      iprot.readFieldEnd()
23178 
    iprot.readStructEnd()
23179 
 
23180 
  def write(self, oprot):
23181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23183 
      return
23184 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23185 
    if self.settlementId is not None:
23186 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23187 
      oprot.writeI64(self.settlementId)
23188 
      oprot.writeFieldEnd()
23189 
    if self.settlementDate is not None:
23190 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23191 
      oprot.writeI64(self.settlementDate)
23192 
      oprot.writeFieldEnd()
23193 
    if self.transactionDateFrom is not None:
23194 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23195 
      oprot.writeI64(self.transactionDateFrom)
23196 
      oprot.writeFieldEnd()
23197 
    if self.transactionDateTo is not None:
23198 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23199 
      oprot.writeI64(self.transactionDateTo)
23200 
      oprot.writeFieldEnd()
23201 
    if self.amount is not None:
23202 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23203 
      oprot.writeDouble(self.amount)
23204 
      oprot.writeFieldEnd()
23205 
    oprot.writeFieldStop()
23206 
    oprot.writeStructEnd()
23207 
 
23208 
  def validate(self):
23209 
    return
23210 
 
23211 
 
23212 
  def __repr__(self):
23213 
    L = ['%s=%r' % (key, value)
23214 
      for key, value in self.__dict__.iteritems()]
23215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23216 
 
23217 
  def __eq__(self, other):
23218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23219 
 
23220 
  def __ne__(self, other):
23221 
    return not (self == other)
23222 
 
23223 
class saveEBSSettlementSummary_result:
23224 
  """
23225 
  Attributes:
23226 
   - ex
23227 
  """
23228 
 
23229 
  thrift_spec = (
23230 
    None, # 0
23231 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23232 
  )
23233 
 
23234 
  def __init__(self, ex=None,):
23235 
    self.ex = ex
23236 
 
23237 
  def read(self, iprot):
23238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23240 
      return
23241 
    iprot.readStructBegin()
23242 
    while True:
23243 
      (fname, ftype, fid) = iprot.readFieldBegin()
23244 
      if ftype == TType.STOP:
23245 
        break
23246 
      if fid == 1:
23247 
        if ftype == TType.STRUCT:
23248 
          self.ex = TransactionServiceException()
23249 
          self.ex.read(iprot)
23250 
        else:
23251 
          iprot.skip(ftype)
23252 
      else:
23253 
        iprot.skip(ftype)
23254 
      iprot.readFieldEnd()
23255 
    iprot.readStructEnd()
23256 
 
23257 
  def write(self, oprot):
23258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23260 
      return
23261 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23262 
    if self.ex is not None:
23263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23264 
      self.ex.write(oprot)
23265 
      oprot.writeFieldEnd()
23266 
    oprot.writeFieldStop()
23267 
    oprot.writeStructEnd()
23268 
 
23269 
  def validate(self):
23270 
    return
23271 
 
23272 
 
23273 
  def __repr__(self):
23274 
    L = ['%s=%r' % (key, value)
23275 
      for key, value in self.__dict__.iteritems()]
23276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23277 
 
23278 
  def __eq__(self, other):
23279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23280 
 
23281 
  def __ne__(self, other):
23282 
    return not (self == other)
23283 
 
5386 phani.kuma 23284 
class getSettlementForPrepaid_args:
4600 varun.gupt 23285 
  """
23286 
  Attributes:
5189 varun.gupt 23287 
   - referenceId
23288 
   - isRefund
4600 varun.gupt 23289 
  """
23290 
 
23291 
  thrift_spec = (
23292 
    None, # 0
5189 varun.gupt 23293 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23294 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23295 
  )
23296 
 
5386 phani.kuma 23297 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23298 
    self.referenceId = referenceId
23299 
    self.isRefund = isRefund
4600 varun.gupt 23300 
 
23301 
  def read(self, iprot):
23302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23304 
      return
23305 
    iprot.readStructBegin()
23306 
    while True:
23307 
      (fname, ftype, fid) = iprot.readFieldBegin()
23308 
      if ftype == TType.STOP:
23309 
        break
23310 
      if fid == 1:
23311 
        if ftype == TType.I64:
5189 varun.gupt 23312 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23313 
        else:
23314 
          iprot.skip(ftype)
5189 varun.gupt 23315 
      elif fid == 2:
23316 
        if ftype == TType.BOOL:
23317 
          self.isRefund = iprot.readBool();
23318 
        else:
23319 
          iprot.skip(ftype)
4600 varun.gupt 23320 
      else:
23321 
        iprot.skip(ftype)
23322 
      iprot.readFieldEnd()
23323 
    iprot.readStructEnd()
23324 
 
23325 
  def write(self, oprot):
23326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23328 
      return
5386 phani.kuma 23329 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23330 
    if self.referenceId is not None:
23331 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23332 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23333 
      oprot.writeFieldEnd()
5386 phani.kuma 23334 
    if self.isRefund is not None:
23335 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23336 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23337 
      oprot.writeFieldEnd()
5386 phani.kuma 23338 
    oprot.writeFieldStop()
23339 
    oprot.writeStructEnd()
23340 
 
23341 
  def validate(self):
23342 
    return
23343 
 
23344 
 
23345 
  def __repr__(self):
23346 
    L = ['%s=%r' % (key, value)
23347 
      for key, value in self.__dict__.iteritems()]
23348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23349 
 
23350 
  def __eq__(self, other):
23351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23352 
 
23353 
  def __ne__(self, other):
23354 
    return not (self == other)
23355 
 
23356 
class getSettlementForPrepaid_result:
23357 
  """
23358 
  Attributes:
23359 
   - success
23360 
   - ex
23361 
  """
23362 
 
23363 
  thrift_spec = (
23364 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23366 
  )
23367 
 
23368 
  def __init__(self, success=None, ex=None,):
23369 
    self.success = success
23370 
    self.ex = ex
23371 
 
23372 
  def read(self, iprot):
23373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23375 
      return
23376 
    iprot.readStructBegin()
23377 
    while True:
23378 
      (fname, ftype, fid) = iprot.readFieldBegin()
23379 
      if ftype == TType.STOP:
23380 
        break
23381 
      if fid == 0:
23382 
        if ftype == TType.STRUCT:
23383 
          self.success = PaymentSettlement()
23384 
          self.success.read(iprot)
23385 
        else:
23386 
          iprot.skip(ftype)
23387 
      elif fid == 1:
23388 
        if ftype == TType.STRUCT:
23389 
          self.ex = TransactionServiceException()
23390 
          self.ex.read(iprot)
23391 
        else:
23392 
          iprot.skip(ftype)
23393 
      else:
23394 
        iprot.skip(ftype)
23395 
      iprot.readFieldEnd()
23396 
    iprot.readStructEnd()
23397 
 
23398 
  def write(self, oprot):
23399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23401 
      return
23402 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23403 
    if self.success is not None:
23404 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23405 
      self.success.write(oprot)
23406 
      oprot.writeFieldEnd()
23407 
    if self.ex is not None:
23408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23409 
      self.ex.write(oprot)
23410 
      oprot.writeFieldEnd()
23411 
    oprot.writeFieldStop()
23412 
    oprot.writeStructEnd()
23413 
 
23414 
  def validate(self):
23415 
    return
23416 
 
23417 
 
23418 
  def __repr__(self):
23419 
    L = ['%s=%r' % (key, value)
23420 
      for key, value in self.__dict__.iteritems()]
23421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23422 
 
23423 
  def __eq__(self, other):
23424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23425 
 
23426 
  def __ne__(self, other):
23427 
    return not (self == other)
23428 
 
23429 
class getSettlementForCod_args:
23430 
  """
23431 
  Attributes:
23432 
   - orderId
23433 
   - isRefund
23434 
  """
23435 
 
23436 
  thrift_spec = (
23437 
    None, # 0
23438 
    (1, TType.I64, 'orderId', None, None, ), # 1
23439 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23440 
  )
23441 
 
23442 
  def __init__(self, orderId=None, isRefund=None,):
23443 
    self.orderId = orderId
23444 
    self.isRefund = isRefund
23445 
 
23446 
  def read(self, iprot):
23447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23449 
      return
23450 
    iprot.readStructBegin()
23451 
    while True:
23452 
      (fname, ftype, fid) = iprot.readFieldBegin()
23453 
      if ftype == TType.STOP:
23454 
        break
23455 
      if fid == 1:
23456 
        if ftype == TType.I64:
23457 
          self.orderId = iprot.readI64();
23458 
        else:
23459 
          iprot.skip(ftype)
23460 
      elif fid == 2:
23461 
        if ftype == TType.BOOL:
23462 
          self.isRefund = iprot.readBool();
23463 
        else:
23464 
          iprot.skip(ftype)
23465 
      else:
23466 
        iprot.skip(ftype)
23467 
      iprot.readFieldEnd()
23468 
    iprot.readStructEnd()
23469 
 
23470 
  def write(self, oprot):
23471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23473 
      return
23474 
    oprot.writeStructBegin('getSettlementForCod_args')
23475 
    if self.orderId is not None:
23476 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23477 
      oprot.writeI64(self.orderId)
23478 
      oprot.writeFieldEnd()
5189 varun.gupt 23479 
    if self.isRefund is not None:
5386 phani.kuma 23480 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23481 
      oprot.writeBool(self.isRefund)
23482 
      oprot.writeFieldEnd()
4600 varun.gupt 23483 
    oprot.writeFieldStop()
23484 
    oprot.writeStructEnd()
23485 
 
23486 
  def validate(self):
23487 
    return
23488 
 
23489 
 
23490 
  def __repr__(self):
23491 
    L = ['%s=%r' % (key, value)
23492 
      for key, value in self.__dict__.iteritems()]
23493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23494 
 
23495 
  def __eq__(self, other):
23496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23497 
 
23498 
  def __ne__(self, other):
23499 
    return not (self == other)
23500 
 
5386 phani.kuma 23501 
class getSettlementForCod_result:
4600 varun.gupt 23502 
  """
23503 
  Attributes:
23504 
   - success
23505 
   - ex
23506 
  """
23507 
 
23508 
  thrift_spec = (
23509 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23511 
  )
23512 
 
23513 
  def __init__(self, success=None, ex=None,):
23514 
    self.success = success
23515 
    self.ex = ex
23516 
 
23517 
  def read(self, iprot):
23518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23520 
      return
23521 
    iprot.readStructBegin()
23522 
    while True:
23523 
      (fname, ftype, fid) = iprot.readFieldBegin()
23524 
      if ftype == TType.STOP:
23525 
        break
23526 
      if fid == 0:
23527 
        if ftype == TType.STRUCT:
23528 
          self.success = PaymentSettlement()
23529 
          self.success.read(iprot)
23530 
        else:
23531 
          iprot.skip(ftype)
23532 
      elif fid == 1:
23533 
        if ftype == TType.STRUCT:
23534 
          self.ex = TransactionServiceException()
23535 
          self.ex.read(iprot)
23536 
        else:
23537 
          iprot.skip(ftype)
23538 
      else:
23539 
        iprot.skip(ftype)
23540 
      iprot.readFieldEnd()
23541 
    iprot.readStructEnd()
23542 
 
23543 
  def write(self, oprot):
23544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23546 
      return
5386 phani.kuma 23547 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23548 
    if self.success is not None:
23549 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23550 
      self.success.write(oprot)
23551 
      oprot.writeFieldEnd()
23552 
    if self.ex is not None:
23553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23554 
      self.ex.write(oprot)
23555 
      oprot.writeFieldEnd()
23556 
    oprot.writeFieldStop()
23557 
    oprot.writeStructEnd()
23558 
 
23559 
  def validate(self):
23560 
    return
23561 
 
23562 
 
23563 
  def __repr__(self):
23564 
    L = ['%s=%r' % (key, value)
23565 
      for key, value in self.__dict__.iteritems()]
23566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23567 
 
23568 
  def __eq__(self, other):
23569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23570 
 
23571 
  def __ne__(self, other):
23572 
    return not (self == other)
23573 
 
23574 
class getEBSSettlementSummaries_args:
23575 
 
23576 
  thrift_spec = (
23577 
  )
23578 
 
23579 
  def read(self, iprot):
23580 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23581 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23582 
      return
23583 
    iprot.readStructBegin()
23584 
    while True:
23585 
      (fname, ftype, fid) = iprot.readFieldBegin()
23586 
      if ftype == TType.STOP:
23587 
        break
23588 
      else:
23589 
        iprot.skip(ftype)
23590 
      iprot.readFieldEnd()
23591 
    iprot.readStructEnd()
23592 
 
23593 
  def write(self, oprot):
23594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23596 
      return
23597 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23598 
    oprot.writeFieldStop()
23599 
    oprot.writeStructEnd()
23600 
 
23601 
  def validate(self):
23602 
    return
23603 
 
23604 
 
23605 
  def __repr__(self):
23606 
    L = ['%s=%r' % (key, value)
23607 
      for key, value in self.__dict__.iteritems()]
23608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23609 
 
23610 
  def __eq__(self, other):
23611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23612 
 
23613 
  def __ne__(self, other):
23614 
    return not (self == other)
23615 
 
23616 
class getEBSSettlementSummaries_result:
23617 
  """
23618 
  Attributes:
23619 
   - success
23620 
   - ex
23621 
  """
23622 
 
23623 
  thrift_spec = (
23624 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23626 
  )
23627 
 
23628 
  def __init__(self, success=None, ex=None,):
23629 
    self.success = success
23630 
    self.ex = ex
23631 
 
23632 
  def read(self, iprot):
23633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23635 
      return
23636 
    iprot.readStructBegin()
23637 
    while True:
23638 
      (fname, ftype, fid) = iprot.readFieldBegin()
23639 
      if ftype == TType.STOP:
23640 
        break
23641 
      if fid == 0:
23642 
        if ftype == TType.MAP:
23643 
          self.success = {}
6188 rajveer 23644 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23645 
          for _i558 in xrange(_size554):
23646 
            _key559 = iprot.readI64();
23647 
            _val560 = iprot.readString();
23648 
            self.success[_key559] = _val560
4600 varun.gupt 23649 
          iprot.readMapEnd()
23650 
        else:
23651 
          iprot.skip(ftype)
23652 
      elif fid == 1:
23653 
        if ftype == TType.STRUCT:
23654 
          self.ex = TransactionServiceException()
23655 
          self.ex.read(iprot)
23656 
        else:
23657 
          iprot.skip(ftype)
23658 
      else:
23659 
        iprot.skip(ftype)
23660 
      iprot.readFieldEnd()
23661 
    iprot.readStructEnd()
23662 
 
23663 
  def write(self, oprot):
23664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23666 
      return
23667 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23668 
    if self.success is not None:
23669 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23670 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23671 
      for kiter561,viter562 in self.success.items():
23672 
        oprot.writeI64(kiter561)
23673 
        oprot.writeString(viter562)
4600 varun.gupt 23674 
      oprot.writeMapEnd()
23675 
      oprot.writeFieldEnd()
23676 
    if self.ex is not None:
23677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23678 
      self.ex.write(oprot)
23679 
      oprot.writeFieldEnd()
23680 
    oprot.writeFieldStop()
23681 
    oprot.writeStructEnd()
23682 
 
23683 
  def validate(self):
23684 
    return
23685 
 
23686 
 
23687 
  def __repr__(self):
23688 
    L = ['%s=%r' % (key, value)
23689 
      for key, value in self.__dict__.iteritems()]
23690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23691 
 
23692 
  def __eq__(self, other):
23693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23694 
 
23695 
  def __ne__(self, other):
23696 
    return not (self == other)
23697 
 
23698 
class markEBSSettlementUploaded_args:
23699 
  """
23700 
  Attributes:
23701 
   - settlementId
23702 
  """
23703 
 
23704 
  thrift_spec = (
23705 
    None, # 0
23706 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23707 
  )
23708 
 
23709 
  def __init__(self, settlementId=None,):
23710 
    self.settlementId = settlementId
23711 
 
23712 
  def read(self, iprot):
23713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23715 
      return
23716 
    iprot.readStructBegin()
23717 
    while True:
23718 
      (fname, ftype, fid) = iprot.readFieldBegin()
23719 
      if ftype == TType.STOP:
23720 
        break
23721 
      if fid == 1:
23722 
        if ftype == TType.I64:
23723 
          self.settlementId = iprot.readI64();
23724 
        else:
23725 
          iprot.skip(ftype)
23726 
      else:
23727 
        iprot.skip(ftype)
23728 
      iprot.readFieldEnd()
23729 
    iprot.readStructEnd()
23730 
 
23731 
  def write(self, oprot):
23732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23734 
      return
23735 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23736 
    if self.settlementId is not None:
23737 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23738 
      oprot.writeI64(self.settlementId)
23739 
      oprot.writeFieldEnd()
23740 
    oprot.writeFieldStop()
23741 
    oprot.writeStructEnd()
23742 
 
23743 
  def validate(self):
23744 
    return
23745 
 
23746 
 
23747 
  def __repr__(self):
23748 
    L = ['%s=%r' % (key, value)
23749 
      for key, value in self.__dict__.iteritems()]
23750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23751 
 
23752 
  def __eq__(self, other):
23753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23754 
 
23755 
  def __ne__(self, other):
23756 
    return not (self == other)
23757 
 
23758 
class markEBSSettlementUploaded_result:
23759 
  """
23760 
  Attributes:
23761 
   - ex
23762 
  """
23763 
 
23764 
  thrift_spec = (
23765 
    None, # 0
23766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23767 
  )
23768 
 
23769 
  def __init__(self, ex=None,):
23770 
    self.ex = ex
23771 
 
23772 
  def read(self, iprot):
23773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23775 
      return
23776 
    iprot.readStructBegin()
23777 
    while True:
23778 
      (fname, ftype, fid) = iprot.readFieldBegin()
23779 
      if ftype == TType.STOP:
23780 
        break
23781 
      if fid == 1:
23782 
        if ftype == TType.STRUCT:
23783 
          self.ex = TransactionServiceException()
23784 
          self.ex.read(iprot)
23785 
        else:
23786 
          iprot.skip(ftype)
23787 
      else:
23788 
        iprot.skip(ftype)
23789 
      iprot.readFieldEnd()
23790 
    iprot.readStructEnd()
23791 
 
23792 
  def write(self, oprot):
23793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23795 
      return
23796 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23797 
    if self.ex is not None:
23798 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23799 
      self.ex.write(oprot)
23800 
      oprot.writeFieldEnd()
23801 
    oprot.writeFieldStop()
23802 
    oprot.writeStructEnd()
23803 
 
23804 
  def validate(self):
23805 
    return
23806 
 
23807 
 
23808 
  def __repr__(self):
23809 
    L = ['%s=%r' % (key, value)
23810 
      for key, value in self.__dict__.iteritems()]
23811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23812 
 
23813 
  def __eq__(self, other):
23814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23815 
 
23816 
  def __ne__(self, other):
23817 
    return not (self == other)
23818 
 
23819 
class getEBSSettlementDate_args:
23820 
  """
23821 
  Attributes:
23822 
   - settlementId
23823 
  """
23824 
 
23825 
  thrift_spec = (
23826 
    None, # 0
23827 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23828 
  )
23829 
 
23830 
  def __init__(self, settlementId=None,):
23831 
    self.settlementId = settlementId
23832 
 
23833 
  def read(self, iprot):
23834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23836 
      return
23837 
    iprot.readStructBegin()
23838 
    while True:
23839 
      (fname, ftype, fid) = iprot.readFieldBegin()
23840 
      if ftype == TType.STOP:
23841 
        break
23842 
      if fid == 1:
23843 
        if ftype == TType.I64:
23844 
          self.settlementId = iprot.readI64();
23845 
        else:
23846 
          iprot.skip(ftype)
23847 
      else:
23848 
        iprot.skip(ftype)
23849 
      iprot.readFieldEnd()
23850 
    iprot.readStructEnd()
23851 
 
23852 
  def write(self, oprot):
23853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23855 
      return
23856 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23857 
    if self.settlementId is not None:
23858 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23859 
      oprot.writeI64(self.settlementId)
23860 
      oprot.writeFieldEnd()
23861 
    oprot.writeFieldStop()
23862 
    oprot.writeStructEnd()
23863 
 
23864 
  def validate(self):
23865 
    return
23866 
 
23867 
 
23868 
  def __repr__(self):
23869 
    L = ['%s=%r' % (key, value)
23870 
      for key, value in self.__dict__.iteritems()]
23871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23872 
 
23873 
  def __eq__(self, other):
23874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23875 
 
23876 
  def __ne__(self, other):
23877 
    return not (self == other)
23878 
 
23879 
class getEBSSettlementDate_result:
23880 
  """
23881 
  Attributes:
23882 
   - success
23883 
   - ex
23884 
  """
23885 
 
23886 
  thrift_spec = (
23887 
    (0, TType.I64, 'success', None, None, ), # 0
23888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23889 
  )
23890 
 
23891 
  def __init__(self, success=None, ex=None,):
23892 
    self.success = success
23893 
    self.ex = ex
23894 
 
23895 
  def read(self, iprot):
23896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23898 
      return
23899 
    iprot.readStructBegin()
23900 
    while True:
23901 
      (fname, ftype, fid) = iprot.readFieldBegin()
23902 
      if ftype == TType.STOP:
23903 
        break
23904 
      if fid == 0:
23905 
        if ftype == TType.I64:
23906 
          self.success = iprot.readI64();
23907 
        else:
23908 
          iprot.skip(ftype)
23909 
      elif fid == 1:
23910 
        if ftype == TType.STRUCT:
23911 
          self.ex = TransactionServiceException()
23912 
          self.ex.read(iprot)
23913 
        else:
23914 
          iprot.skip(ftype)
23915 
      else:
23916 
        iprot.skip(ftype)
23917 
      iprot.readFieldEnd()
23918 
    iprot.readStructEnd()
23919 
 
23920 
  def write(self, oprot):
23921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23923 
      return
23924 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23925 
    if self.success is not None:
23926 
      oprot.writeFieldBegin('success', TType.I64, 0)
23927 
      oprot.writeI64(self.success)
23928 
      oprot.writeFieldEnd()
23929 
    if self.ex is not None:
23930 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23931 
      self.ex.write(oprot)
23932 
      oprot.writeFieldEnd()
23933 
    oprot.writeFieldStop()
23934 
    oprot.writeStructEnd()
23935 
 
23936 
  def validate(self):
23937 
    return
23938 
 
23939 
 
23940 
  def __repr__(self):
23941 
    L = ['%s=%r' % (key, value)
23942 
      for key, value in self.__dict__.iteritems()]
23943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23944 
 
23945 
  def __eq__(self, other):
23946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23947 
 
23948 
  def __ne__(self, other):
23949 
    return not (self == other)
4715 varun.gupt 23950 
 
23951 
class getSettlementsByDate_args:
23952 
  """
23953 
  Attributes:
23954 
   - settlementDateFrom
23955 
   - settlementDateTo
23956 
   - isRefund
23957 
  """
23958 
 
23959 
  thrift_spec = (
23960 
    None, # 0
23961 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23962 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23963 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23964 
  )
23965 
 
23966 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23967 
    self.settlementDateFrom = settlementDateFrom
23968 
    self.settlementDateTo = settlementDateTo
23969 
    self.isRefund = isRefund
23970 
 
23971 
  def read(self, iprot):
23972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23974 
      return
23975 
    iprot.readStructBegin()
23976 
    while True:
23977 
      (fname, ftype, fid) = iprot.readFieldBegin()
23978 
      if ftype == TType.STOP:
23979 
        break
23980 
      if fid == 1:
23981 
        if ftype == TType.I64:
23982 
          self.settlementDateFrom = iprot.readI64();
23983 
        else:
23984 
          iprot.skip(ftype)
23985 
      elif fid == 2:
23986 
        if ftype == TType.I64:
23987 
          self.settlementDateTo = iprot.readI64();
23988 
        else:
23989 
          iprot.skip(ftype)
23990 
      elif fid == 3:
23991 
        if ftype == TType.BOOL:
23992 
          self.isRefund = iprot.readBool();
23993 
        else:
23994 
          iprot.skip(ftype)
23995 
      else:
23996 
        iprot.skip(ftype)
23997 
      iprot.readFieldEnd()
23998 
    iprot.readStructEnd()
23999 
 
24000 
  def write(self, oprot):
24001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24003 
      return
24004 
    oprot.writeStructBegin('getSettlementsByDate_args')
24005 
    if self.settlementDateFrom is not None:
24006 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24007 
      oprot.writeI64(self.settlementDateFrom)
24008 
      oprot.writeFieldEnd()
24009 
    if self.settlementDateTo is not None:
24010 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24011 
      oprot.writeI64(self.settlementDateTo)
24012 
      oprot.writeFieldEnd()
24013 
    if self.isRefund is not None:
24014 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24015 
      oprot.writeBool(self.isRefund)
24016 
      oprot.writeFieldEnd()
24017 
    oprot.writeFieldStop()
24018 
    oprot.writeStructEnd()
24019 
 
24020 
  def validate(self):
24021 
    return
24022 
 
24023 
 
24024 
  def __repr__(self):
24025 
    L = ['%s=%r' % (key, value)
24026 
      for key, value in self.__dict__.iteritems()]
24027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24028 
 
24029 
  def __eq__(self, other):
24030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24031 
 
24032 
  def __ne__(self, other):
24033 
    return not (self == other)
24034 
 
24035 
class getSettlementsByDate_result:
24036 
  """
24037 
  Attributes:
24038 
   - success
24039 
   - ex
24040 
  """
24041 
 
24042 
  thrift_spec = (
24043 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24045 
  )
24046 
 
24047 
  def __init__(self, success=None, ex=None,):
24048 
    self.success = success
24049 
    self.ex = ex
24050 
 
24051 
  def read(self, iprot):
24052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24054 
      return
24055 
    iprot.readStructBegin()
24056 
    while True:
24057 
      (fname, ftype, fid) = iprot.readFieldBegin()
24058 
      if ftype == TType.STOP:
24059 
        break
24060 
      if fid == 0:
24061 
        if ftype == TType.LIST:
24062 
          self.success = []
6188 rajveer 24063 
          (_etype566, _size563) = iprot.readListBegin()
24064 
          for _i567 in xrange(_size563):
24065 
            _elem568 = PaymentSettlement()
24066 
            _elem568.read(iprot)
24067 
            self.success.append(_elem568)
4715 varun.gupt 24068 
          iprot.readListEnd()
24069 
        else:
24070 
          iprot.skip(ftype)
24071 
      elif fid == 1:
24072 
        if ftype == TType.STRUCT:
24073 
          self.ex = TransactionServiceException()
24074 
          self.ex.read(iprot)
24075 
        else:
24076 
          iprot.skip(ftype)
24077 
      else:
24078 
        iprot.skip(ftype)
24079 
      iprot.readFieldEnd()
24080 
    iprot.readStructEnd()
24081 
 
24082 
  def write(self, oprot):
24083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24085 
      return
24086 
    oprot.writeStructBegin('getSettlementsByDate_result')
24087 
    if self.success is not None:
24088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24089 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24090 
      for iter569 in self.success:
24091 
        iter569.write(oprot)
4715 varun.gupt 24092 
      oprot.writeListEnd()
24093 
      oprot.writeFieldEnd()
24094 
    if self.ex is not None:
24095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24096 
      self.ex.write(oprot)
24097 
      oprot.writeFieldEnd()
24098 
    oprot.writeFieldStop()
24099 
    oprot.writeStructEnd()
24100 
 
24101 
  def validate(self):
24102 
    return
24103 
 
24104 
 
24105 
  def __repr__(self):
24106 
    L = ['%s=%r' % (key, value)
24107 
      for key, value in self.__dict__.iteritems()]
24108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24109 
 
24110 
  def __eq__(self, other):
24111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24112 
 
24113 
  def __ne__(self, other):
24114 
    return not (self == other)
24115 
 
24116 
class getReshippedOrderIds_args:
24117 
  """
24118 
  Attributes:
24119 
   - orderIds
24120 
  """
24121 
 
24122 
  thrift_spec = (
24123 
    None, # 0
24124 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24125 
  )
24126 
 
24127 
  def __init__(self, orderIds=None,):
24128 
    self.orderIds = orderIds
24129 
 
24130 
  def read(self, iprot):
24131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24133 
      return
24134 
    iprot.readStructBegin()
24135 
    while True:
24136 
      (fname, ftype, fid) = iprot.readFieldBegin()
24137 
      if ftype == TType.STOP:
24138 
        break
24139 
      if fid == 1:
24140 
        if ftype == TType.LIST:
24141 
          self.orderIds = []
6188 rajveer 24142 
          (_etype573, _size570) = iprot.readListBegin()
24143 
          for _i574 in xrange(_size570):
24144 
            _elem575 = iprot.readI64();
24145 
            self.orderIds.append(_elem575)
4715 varun.gupt 24146 
          iprot.readListEnd()
24147 
        else:
24148 
          iprot.skip(ftype)
24149 
      else:
24150 
        iprot.skip(ftype)
24151 
      iprot.readFieldEnd()
24152 
    iprot.readStructEnd()
24153 
 
24154 
  def write(self, oprot):
24155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24157 
      return
24158 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24159 
    if self.orderIds is not None:
24160 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24161 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24162 
      for iter576 in self.orderIds:
24163 
        oprot.writeI64(iter576)
4715 varun.gupt 24164 
      oprot.writeListEnd()
24165 
      oprot.writeFieldEnd()
24166 
    oprot.writeFieldStop()
24167 
    oprot.writeStructEnd()
24168 
 
24169 
  def validate(self):
24170 
    return
24171 
 
24172 
 
24173 
  def __repr__(self):
24174 
    L = ['%s=%r' % (key, value)
24175 
      for key, value in self.__dict__.iteritems()]
24176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24177 
 
24178 
  def __eq__(self, other):
24179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24180 
 
24181 
  def __ne__(self, other):
24182 
    return not (self == other)
24183 
 
24184 
class getReshippedOrderIds_result:
24185 
  """
24186 
  Attributes:
24187 
   - success
24188 
   - ex
24189 
  """
24190 
 
24191 
  thrift_spec = (
24192 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24193 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24194 
  )
24195 
 
24196 
  def __init__(self, success=None, ex=None,):
24197 
    self.success = success
24198 
    self.ex = ex
24199 
 
24200 
  def read(self, iprot):
24201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24203 
      return
24204 
    iprot.readStructBegin()
24205 
    while True:
24206 
      (fname, ftype, fid) = iprot.readFieldBegin()
24207 
      if ftype == TType.STOP:
24208 
        break
24209 
      if fid == 0:
24210 
        if ftype == TType.LIST:
24211 
          self.success = []
6188 rajveer 24212 
          (_etype580, _size577) = iprot.readListBegin()
24213 
          for _i581 in xrange(_size577):
24214 
            _elem582 = iprot.readI64();
24215 
            self.success.append(_elem582)
4715 varun.gupt 24216 
          iprot.readListEnd()
24217 
        else:
24218 
          iprot.skip(ftype)
24219 
      elif fid == 1:
24220 
        if ftype == TType.STRUCT:
24221 
          self.ex = TransactionServiceException()
24222 
          self.ex.read(iprot)
24223 
        else:
24224 
          iprot.skip(ftype)
24225 
      else:
24226 
        iprot.skip(ftype)
24227 
      iprot.readFieldEnd()
24228 
    iprot.readStructEnd()
24229 
 
24230 
  def write(self, oprot):
24231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24233 
      return
24234 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24235 
    if self.success is not None:
24236 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24237 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24238 
      for iter583 in self.success:
24239 
        oprot.writeI64(iter583)
4715 varun.gupt 24240 
      oprot.writeListEnd()
24241 
      oprot.writeFieldEnd()
24242 
    if self.ex is not None:
24243 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24244 
      self.ex.write(oprot)
24245 
      oprot.writeFieldEnd()
24246 
    oprot.writeFieldStop()
24247 
    oprot.writeStructEnd()
24248 
 
24249 
  def validate(self):
24250 
    return
24251 
 
24252 
 
24253 
  def __repr__(self):
24254 
    L = ['%s=%r' % (key, value)
24255 
      for key, value in self.__dict__.iteritems()]
24256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24257 
 
24258 
  def __eq__(self, other):
24259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24260 
 
24261 
  def __ne__(self, other):
24262 
    return not (self == other)
4757 mandeep.dh 24263 
 
5481 phani.kuma 24264 
class getBilledOrders_args:
4875 varun.gupt 24265 
  """
24266 
  Attributes:
24267 
   - vendorId
5481 phani.kuma 24268 
   - onlyVendorNotPaid
24269 
   - billingDateFrom
24270 
   - billingDateTo
4875 varun.gupt 24271 
  """
24272 
 
24273 
  thrift_spec = (
24274 
    None, # 0
24275 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24276 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24277 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24278 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24279 
  )
24280 
 
5481 phani.kuma 24281 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24282 
    self.vendorId = vendorId
5481 phani.kuma 24283 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24284 
    self.billingDateFrom = billingDateFrom
24285 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24286 
 
24287 
  def read(self, iprot):
24288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24290 
      return
24291 
    iprot.readStructBegin()
24292 
    while True:
24293 
      (fname, ftype, fid) = iprot.readFieldBegin()
24294 
      if ftype == TType.STOP:
24295 
        break
24296 
      if fid == 1:
24297 
        if ftype == TType.I64:
24298 
          self.vendorId = iprot.readI64();
24299 
        else:
24300 
          iprot.skip(ftype)
5481 phani.kuma 24301 
      elif fid == 2:
24302 
        if ftype == TType.BOOL:
24303 
          self.onlyVendorNotPaid = iprot.readBool();
24304 
        else:
24305 
          iprot.skip(ftype)
24306 
      elif fid == 3:
24307 
        if ftype == TType.I64:
24308 
          self.billingDateFrom = iprot.readI64();
24309 
        else:
24310 
          iprot.skip(ftype)
24311 
      elif fid == 4:
24312 
        if ftype == TType.I64:
24313 
          self.billingDateTo = iprot.readI64();
24314 
        else:
24315 
          iprot.skip(ftype)
4875 varun.gupt 24316 
      else:
24317 
        iprot.skip(ftype)
24318 
      iprot.readFieldEnd()
24319 
    iprot.readStructEnd()
24320 
 
24321 
  def write(self, oprot):
24322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24324 
      return
5481 phani.kuma 24325 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24326 
    if self.vendorId is not None:
24327 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24328 
      oprot.writeI64(self.vendorId)
24329 
      oprot.writeFieldEnd()
5481 phani.kuma 24330 
    if self.onlyVendorNotPaid is not None:
24331 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24332 
      oprot.writeBool(self.onlyVendorNotPaid)
24333 
      oprot.writeFieldEnd()
24334 
    if self.billingDateFrom is not None:
24335 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24336 
      oprot.writeI64(self.billingDateFrom)
24337 
      oprot.writeFieldEnd()
24338 
    if self.billingDateTo is not None:
24339 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24340 
      oprot.writeI64(self.billingDateTo)
24341 
      oprot.writeFieldEnd()
4875 varun.gupt 24342 
    oprot.writeFieldStop()
24343 
    oprot.writeStructEnd()
24344 
 
24345 
  def validate(self):
24346 
    return
24347 
 
24348 
 
24349 
  def __repr__(self):
24350 
    L = ['%s=%r' % (key, value)
24351 
      for key, value in self.__dict__.iteritems()]
24352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24353 
 
24354 
  def __eq__(self, other):
24355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24356 
 
24357 
  def __ne__(self, other):
24358 
    return not (self == other)
24359 
 
5481 phani.kuma 24360 
class getBilledOrders_result:
4875 varun.gupt 24361 
  """
24362 
  Attributes:
24363 
   - success
24364 
   - ex
24365 
  """
24366 
 
24367 
  thrift_spec = (
24368 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24369 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24370 
  )
24371 
 
24372 
  def __init__(self, success=None, ex=None,):
24373 
    self.success = success
24374 
    self.ex = ex
24375 
 
24376 
  def read(self, iprot):
24377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24379 
      return
24380 
    iprot.readStructBegin()
24381 
    while True:
24382 
      (fname, ftype, fid) = iprot.readFieldBegin()
24383 
      if ftype == TType.STOP:
24384 
        break
24385 
      if fid == 0:
24386 
        if ftype == TType.LIST:
24387 
          self.success = []
6188 rajveer 24388 
          (_etype587, _size584) = iprot.readListBegin()
24389 
          for _i588 in xrange(_size584):
24390 
            _elem589 = Order()
24391 
            _elem589.read(iprot)
24392 
            self.success.append(_elem589)
4875 varun.gupt 24393 
          iprot.readListEnd()
24394 
        else:
24395 
          iprot.skip(ftype)
24396 
      elif fid == 1:
24397 
        if ftype == TType.STRUCT:
24398 
          self.ex = TransactionServiceException()
24399 
          self.ex.read(iprot)
24400 
        else:
24401 
          iprot.skip(ftype)
24402 
      else:
24403 
        iprot.skip(ftype)
24404 
      iprot.readFieldEnd()
24405 
    iprot.readStructEnd()
24406 
 
24407 
  def write(self, oprot):
24408 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24409 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24410 
      return
5481 phani.kuma 24411 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24412 
    if self.success is not None:
24413 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24414 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24415 
      for iter590 in self.success:
24416 
        iter590.write(oprot)
4875 varun.gupt 24417 
      oprot.writeListEnd()
24418 
      oprot.writeFieldEnd()
24419 
    if self.ex is not None:
24420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24421 
      self.ex.write(oprot)
24422 
      oprot.writeFieldEnd()
24423 
    oprot.writeFieldStop()
24424 
    oprot.writeStructEnd()
24425 
 
24426 
  def validate(self):
24427 
    return
24428 
 
24429 
 
24430 
  def __repr__(self):
24431 
    L = ['%s=%r' % (key, value)
24432 
      for key, value in self.__dict__.iteritems()]
24433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24434 
 
24435 
  def __eq__(self, other):
24436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24437 
 
24438 
  def __ne__(self, other):
24439 
    return not (self == other)
5031 varun.gupt 24440 
 
24441 
class getStatusDistributionOfOrders_args:
24442 
  """
24443 
  Attributes:
24444 
   - startDate
24445 
   - endDate
24446 
  """
24447 
 
24448 
  thrift_spec = (
24449 
    None, # 0
24450 
    (1, TType.I64, 'startDate', None, None, ), # 1
24451 
    (2, TType.I64, 'endDate', None, None, ), # 2
24452 
  )
24453 
 
24454 
  def __init__(self, startDate=None, endDate=None,):
24455 
    self.startDate = startDate
24456 
    self.endDate = endDate
24457 
 
24458 
  def read(self, iprot):
24459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24461 
      return
24462 
    iprot.readStructBegin()
24463 
    while True:
24464 
      (fname, ftype, fid) = iprot.readFieldBegin()
24465 
      if ftype == TType.STOP:
24466 
        break
24467 
      if fid == 1:
24468 
        if ftype == TType.I64:
24469 
          self.startDate = iprot.readI64();
24470 
        else:
24471 
          iprot.skip(ftype)
24472 
      elif fid == 2:
24473 
        if ftype == TType.I64:
24474 
          self.endDate = iprot.readI64();
24475 
        else:
24476 
          iprot.skip(ftype)
24477 
      else:
24478 
        iprot.skip(ftype)
24479 
      iprot.readFieldEnd()
24480 
    iprot.readStructEnd()
24481 
 
24482 
  def write(self, oprot):
24483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24485 
      return
24486 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24487 
    if self.startDate is not None:
24488 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24489 
      oprot.writeI64(self.startDate)
24490 
      oprot.writeFieldEnd()
24491 
    if self.endDate is not None:
24492 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24493 
      oprot.writeI64(self.endDate)
24494 
      oprot.writeFieldEnd()
24495 
    oprot.writeFieldStop()
24496 
    oprot.writeStructEnd()
24497 
 
24498 
  def validate(self):
24499 
    return
24500 
 
24501 
 
24502 
  def __repr__(self):
24503 
    L = ['%s=%r' % (key, value)
24504 
      for key, value in self.__dict__.iteritems()]
24505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24506 
 
24507 
  def __eq__(self, other):
24508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24509 
 
24510 
  def __ne__(self, other):
24511 
    return not (self == other)
24512 
 
24513 
class getStatusDistributionOfOrders_result:
24514 
  """
24515 
  Attributes:
24516 
   - success
24517 
   - ex
24518 
  """
24519 
 
24520 
  thrift_spec = (
24521 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24523 
  )
24524 
 
24525 
  def __init__(self, success=None, ex=None,):
24526 
    self.success = success
24527 
    self.ex = ex
24528 
 
24529 
  def read(self, iprot):
24530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24532 
      return
24533 
    iprot.readStructBegin()
24534 
    while True:
24535 
      (fname, ftype, fid) = iprot.readFieldBegin()
24536 
      if ftype == TType.STOP:
24537 
        break
24538 
      if fid == 0:
24539 
        if ftype == TType.MAP:
24540 
          self.success = {}
6188 rajveer 24541 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24542 
          for _i595 in xrange(_size591):
24543 
            _key596 = iprot.readI64();
24544 
            _val597 = iprot.readI64();
24545 
            self.success[_key596] = _val597
5031 varun.gupt 24546 
          iprot.readMapEnd()
24547 
        else:
24548 
          iprot.skip(ftype)
24549 
      elif fid == 1:
24550 
        if ftype == TType.STRUCT:
24551 
          self.ex = TransactionServiceException()
24552 
          self.ex.read(iprot)
24553 
        else:
24554 
          iprot.skip(ftype)
24555 
      else:
24556 
        iprot.skip(ftype)
24557 
      iprot.readFieldEnd()
24558 
    iprot.readStructEnd()
24559 
 
24560 
  def write(self, oprot):
24561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24563 
      return
24564 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24565 
    if self.success is not None:
24566 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24567 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24568 
      for kiter598,viter599 in self.success.items():
24569 
        oprot.writeI64(kiter598)
24570 
        oprot.writeI64(viter599)
5031 varun.gupt 24571 
      oprot.writeMapEnd()
24572 
      oprot.writeFieldEnd()
24573 
    if self.ex is not None:
24574 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24575 
      self.ex.write(oprot)
24576 
      oprot.writeFieldEnd()
24577 
    oprot.writeFieldStop()
24578 
    oprot.writeStructEnd()
24579 
 
24580 
  def validate(self):
24581 
    return
24582 
 
24583 
 
24584 
  def __repr__(self):
24585 
    L = ['%s=%r' % (key, value)
24586 
      for key, value in self.__dict__.iteritems()]
24587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24588 
 
24589 
  def __eq__(self, other):
24590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24591 
 
24592 
  def __ne__(self, other):
24593 
    return not (self == other)
5067 varun.gupt 24594 
 
24595 
class getOrderIdsForStatus_args:
24596 
  """
24597 
  Attributes:
24598 
   - status
24599 
   - startDatetime
24600 
   - endDatetime
24601 
  """
24602 
 
24603 
  thrift_spec = (
24604 
    None, # 0
24605 
    (1, TType.I64, 'status', None, None, ), # 1
24606 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24607 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24608 
  )
24609 
 
24610 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24611 
    self.status = status
24612 
    self.startDatetime = startDatetime
24613 
    self.endDatetime = endDatetime
24614 
 
24615 
  def read(self, iprot):
24616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24618 
      return
24619 
    iprot.readStructBegin()
24620 
    while True:
24621 
      (fname, ftype, fid) = iprot.readFieldBegin()
24622 
      if ftype == TType.STOP:
24623 
        break
24624 
      if fid == 1:
24625 
        if ftype == TType.I64:
24626 
          self.status = iprot.readI64();
24627 
        else:
24628 
          iprot.skip(ftype)
24629 
      elif fid == 2:
24630 
        if ftype == TType.I64:
24631 
          self.startDatetime = iprot.readI64();
24632 
        else:
24633 
          iprot.skip(ftype)
24634 
      elif fid == 3:
24635 
        if ftype == TType.I64:
24636 
          self.endDatetime = iprot.readI64();
24637 
        else:
24638 
          iprot.skip(ftype)
24639 
      else:
24640 
        iprot.skip(ftype)
24641 
      iprot.readFieldEnd()
24642 
    iprot.readStructEnd()
24643 
 
24644 
  def write(self, oprot):
24645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24647 
      return
24648 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24649 
    if self.status is not None:
24650 
      oprot.writeFieldBegin('status', TType.I64, 1)
24651 
      oprot.writeI64(self.status)
24652 
      oprot.writeFieldEnd()
24653 
    if self.startDatetime is not None:
24654 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24655 
      oprot.writeI64(self.startDatetime)
24656 
      oprot.writeFieldEnd()
24657 
    if self.endDatetime is not None:
24658 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24659 
      oprot.writeI64(self.endDatetime)
24660 
      oprot.writeFieldEnd()
24661 
    oprot.writeFieldStop()
24662 
    oprot.writeStructEnd()
24663 
 
24664 
  def validate(self):
24665 
    return
24666 
 
24667 
 
24668 
  def __repr__(self):
24669 
    L = ['%s=%r' % (key, value)
24670 
      for key, value in self.__dict__.iteritems()]
24671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24672 
 
24673 
  def __eq__(self, other):
24674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24675 
 
24676 
  def __ne__(self, other):
24677 
    return not (self == other)
24678 
 
24679 
class getOrderIdsForStatus_result:
24680 
  """
24681 
  Attributes:
24682 
   - success
24683 
   - ex
24684 
  """
24685 
 
24686 
  thrift_spec = (
24687 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24689 
  )
24690 
 
24691 
  def __init__(self, success=None, ex=None,):
24692 
    self.success = success
24693 
    self.ex = ex
24694 
 
24695 
  def read(self, iprot):
24696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24698 
      return
24699 
    iprot.readStructBegin()
24700 
    while True:
24701 
      (fname, ftype, fid) = iprot.readFieldBegin()
24702 
      if ftype == TType.STOP:
24703 
        break
24704 
      if fid == 0:
24705 
        if ftype == TType.LIST:
24706 
          self.success = []
6188 rajveer 24707 
          (_etype603, _size600) = iprot.readListBegin()
24708 
          for _i604 in xrange(_size600):
24709 
            _elem605 = iprot.readI64();
24710 
            self.success.append(_elem605)
5067 varun.gupt 24711 
          iprot.readListEnd()
24712 
        else:
24713 
          iprot.skip(ftype)
24714 
      elif fid == 1:
24715 
        if ftype == TType.STRUCT:
24716 
          self.ex = TransactionServiceException()
24717 
          self.ex.read(iprot)
24718 
        else:
24719 
          iprot.skip(ftype)
24720 
      else:
24721 
        iprot.skip(ftype)
24722 
      iprot.readFieldEnd()
24723 
    iprot.readStructEnd()
24724 
 
24725 
  def write(self, oprot):
24726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24728 
      return
24729 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24730 
    if self.success is not None:
24731 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24732 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24733 
      for iter606 in self.success:
24734 
        oprot.writeI64(iter606)
5067 varun.gupt 24735 
      oprot.writeListEnd()
24736 
      oprot.writeFieldEnd()
24737 
    if self.ex is not None:
24738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24739 
      self.ex.write(oprot)
24740 
      oprot.writeFieldEnd()
24741 
    oprot.writeFieldStop()
24742 
    oprot.writeStructEnd()
24743 
 
24744 
  def validate(self):
24745 
    return
24746 
 
24747 
 
24748 
  def __repr__(self):
24749 
    L = ['%s=%r' % (key, value)
24750 
      for key, value in self.__dict__.iteritems()]
24751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24752 
 
24753 
  def __eq__(self, other):
24754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24755 
 
24756 
  def __ne__(self, other):
24757 
    return not (self == other)
5099 varun.gupt 24758 
 
5348 anupam.sin 24759 
class updateCODAgent_args:
24760 
  """
24761 
  Attributes:
24762 
   - agent
24763 
   - orderId
24764 
  """
24765 
 
24766 
  thrift_spec = (
24767 
    None, # 0
24768 
    (1, TType.STRING, 'agent', None, None, ), # 1
24769 
    (2, TType.I64, 'orderId', None, None, ), # 2
24770 
  )
24771 
 
24772 
  def __init__(self, agent=None, orderId=None,):
24773 
    self.agent = agent
24774 
    self.orderId = orderId
24775 
 
24776 
  def read(self, iprot):
24777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24779 
      return
24780 
    iprot.readStructBegin()
24781 
    while True:
24782 
      (fname, ftype, fid) = iprot.readFieldBegin()
24783 
      if ftype == TType.STOP:
24784 
        break
24785 
      if fid == 1:
24786 
        if ftype == TType.STRING:
24787 
          self.agent = iprot.readString();
24788 
        else:
24789 
          iprot.skip(ftype)
24790 
      elif fid == 2:
24791 
        if ftype == TType.I64:
24792 
          self.orderId = iprot.readI64();
24793 
        else:
24794 
          iprot.skip(ftype)
24795 
      else:
24796 
        iprot.skip(ftype)
24797 
      iprot.readFieldEnd()
24798 
    iprot.readStructEnd()
24799 
 
24800 
  def write(self, oprot):
24801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24803 
      return
24804 
    oprot.writeStructBegin('updateCODAgent_args')
24805 
    if self.agent is not None:
24806 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24807 
      oprot.writeString(self.agent)
24808 
      oprot.writeFieldEnd()
24809 
    if self.orderId is not None:
24810 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24811 
      oprot.writeI64(self.orderId)
24812 
      oprot.writeFieldEnd()
24813 
    oprot.writeFieldStop()
24814 
    oprot.writeStructEnd()
24815 
 
24816 
  def validate(self):
24817 
    return
24818 
 
24819 
 
24820 
  def __repr__(self):
24821 
    L = ['%s=%r' % (key, value)
24822 
      for key, value in self.__dict__.iteritems()]
24823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24824 
 
24825 
  def __eq__(self, other):
24826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24827 
 
24828 
  def __ne__(self, other):
24829 
    return not (self == other)
24830 
 
24831 
class updateCODAgent_result:
24832 
  """
24833 
  Attributes:
24834 
   - ex
24835 
  """
24836 
 
24837 
  thrift_spec = (
24838 
    None, # 0
24839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24840 
  )
24841 
 
24842 
  def __init__(self, ex=None,):
24843 
    self.ex = ex
24844 
 
24845 
  def read(self, iprot):
24846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24848 
      return
24849 
    iprot.readStructBegin()
24850 
    while True:
24851 
      (fname, ftype, fid) = iprot.readFieldBegin()
24852 
      if ftype == TType.STOP:
24853 
        break
24854 
      if fid == 1:
24855 
        if ftype == TType.STRUCT:
24856 
          self.ex = TransactionServiceException()
24857 
          self.ex.read(iprot)
24858 
        else:
24859 
          iprot.skip(ftype)
24860 
      else:
24861 
        iprot.skip(ftype)
24862 
      iprot.readFieldEnd()
24863 
    iprot.readStructEnd()
24864 
 
24865 
  def write(self, oprot):
24866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24868 
      return
24869 
    oprot.writeStructBegin('updateCODAgent_result')
24870 
    if self.ex is not None:
24871 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24872 
      self.ex.write(oprot)
24873 
      oprot.writeFieldEnd()
24874 
    oprot.writeFieldStop()
24875 
    oprot.writeStructEnd()
24876 
 
24877 
  def validate(self):
24878 
    return
24879 
 
24880 
 
24881 
  def __repr__(self):
24882 
    L = ['%s=%r' % (key, value)
24883 
      for key, value in self.__dict__.iteritems()]
24884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24885 
 
24886 
  def __eq__(self, other):
24887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24888 
 
24889 
  def __ne__(self, other):
24890 
    return not (self == other)
24891 
 
5099 varun.gupt 24892 
class updateOrderAsPaidToVendor_args:
24893 
  """
24894 
  Attributes:
24895 
   - orderId
24896 
  """
24897 
 
24898 
  thrift_spec = (
24899 
    None, # 0
24900 
    (1, TType.I64, 'orderId', None, None, ), # 1
24901 
  )
24902 
 
24903 
  def __init__(self, orderId=None,):
24904 
    self.orderId = orderId
24905 
 
24906 
  def read(self, iprot):
24907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24909 
      return
24910 
    iprot.readStructBegin()
24911 
    while True:
24912 
      (fname, ftype, fid) = iprot.readFieldBegin()
24913 
      if ftype == TType.STOP:
24914 
        break
24915 
      if fid == 1:
24916 
        if ftype == TType.I64:
24917 
          self.orderId = iprot.readI64();
24918 
        else:
24919 
          iprot.skip(ftype)
24920 
      else:
24921 
        iprot.skip(ftype)
24922 
      iprot.readFieldEnd()
24923 
    iprot.readStructEnd()
24924 
 
24925 
  def write(self, oprot):
24926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24928 
      return
24929 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24930 
    if self.orderId is not None:
24931 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24932 
      oprot.writeI64(self.orderId)
24933 
      oprot.writeFieldEnd()
24934 
    oprot.writeFieldStop()
24935 
    oprot.writeStructEnd()
24936 
 
24937 
  def validate(self):
24938 
    return
24939 
 
24940 
 
24941 
  def __repr__(self):
24942 
    L = ['%s=%r' % (key, value)
24943 
      for key, value in self.__dict__.iteritems()]
24944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24945 
 
24946 
  def __eq__(self, other):
24947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24948 
 
24949 
  def __ne__(self, other):
24950 
    return not (self == other)
24951 
 
24952 
class updateOrderAsPaidToVendor_result:
24953 
  """
24954 
  Attributes:
24955 
   - ex
24956 
  """
24957 
 
24958 
  thrift_spec = (
24959 
    None, # 0
24960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24961 
  )
24962 
 
24963 
  def __init__(self, ex=None,):
24964 
    self.ex = ex
24965 
 
24966 
  def read(self, iprot):
24967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24969 
      return
24970 
    iprot.readStructBegin()
24971 
    while True:
24972 
      (fname, ftype, fid) = iprot.readFieldBegin()
24973 
      if ftype == TType.STOP:
24974 
        break
24975 
      if fid == 1:
24976 
        if ftype == TType.STRUCT:
24977 
          self.ex = TransactionServiceException()
24978 
          self.ex.read(iprot)
24979 
        else:
24980 
          iprot.skip(ftype)
24981 
      else:
24982 
        iprot.skip(ftype)
24983 
      iprot.readFieldEnd()
24984 
    iprot.readStructEnd()
24985 
 
24986 
  def write(self, oprot):
24987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24989 
      return
24990 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24991 
    if self.ex is not None:
24992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24993 
      self.ex.write(oprot)
24994 
      oprot.writeFieldEnd()
24995 
    oprot.writeFieldStop()
24996 
    oprot.writeStructEnd()
24997 
 
24998 
  def validate(self):
24999 
    return
25000 
 
25001 
 
25002 
  def __repr__(self):
25003 
    L = ['%s=%r' % (key, value)
25004 
      for key, value in self.__dict__.iteritems()]
25005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25006 
 
25007 
  def __eq__(self, other):
25008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25009 
 
25010 
  def __ne__(self, other):
25011 
    return not (self == other)
5208 varun.gupt 25012 
 
5386 phani.kuma 25013 
class updateOrderOnlyAsPaidToVendor_args:
25014 
  """
25015 
  Attributes:
25016 
   - orderId
25017 
  """
25018 
 
25019 
  thrift_spec = (
25020 
    None, # 0
25021 
    (1, TType.I64, 'orderId', None, None, ), # 1
25022 
  )
25023 
 
25024 
  def __init__(self, orderId=None,):
25025 
    self.orderId = orderId
25026 
 
25027 
  def read(self, iprot):
25028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25030 
      return
25031 
    iprot.readStructBegin()
25032 
    while True:
25033 
      (fname, ftype, fid) = iprot.readFieldBegin()
25034 
      if ftype == TType.STOP:
25035 
        break
25036 
      if fid == 1:
25037 
        if ftype == TType.I64:
25038 
          self.orderId = iprot.readI64();
25039 
        else:
25040 
          iprot.skip(ftype)
25041 
      else:
25042 
        iprot.skip(ftype)
25043 
      iprot.readFieldEnd()
25044 
    iprot.readStructEnd()
25045 
 
25046 
  def write(self, oprot):
25047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25049 
      return
25050 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25051 
    if self.orderId is not None:
25052 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25053 
      oprot.writeI64(self.orderId)
25054 
      oprot.writeFieldEnd()
25055 
    oprot.writeFieldStop()
25056 
    oprot.writeStructEnd()
25057 
 
25058 
  def validate(self):
25059 
    return
25060 
 
25061 
 
25062 
  def __repr__(self):
25063 
    L = ['%s=%r' % (key, value)
25064 
      for key, value in self.__dict__.iteritems()]
25065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25066 
 
25067 
  def __eq__(self, other):
25068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25069 
 
25070 
  def __ne__(self, other):
25071 
    return not (self == other)
25072 
 
25073 
class updateOrderOnlyAsPaidToVendor_result:
25074 
  """
25075 
  Attributes:
25076 
   - ex
25077 
  """
25078 
 
25079 
  thrift_spec = (
25080 
    None, # 0
25081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25082 
  )
25083 
 
25084 
  def __init__(self, ex=None,):
25085 
    self.ex = ex
25086 
 
25087 
  def read(self, iprot):
25088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25090 
      return
25091 
    iprot.readStructBegin()
25092 
    while True:
25093 
      (fname, ftype, fid) = iprot.readFieldBegin()
25094 
      if ftype == TType.STOP:
25095 
        break
25096 
      if fid == 1:
25097 
        if ftype == TType.STRUCT:
25098 
          self.ex = TransactionServiceException()
25099 
          self.ex.read(iprot)
25100 
        else:
25101 
          iprot.skip(ftype)
25102 
      else:
25103 
        iprot.skip(ftype)
25104 
      iprot.readFieldEnd()
25105 
    iprot.readStructEnd()
25106 
 
25107 
  def write(self, oprot):
25108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25110 
      return
25111 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25112 
    if self.ex is not None:
25113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25114 
      self.ex.write(oprot)
25115 
      oprot.writeFieldEnd()
25116 
    oprot.writeFieldStop()
25117 
    oprot.writeStructEnd()
25118 
 
25119 
  def validate(self):
25120 
    return
25121 
 
25122 
 
25123 
  def __repr__(self):
25124 
    L = ['%s=%r' % (key, value)
25125 
      for key, value in self.__dict__.iteritems()]
25126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25127 
 
25128 
  def __eq__(self, other):
25129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25130 
 
25131 
  def __ne__(self, other):
25132 
    return not (self == other)
25133 
 
5208 varun.gupt 25134 
class getRefundedOrdersMarkedPaid_args:
25135 
 
25136 
  thrift_spec = (
25137 
  )
25138 
 
25139 
  def read(self, iprot):
25140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25142 
      return
25143 
    iprot.readStructBegin()
25144 
    while True:
25145 
      (fname, ftype, fid) = iprot.readFieldBegin()
25146 
      if ftype == TType.STOP:
25147 
        break
25148 
      else:
25149 
        iprot.skip(ftype)
25150 
      iprot.readFieldEnd()
25151 
    iprot.readStructEnd()
25152 
 
25153 
  def write(self, oprot):
25154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25156 
      return
25157 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25158 
    oprot.writeFieldStop()
25159 
    oprot.writeStructEnd()
25160 
 
25161 
  def validate(self):
25162 
    return
25163 
 
25164 
 
25165 
  def __repr__(self):
25166 
    L = ['%s=%r' % (key, value)
25167 
      for key, value in self.__dict__.iteritems()]
25168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25169 
 
25170 
  def __eq__(self, other):
25171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25172 
 
25173 
  def __ne__(self, other):
25174 
    return not (self == other)
25175 
 
25176 
class getRefundedOrdersMarkedPaid_result:
25177 
  """
25178 
  Attributes:
25179 
   - success
25180 
   - ex
25181 
  """
25182 
 
25183 
  thrift_spec = (
25184 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25186 
  )
25187 
 
25188 
  def __init__(self, success=None, ex=None,):
25189 
    self.success = success
25190 
    self.ex = ex
25191 
 
25192 
  def read(self, iprot):
25193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25195 
      return
25196 
    iprot.readStructBegin()
25197 
    while True:
25198 
      (fname, ftype, fid) = iprot.readFieldBegin()
25199 
      if ftype == TType.STOP:
25200 
        break
25201 
      if fid == 0:
25202 
        if ftype == TType.LIST:
25203 
          self.success = []
6188 rajveer 25204 
          (_etype610, _size607) = iprot.readListBegin()
25205 
          for _i611 in xrange(_size607):
25206 
            _elem612 = Order()
25207 
            _elem612.read(iprot)
25208 
            self.success.append(_elem612)
5208 varun.gupt 25209 
          iprot.readListEnd()
25210 
        else:
25211 
          iprot.skip(ftype)
25212 
      elif fid == 1:
25213 
        if ftype == TType.STRUCT:
25214 
          self.ex = TransactionServiceException()
25215 
          self.ex.read(iprot)
25216 
        else:
25217 
          iprot.skip(ftype)
25218 
      else:
25219 
        iprot.skip(ftype)
25220 
      iprot.readFieldEnd()
25221 
    iprot.readStructEnd()
25222 
 
25223 
  def write(self, oprot):
25224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25226 
      return
25227 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25228 
    if self.success is not None:
25229 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25230 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25231 
      for iter613 in self.success:
25232 
        iter613.write(oprot)
5208 varun.gupt 25233 
      oprot.writeListEnd()
25234 
      oprot.writeFieldEnd()
25235 
    if self.ex is not None:
25236 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25237 
      self.ex.write(oprot)
25238 
      oprot.writeFieldEnd()
25239 
    oprot.writeFieldStop()
25240 
    oprot.writeStructEnd()
25241 
 
25242 
  def validate(self):
25243 
    return
25244 
 
25245 
 
25246 
  def __repr__(self):
25247 
    L = ['%s=%r' % (key, value)
25248 
      for key, value in self.__dict__.iteritems()]
25249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25250 
 
25251 
  def __eq__(self, other):
25252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25253 
 
25254 
  def __ne__(self, other):
25255 
    return not (self == other)
5447 anupam.sin 25256 
 
25257 
class getAllVerificationAgents_args:
25258 
  """
25259 
  Attributes:
25260 
   - minOrderId
25261 
   - maxOrderId
25262 
  """
25263 
 
25264 
  thrift_spec = (
25265 
    None, # 0
25266 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25267 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25268 
  )
25269 
 
25270 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25271 
    self.minOrderId = minOrderId
25272 
    self.maxOrderId = maxOrderId
25273 
 
25274 
  def read(self, iprot):
25275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25277 
      return
25278 
    iprot.readStructBegin()
25279 
    while True:
25280 
      (fname, ftype, fid) = iprot.readFieldBegin()
25281 
      if ftype == TType.STOP:
25282 
        break
25283 
      if fid == 1:
25284 
        if ftype == TType.I64:
25285 
          self.minOrderId = iprot.readI64();
25286 
        else:
25287 
          iprot.skip(ftype)
25288 
      elif fid == 2:
25289 
        if ftype == TType.I64:
25290 
          self.maxOrderId = iprot.readI64();
25291 
        else:
25292 
          iprot.skip(ftype)
25293 
      else:
25294 
        iprot.skip(ftype)
25295 
      iprot.readFieldEnd()
25296 
    iprot.readStructEnd()
25297 
 
25298 
  def write(self, oprot):
25299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25301 
      return
25302 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25303 
    if self.minOrderId is not None:
25304 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25305 
      oprot.writeI64(self.minOrderId)
25306 
      oprot.writeFieldEnd()
25307 
    if self.maxOrderId is not None:
25308 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25309 
      oprot.writeI64(self.maxOrderId)
25310 
      oprot.writeFieldEnd()
25311 
    oprot.writeFieldStop()
25312 
    oprot.writeStructEnd()
25313 
 
25314 
  def validate(self):
25315 
    return
25316 
 
25317 
 
25318 
  def __repr__(self):
25319 
    L = ['%s=%r' % (key, value)
25320 
      for key, value in self.__dict__.iteritems()]
25321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25322 
 
25323 
  def __eq__(self, other):
25324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25325 
 
25326 
  def __ne__(self, other):
25327 
    return not (self == other)
25328 
 
25329 
class getAllVerificationAgents_result:
25330 
  """
25331 
  Attributes:
25332 
   - success
25333 
  """
25334 
 
25335 
  thrift_spec = (
25336 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25337 
  )
25338 
 
25339 
  def __init__(self, success=None,):
25340 
    self.success = success
25341 
 
25342 
  def read(self, iprot):
25343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25345 
      return
25346 
    iprot.readStructBegin()
25347 
    while True:
25348 
      (fname, ftype, fid) = iprot.readFieldBegin()
25349 
      if ftype == TType.STOP:
25350 
        break
25351 
      if fid == 0:
25352 
        if ftype == TType.LIST:
25353 
          self.success = []
6188 rajveer 25354 
          (_etype617, _size614) = iprot.readListBegin()
25355 
          for _i618 in xrange(_size614):
25356 
            _elem619 = CODVerificationAgent()
25357 
            _elem619.read(iprot)
25358 
            self.success.append(_elem619)
5447 anupam.sin 25359 
          iprot.readListEnd()
25360 
        else:
25361 
          iprot.skip(ftype)
25362 
      else:
25363 
        iprot.skip(ftype)
25364 
      iprot.readFieldEnd()
25365 
    iprot.readStructEnd()
25366 
 
25367 
  def write(self, oprot):
25368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25370 
      return
25371 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25372 
    if self.success is not None:
25373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25374 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25375 
      for iter620 in self.success:
25376 
        iter620.write(oprot)
5447 anupam.sin 25377 
      oprot.writeListEnd()
25378 
      oprot.writeFieldEnd()
25379 
    oprot.writeFieldStop()
25380 
    oprot.writeStructEnd()
25381 
 
25382 
  def validate(self):
25383 
    return
25384 
 
25385 
 
25386 
  def __repr__(self):
25387 
    L = ['%s=%r' % (key, value)
25388 
      for key, value in self.__dict__.iteritems()]
25389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25390 
 
25391 
  def __eq__(self, other):
25392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25393 
 
25394 
  def __ne__(self, other):
25395 
    return not (self == other)
5527 anupam.sin 25396 
 
25397 
class getAllAttributesForOrderId_args:
25398 
  """
25399 
  Attributes:
25400 
   - orderId
25401 
  """
25402 
 
25403 
  thrift_spec = (
25404 
    None, # 0
25405 
    (1, TType.I64, 'orderId', None, None, ), # 1
25406 
  )
25407 
 
25408 
  def __init__(self, orderId=None,):
25409 
    self.orderId = orderId
25410 
 
25411 
  def read(self, iprot):
25412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25414 
      return
25415 
    iprot.readStructBegin()
25416 
    while True:
25417 
      (fname, ftype, fid) = iprot.readFieldBegin()
25418 
      if ftype == TType.STOP:
25419 
        break
25420 
      if fid == 1:
25421 
        if ftype == TType.I64:
25422 
          self.orderId = iprot.readI64();
25423 
        else:
25424 
          iprot.skip(ftype)
25425 
      else:
25426 
        iprot.skip(ftype)
25427 
      iprot.readFieldEnd()
25428 
    iprot.readStructEnd()
25429 
 
25430 
  def write(self, oprot):
25431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25433 
      return
25434 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25435 
    if self.orderId is not None:
25436 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25437 
      oprot.writeI64(self.orderId)
25438 
      oprot.writeFieldEnd()
25439 
    oprot.writeFieldStop()
25440 
    oprot.writeStructEnd()
25441 
 
25442 
  def validate(self):
25443 
    return
25444 
 
25445 
 
25446 
  def __repr__(self):
25447 
    L = ['%s=%r' % (key, value)
25448 
      for key, value in self.__dict__.iteritems()]
25449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25450 
 
25451 
  def __eq__(self, other):
25452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25453 
 
25454 
  def __ne__(self, other):
25455 
    return not (self == other)
25456 
 
25457 
class getAllAttributesForOrderId_result:
25458 
  """
25459 
  Attributes:
25460 
   - success
25461 
  """
25462 
 
25463 
  thrift_spec = (
25464 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25465 
  )
25466 
 
25467 
  def __init__(self, success=None,):
25468 
    self.success = success
25469 
 
25470 
  def read(self, iprot):
25471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25473 
      return
25474 
    iprot.readStructBegin()
25475 
    while True:
25476 
      (fname, ftype, fid) = iprot.readFieldBegin()
25477 
      if ftype == TType.STOP:
25478 
        break
25479 
      if fid == 0:
25480 
        if ftype == TType.LIST:
25481 
          self.success = []
6188 rajveer 25482 
          (_etype624, _size621) = iprot.readListBegin()
25483 
          for _i625 in xrange(_size621):
25484 
            _elem626 = Attribute()
25485 
            _elem626.read(iprot)
25486 
            self.success.append(_elem626)
5527 anupam.sin 25487 
          iprot.readListEnd()
25488 
        else:
25489 
          iprot.skip(ftype)
25490 
      else:
25491 
        iprot.skip(ftype)
25492 
      iprot.readFieldEnd()
25493 
    iprot.readStructEnd()
25494 
 
25495 
  def write(self, oprot):
25496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25498 
      return
25499 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25500 
    if self.success is not None:
25501 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25502 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25503 
      for iter627 in self.success:
25504 
        iter627.write(oprot)
5527 anupam.sin 25505 
      oprot.writeListEnd()
25506 
      oprot.writeFieldEnd()
25507 
    oprot.writeFieldStop()
25508 
    oprot.writeStructEnd()
25509 
 
25510 
  def validate(self):
25511 
    return
25512 
 
25513 
 
25514 
  def __repr__(self):
25515 
    L = ['%s=%r' % (key, value)
25516 
      for key, value in self.__dict__.iteritems()]
25517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25518 
 
25519 
  def __eq__(self, other):
25520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25521 
 
25522 
  def __ne__(self, other):
25523 
    return not (self == other)
25524 
 
5676 rajveer 25525 
class setOrderAttributes_args:
25526 
  """
25527 
  Attributes:
25528 
   - orderId
25529 
   - attributes
25530 
  """
25531 
 
25532 
  thrift_spec = None
25533 
  def __init__(self, orderId=None, attributes=None,):
25534 
    self.orderId = orderId
25535 
    self.attributes = attributes
25536 
 
25537 
  def read(self, iprot):
25538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25540 
      return
25541 
    iprot.readStructBegin()
25542 
    while True:
25543 
      (fname, ftype, fid) = iprot.readFieldBegin()
25544 
      if ftype == TType.STOP:
25545 
        break
25546 
      if fid == 1:
25547 
        if ftype == TType.I64:
25548 
          self.orderId = iprot.readI64();
25549 
        else:
25550 
          iprot.skip(ftype)
25551 
      elif fid == -1:
25552 
        if ftype == TType.LIST:
25553 
          self.attributes = []
6188 rajveer 25554 
          (_etype631, _size628) = iprot.readListBegin()
25555 
          for _i632 in xrange(_size628):
25556 
            _elem633 = Attribute()
25557 
            _elem633.read(iprot)
25558 
            self.attributes.append(_elem633)
5676 rajveer 25559 
          iprot.readListEnd()
25560 
        else:
25561 
          iprot.skip(ftype)
25562 
      else:
25563 
        iprot.skip(ftype)
25564 
      iprot.readFieldEnd()
25565 
    iprot.readStructEnd()
25566 
 
25567 
  def write(self, oprot):
25568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25570 
      return
25571 
    oprot.writeStructBegin('setOrderAttributes_args')
25572 
    if self.attributes is not None:
25573 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25574 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25575 
      for iter634 in self.attributes:
25576 
        iter634.write(oprot)
5676 rajveer 25577 
      oprot.writeListEnd()
25578 
      oprot.writeFieldEnd()
25579 
    if self.orderId is not None:
25580 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25581 
      oprot.writeI64(self.orderId)
25582 
      oprot.writeFieldEnd()
25583 
    oprot.writeFieldStop()
25584 
    oprot.writeStructEnd()
25585 
 
25586 
  def validate(self):
25587 
    return
25588 
 
25589 
 
25590 
  def __repr__(self):
25591 
    L = ['%s=%r' % (key, value)
25592 
      for key, value in self.__dict__.iteritems()]
25593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25594 
 
25595 
  def __eq__(self, other):
25596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25597 
 
25598 
  def __ne__(self, other):
25599 
    return not (self == other)
25600 
 
25601 
class setOrderAttributes_result:
25602 
 
25603 
  thrift_spec = (
25604 
  )
25605 
 
25606 
  def read(self, iprot):
25607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25609 
      return
25610 
    iprot.readStructBegin()
25611 
    while True:
25612 
      (fname, ftype, fid) = iprot.readFieldBegin()
25613 
      if ftype == TType.STOP:
25614 
        break
25615 
      else:
25616 
        iprot.skip(ftype)
25617 
      iprot.readFieldEnd()
25618 
    iprot.readStructEnd()
25619 
 
25620 
  def write(self, oprot):
25621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25623 
      return
25624 
    oprot.writeStructBegin('setOrderAttributes_result')
25625 
    oprot.writeFieldStop()
25626 
    oprot.writeStructEnd()
25627 
 
25628 
  def validate(self):
25629 
    return
25630 
 
25631 
 
25632 
  def __repr__(self):
25633 
    L = ['%s=%r' % (key, value)
25634 
      for key, value in self.__dict__.iteritems()]
25635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25636 
 
25637 
  def __eq__(self, other):
25638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25639 
 
25640 
  def __ne__(self, other):
25641 
    return not (self == other)
25642 
 
5527 anupam.sin 25643 
class setOrderAttributeForTransaction_args:
25644 
  """
25645 
  Attributes:
25646 
   - transactionId
25647 
   - attribute
25648 
  """
25649 
 
25650 
  thrift_spec = None
25651 
  def __init__(self, transactionId=None, attribute=None,):
25652 
    self.transactionId = transactionId
25653 
    self.attribute = attribute
25654 
 
25655 
  def read(self, iprot):
25656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25658 
      return
25659 
    iprot.readStructBegin()
25660 
    while True:
25661 
      (fname, ftype, fid) = iprot.readFieldBegin()
25662 
      if ftype == TType.STOP:
25663 
        break
25664 
      if fid == 1:
25665 
        if ftype == TType.I64:
25666 
          self.transactionId = iprot.readI64();
25667 
        else:
25668 
          iprot.skip(ftype)
25669 
      elif fid == -1:
25670 
        if ftype == TType.STRUCT:
25671 
          self.attribute = Attribute()
25672 
          self.attribute.read(iprot)
25673 
        else:
25674 
          iprot.skip(ftype)
25675 
      else:
25676 
        iprot.skip(ftype)
25677 
      iprot.readFieldEnd()
25678 
    iprot.readStructEnd()
25679 
 
25680 
  def write(self, oprot):
25681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25683 
      return
25684 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25685 
    if self.attribute is not None:
25686 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25687 
      self.attribute.write(oprot)
25688 
      oprot.writeFieldEnd()
25689 
    if self.transactionId is not None:
25690 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25691 
      oprot.writeI64(self.transactionId)
25692 
      oprot.writeFieldEnd()
25693 
    oprot.writeFieldStop()
25694 
    oprot.writeStructEnd()
25695 
 
25696 
  def validate(self):
25697 
    return
25698 
 
25699 
 
25700 
  def __repr__(self):
25701 
    L = ['%s=%r' % (key, value)
25702 
      for key, value in self.__dict__.iteritems()]
25703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25704 
 
25705 
  def __eq__(self, other):
25706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25707 
 
25708 
  def __ne__(self, other):
25709 
    return not (self == other)
25710 
 
25711 
class setOrderAttributeForTransaction_result:
25712 
 
25713 
  thrift_spec = (
25714 
  )
25715 
 
25716 
  def read(self, iprot):
25717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25719 
      return
25720 
    iprot.readStructBegin()
25721 
    while True:
25722 
      (fname, ftype, fid) = iprot.readFieldBegin()
25723 
      if ftype == TType.STOP:
25724 
        break
25725 
      else:
25726 
        iprot.skip(ftype)
25727 
      iprot.readFieldEnd()
25728 
    iprot.readStructEnd()
25729 
 
25730 
  def write(self, oprot):
25731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25733 
      return
25734 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25735 
    oprot.writeFieldStop()
25736 
    oprot.writeStructEnd()
25737 
 
25738 
  def validate(self):
25739 
    return
25740 
 
25741 
 
25742 
  def __repr__(self):
25743 
    L = ['%s=%r' % (key, value)
25744 
      for key, value in self.__dict__.iteritems()]
25745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25746 
 
25747 
  def __eq__(self, other):
25748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25749 
 
25750 
  def __ne__(self, other):
25751 
    return not (self == other)
5553 rajveer 25752 
 
25753 
class getReceivePendingOrders_args:
25754 
  """
25755 
  Attributes:
25756 
   - storeId
25757 
  """
25758 
 
25759 
  thrift_spec = (
25760 
    None, # 0
25761 
    (1, TType.I64, 'storeId', None, None, ), # 1
25762 
  )
25763 
 
25764 
  def __init__(self, storeId=None,):
25765 
    self.storeId = storeId
25766 
 
25767 
  def read(self, iprot):
25768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25770 
      return
25771 
    iprot.readStructBegin()
25772 
    while True:
25773 
      (fname, ftype, fid) = iprot.readFieldBegin()
25774 
      if ftype == TType.STOP:
25775 
        break
25776 
      if fid == 1:
25777 
        if ftype == TType.I64:
25778 
          self.storeId = iprot.readI64();
25779 
        else:
25780 
          iprot.skip(ftype)
25781 
      else:
25782 
        iprot.skip(ftype)
25783 
      iprot.readFieldEnd()
25784 
    iprot.readStructEnd()
25785 
 
25786 
  def write(self, oprot):
25787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25789 
      return
25790 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25791 
    if self.storeId is not None:
25792 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25793 
      oprot.writeI64(self.storeId)
25794 
      oprot.writeFieldEnd()
25795 
    oprot.writeFieldStop()
25796 
    oprot.writeStructEnd()
25797 
 
25798 
  def validate(self):
25799 
    return
25800 
 
25801 
 
25802 
  def __repr__(self):
25803 
    L = ['%s=%r' % (key, value)
25804 
      for key, value in self.__dict__.iteritems()]
25805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25806 
 
25807 
  def __eq__(self, other):
25808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25809 
 
25810 
  def __ne__(self, other):
25811 
    return not (self == other)
25812 
 
25813 
class getReceivePendingOrders_result:
25814 
  """
25815 
  Attributes:
25816 
   - success
25817 
  """
25818 
 
25819 
  thrift_spec = (
25820 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25821 
  )
25822 
 
25823 
  def __init__(self, success=None,):
25824 
    self.success = success
25825 
 
25826 
  def read(self, iprot):
25827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25829 
      return
25830 
    iprot.readStructBegin()
25831 
    while True:
25832 
      (fname, ftype, fid) = iprot.readFieldBegin()
25833 
      if ftype == TType.STOP:
25834 
        break
25835 
      if fid == 0:
25836 
        if ftype == TType.LIST:
25837 
          self.success = []
6188 rajveer 25838 
          (_etype638, _size635) = iprot.readListBegin()
25839 
          for _i639 in xrange(_size635):
25840 
            _elem640 = Order()
25841 
            _elem640.read(iprot)
25842 
            self.success.append(_elem640)
5553 rajveer 25843 
          iprot.readListEnd()
25844 
        else:
25845 
          iprot.skip(ftype)
25846 
      else:
25847 
        iprot.skip(ftype)
25848 
      iprot.readFieldEnd()
25849 
    iprot.readStructEnd()
25850 
 
25851 
  def write(self, oprot):
25852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25854 
      return
25855 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25856 
    if self.success is not None:
25857 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25858 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25859 
      for iter641 in self.success:
25860 
        iter641.write(oprot)
5553 rajveer 25861 
      oprot.writeListEnd()
25862 
      oprot.writeFieldEnd()
25863 
    oprot.writeFieldStop()
25864 
    oprot.writeStructEnd()
25865 
 
25866 
  def validate(self):
25867 
    return
25868 
 
25869 
 
25870 
  def __repr__(self):
25871 
    L = ['%s=%r' % (key, value)
25872 
      for key, value in self.__dict__.iteritems()]
25873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25874 
 
25875 
  def __eq__(self, other):
25876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25877 
 
25878 
  def __ne__(self, other):
25879 
    return not (self == other)
25880 
 
25881 
class getReceivedAtStoreOrders_args:
25882 
  """
25883 
  Attributes:
25884 
   - storeId
25885 
  """
25886 
 
25887 
  thrift_spec = (
25888 
    None, # 0
25889 
    (1, TType.I64, 'storeId', None, None, ), # 1
25890 
  )
25891 
 
25892 
  def __init__(self, storeId=None,):
25893 
    self.storeId = storeId
25894 
 
25895 
  def read(self, iprot):
25896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25898 
      return
25899 
    iprot.readStructBegin()
25900 
    while True:
25901 
      (fname, ftype, fid) = iprot.readFieldBegin()
25902 
      if ftype == TType.STOP:
25903 
        break
25904 
      if fid == 1:
25905 
        if ftype == TType.I64:
25906 
          self.storeId = iprot.readI64();
25907 
        else:
25908 
          iprot.skip(ftype)
25909 
      else:
25910 
        iprot.skip(ftype)
25911 
      iprot.readFieldEnd()
25912 
    iprot.readStructEnd()
25913 
 
25914 
  def write(self, oprot):
25915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25917 
      return
25918 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25919 
    if self.storeId is not None:
25920 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25921 
      oprot.writeI64(self.storeId)
25922 
      oprot.writeFieldEnd()
25923 
    oprot.writeFieldStop()
25924 
    oprot.writeStructEnd()
25925 
 
25926 
  def validate(self):
25927 
    return
25928 
 
25929 
 
25930 
  def __repr__(self):
25931 
    L = ['%s=%r' % (key, value)
25932 
      for key, value in self.__dict__.iteritems()]
25933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25934 
 
25935 
  def __eq__(self, other):
25936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25937 
 
25938 
  def __ne__(self, other):
25939 
    return not (self == other)
25940 
 
25941 
class getReceivedAtStoreOrders_result:
25942 
  """
25943 
  Attributes:
25944 
   - success
25945 
  """
25946 
 
25947 
  thrift_spec = (
25948 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25949 
  )
25950 
 
25951 
  def __init__(self, success=None,):
25952 
    self.success = success
25953 
 
25954 
  def read(self, iprot):
25955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25957 
      return
25958 
    iprot.readStructBegin()
25959 
    while True:
25960 
      (fname, ftype, fid) = iprot.readFieldBegin()
25961 
      if ftype == TType.STOP:
25962 
        break
25963 
      if fid == 0:
25964 
        if ftype == TType.LIST:
25965 
          self.success = []
6188 rajveer 25966 
          (_etype645, _size642) = iprot.readListBegin()
25967 
          for _i646 in xrange(_size642):
25968 
            _elem647 = Order()
25969 
            _elem647.read(iprot)
25970 
            self.success.append(_elem647)
5553 rajveer 25971 
          iprot.readListEnd()
25972 
        else:
25973 
          iprot.skip(ftype)
25974 
      else:
25975 
        iprot.skip(ftype)
25976 
      iprot.readFieldEnd()
25977 
    iprot.readStructEnd()
25978 
 
25979 
  def write(self, oprot):
25980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25982 
      return
25983 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25984 
    if self.success is not None:
25985 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25986 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25987 
      for iter648 in self.success:
25988 
        iter648.write(oprot)
5553 rajveer 25989 
      oprot.writeListEnd()
25990 
      oprot.writeFieldEnd()
25991 
    oprot.writeFieldStop()
25992 
    oprot.writeStructEnd()
25993 
 
25994 
  def validate(self):
25995 
    return
25996 
 
25997 
 
25998 
  def __repr__(self):
25999 
    L = ['%s=%r' % (key, value)
26000 
      for key, value in self.__dict__.iteritems()]
26001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26002 
 
26003 
  def __eq__(self, other):
26004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26005 
 
26006 
  def __ne__(self, other):
26007 
    return not (self == other)
5593 mandeep.dh 26008 
 
5713 rajveer 26009 
class getOrdersCollectionAtStore_args:
26010 
  """
26011 
  Attributes:
26012 
   - storeId
26013 
   - fromDate
26014 
   - toDate
26015 
   - onlyCod
26016 
  """
26017 
 
26018 
  thrift_spec = (
26019 
    None, # 0
26020 
    (1, TType.I64, 'storeId', None, None, ), # 1
26021 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26022 
    (3, TType.I64, 'toDate', None, None, ), # 3
26023 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26024 
  )
26025 
 
26026 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26027 
    self.storeId = storeId
26028 
    self.fromDate = fromDate
26029 
    self.toDate = toDate
26030 
    self.onlyCod = onlyCod
26031 
 
26032 
  def read(self, iprot):
26033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26035 
      return
26036 
    iprot.readStructBegin()
26037 
    while True:
26038 
      (fname, ftype, fid) = iprot.readFieldBegin()
26039 
      if ftype == TType.STOP:
26040 
        break
26041 
      if fid == 1:
26042 
        if ftype == TType.I64:
26043 
          self.storeId = iprot.readI64();
26044 
        else:
26045 
          iprot.skip(ftype)
26046 
      elif fid == 2:
26047 
        if ftype == TType.I64:
26048 
          self.fromDate = iprot.readI64();
26049 
        else:
26050 
          iprot.skip(ftype)
26051 
      elif fid == 3:
26052 
        if ftype == TType.I64:
26053 
          self.toDate = iprot.readI64();
26054 
        else:
26055 
          iprot.skip(ftype)
26056 
      elif fid == 4:
26057 
        if ftype == TType.BOOL:
26058 
          self.onlyCod = iprot.readBool();
26059 
        else:
26060 
          iprot.skip(ftype)
26061 
      else:
26062 
        iprot.skip(ftype)
26063 
      iprot.readFieldEnd()
26064 
    iprot.readStructEnd()
26065 
 
26066 
  def write(self, oprot):
26067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26069 
      return
26070 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26071 
    if self.storeId is not None:
26072 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26073 
      oprot.writeI64(self.storeId)
26074 
      oprot.writeFieldEnd()
26075 
    if self.fromDate is not None:
26076 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26077 
      oprot.writeI64(self.fromDate)
26078 
      oprot.writeFieldEnd()
26079 
    if self.toDate is not None:
26080 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26081 
      oprot.writeI64(self.toDate)
26082 
      oprot.writeFieldEnd()
26083 
    if self.onlyCod is not None:
26084 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26085 
      oprot.writeBool(self.onlyCod)
26086 
      oprot.writeFieldEnd()
26087 
    oprot.writeFieldStop()
26088 
    oprot.writeStructEnd()
26089 
 
26090 
  def validate(self):
26091 
    return
26092 
 
26093 
 
26094 
  def __repr__(self):
26095 
    L = ['%s=%r' % (key, value)
26096 
      for key, value in self.__dict__.iteritems()]
26097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26098 
 
26099 
  def __eq__(self, other):
26100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26101 
 
26102 
  def __ne__(self, other):
26103 
    return not (self == other)
26104 
 
26105 
class getOrdersCollectionAtStore_result:
26106 
  """
26107 
  Attributes:
26108 
   - success
26109 
  """
26110 
 
26111 
  thrift_spec = (
26112 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26113 
  )
26114 
 
26115 
  def __init__(self, success=None,):
26116 
    self.success = success
26117 
 
26118 
  def read(self, iprot):
26119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26121 
      return
26122 
    iprot.readStructBegin()
26123 
    while True:
26124 
      (fname, ftype, fid) = iprot.readFieldBegin()
26125 
      if ftype == TType.STOP:
26126 
        break
26127 
      if fid == 0:
26128 
        if ftype == TType.LIST:
26129 
          self.success = []
6188 rajveer 26130 
          (_etype652, _size649) = iprot.readListBegin()
26131 
          for _i653 in xrange(_size649):
26132 
            _elem654 = Order()
26133 
            _elem654.read(iprot)
26134 
            self.success.append(_elem654)
5713 rajveer 26135 
          iprot.readListEnd()
26136 
        else:
26137 
          iprot.skip(ftype)
26138 
      else:
26139 
        iprot.skip(ftype)
26140 
      iprot.readFieldEnd()
26141 
    iprot.readStructEnd()
26142 
 
26143 
  def write(self, oprot):
26144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26146 
      return
26147 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26148 
    if self.success is not None:
26149 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26150 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26151 
      for iter655 in self.success:
26152 
        iter655.write(oprot)
5713 rajveer 26153 
      oprot.writeListEnd()
26154 
      oprot.writeFieldEnd()
26155 
    oprot.writeFieldStop()
26156 
    oprot.writeStructEnd()
26157 
 
26158 
  def validate(self):
26159 
    return
26160 
 
26161 
 
26162 
  def __repr__(self):
26163 
    L = ['%s=%r' % (key, value)
26164 
      for key, value in self.__dict__.iteritems()]
26165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26166 
 
26167 
  def __eq__(self, other):
26168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26169 
 
26170 
  def __ne__(self, other):
26171 
    return not (self == other)
26172 
 
5833 rajveer 26173 
class getOrderAttributeValue_args:
26174 
  """
26175 
  Attributes:
26176 
   - orderId
26177 
   - attributeName
26178 
  """
26179 
 
26180 
  thrift_spec = None
26181 
  def __init__(self, orderId=None, attributeName=None,):
26182 
    self.orderId = orderId
26183 
    self.attributeName = attributeName
26184 
 
26185 
  def read(self, iprot):
26186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26188 
      return
26189 
    iprot.readStructBegin()
26190 
    while True:
26191 
      (fname, ftype, fid) = iprot.readFieldBegin()
26192 
      if ftype == TType.STOP:
26193 
        break
26194 
      if fid == 1:
26195 
        if ftype == TType.I64:
26196 
          self.orderId = iprot.readI64();
26197 
        else:
26198 
          iprot.skip(ftype)
26199 
      elif fid == -1:
26200 
        if ftype == TType.STRING:
26201 
          self.attributeName = iprot.readString();
26202 
        else:
26203 
          iprot.skip(ftype)
26204 
      else:
26205 
        iprot.skip(ftype)
26206 
      iprot.readFieldEnd()
26207 
    iprot.readStructEnd()
26208 
 
26209 
  def write(self, oprot):
26210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26212 
      return
26213 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26214 
    if self.attributeName is not None:
26215 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26216 
      oprot.writeString(self.attributeName)
26217 
      oprot.writeFieldEnd()
26218 
    if self.orderId is not None:
26219 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26220 
      oprot.writeI64(self.orderId)
26221 
      oprot.writeFieldEnd()
26222 
    oprot.writeFieldStop()
26223 
    oprot.writeStructEnd()
26224 
 
26225 
  def validate(self):
26226 
    return
26227 
 
26228 
 
26229 
  def __repr__(self):
26230 
    L = ['%s=%r' % (key, value)
26231 
      for key, value in self.__dict__.iteritems()]
26232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26233 
 
26234 
  def __eq__(self, other):
26235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26236 
 
26237 
  def __ne__(self, other):
26238 
    return not (self == other)
26239 
 
26240 
class getOrderAttributeValue_result:
26241 
  """
26242 
  Attributes:
26243 
   - success
26244 
  """
26245 
 
26246 
  thrift_spec = (
26247 
    (0, TType.STRING, 'success', None, None, ), # 0
26248 
  )
26249 
 
26250 
  def __init__(self, success=None,):
26251 
    self.success = success
26252 
 
26253 
  def read(self, iprot):
26254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26256 
      return
26257 
    iprot.readStructBegin()
26258 
    while True:
26259 
      (fname, ftype, fid) = iprot.readFieldBegin()
26260 
      if ftype == TType.STOP:
26261 
        break
26262 
      if fid == 0:
26263 
        if ftype == TType.STRING:
26264 
          self.success = iprot.readString();
26265 
        else:
26266 
          iprot.skip(ftype)
26267 
      else:
26268 
        iprot.skip(ftype)
26269 
      iprot.readFieldEnd()
26270 
    iprot.readStructEnd()
26271 
 
26272 
  def write(self, oprot):
26273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26275 
      return
26276 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26277 
    if self.success is not None:
26278 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26279 
      oprot.writeString(self.success)
26280 
      oprot.writeFieldEnd()
26281 
    oprot.writeFieldStop()
26282 
    oprot.writeStructEnd()
26283 
 
26284 
  def validate(self):
26285 
    return
26286 
 
26287 
 
26288 
  def __repr__(self):
26289 
    L = ['%s=%r' % (key, value)
26290 
      for key, value in self.__dict__.iteritems()]
26291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26292 
 
26293 
  def __eq__(self, other):
26294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26295 
 
26296 
  def __ne__(self, other):
26297 
    return not (self == other)
26298 
 
6019 rajveer 26299 
class changeJacketNumber_args:
26300 
  """
26301 
  Attributes:
26302 
   - orderId
26303 
   - jacketNumber
26304 
  """
26305 
 
26306 
  thrift_spec = (
26307 
    None, # 0
26308 
    (1, TType.I64, 'orderId', None, None, ), # 1
26309 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26310 
  )
26311 
 
26312 
  def __init__(self, orderId=None, jacketNumber=None,):
26313 
    self.orderId = orderId
26314 
    self.jacketNumber = jacketNumber
26315 
 
26316 
  def read(self, iprot):
26317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26319 
      return
26320 
    iprot.readStructBegin()
26321 
    while True:
26322 
      (fname, ftype, fid) = iprot.readFieldBegin()
26323 
      if ftype == TType.STOP:
26324 
        break
26325 
      if fid == 1:
26326 
        if ftype == TType.I64:
26327 
          self.orderId = iprot.readI64();
26328 
        else:
26329 
          iprot.skip(ftype)
26330 
      elif fid == 2:
26331 
        if ftype == TType.I64:
26332 
          self.jacketNumber = iprot.readI64();
26333 
        else:
26334 
          iprot.skip(ftype)
26335 
      else:
26336 
        iprot.skip(ftype)
26337 
      iprot.readFieldEnd()
26338 
    iprot.readStructEnd()
26339 
 
26340 
  def write(self, oprot):
26341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26343 
      return
26344 
    oprot.writeStructBegin('changeJacketNumber_args')
26345 
    if self.orderId is not None:
26346 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26347 
      oprot.writeI64(self.orderId)
26348 
      oprot.writeFieldEnd()
26349 
    if self.jacketNumber is not None:
26350 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26351 
      oprot.writeI64(self.jacketNumber)
26352 
      oprot.writeFieldEnd()
26353 
    oprot.writeFieldStop()
26354 
    oprot.writeStructEnd()
26355 
 
26356 
  def validate(self):
26357 
    return
26358 
 
26359 
 
26360 
  def __repr__(self):
26361 
    L = ['%s=%r' % (key, value)
26362 
      for key, value in self.__dict__.iteritems()]
26363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26364 
 
26365 
  def __eq__(self, other):
26366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26367 
 
26368 
  def __ne__(self, other):
26369 
    return not (self == other)
26370 
 
26371 
class changeJacketNumber_result:
26372 
  """
26373 
  Attributes:
26374 
   - success
26375 
  """
26376 
 
26377 
  thrift_spec = (
26378 
    (0, TType.BOOL, 'success', None, None, ), # 0
26379 
  )
26380 
 
26381 
  def __init__(self, success=None,):
26382 
    self.success = success
26383 
 
26384 
  def read(self, iprot):
26385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26387 
      return
26388 
    iprot.readStructBegin()
26389 
    while True:
26390 
      (fname, ftype, fid) = iprot.readFieldBegin()
26391 
      if ftype == TType.STOP:
26392 
        break
26393 
      if fid == 0:
26394 
        if ftype == TType.BOOL:
26395 
          self.success = iprot.readBool();
26396 
        else:
26397 
          iprot.skip(ftype)
26398 
      else:
26399 
        iprot.skip(ftype)
26400 
      iprot.readFieldEnd()
26401 
    iprot.readStructEnd()
26402 
 
26403 
  def write(self, oprot):
26404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26406 
      return
26407 
    oprot.writeStructBegin('changeJacketNumber_result')
26408 
    if self.success is not None:
26409 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26410 
      oprot.writeBool(self.success)
26411 
      oprot.writeFieldEnd()
26412 
    oprot.writeFieldStop()
26413 
    oprot.writeStructEnd()
26414 
 
26415 
  def validate(self):
26416 
    return
26417 
 
26418 
 
26419 
  def __repr__(self):
26420 
    L = ['%s=%r' % (key, value)
26421 
      for key, value in self.__dict__.iteritems()]
26422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26423 
 
26424 
  def __eq__(self, other):
26425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26426 
 
26427 
  def __ne__(self, other):
26428 
    return not (self == other)
26429 
 
26430 
class markOrderAsRtoInTransit_args:
26431 
  """
26432 
  Attributes:
26433 
   - orderId
26434 
  """
26435 
 
26436 
  thrift_spec = (
26437 
    None, # 0
26438 
    (1, TType.I64, 'orderId', None, None, ), # 1
26439 
  )
26440 
 
26441 
  def __init__(self, orderId=None,):
26442 
    self.orderId = orderId
26443 
 
26444 
  def read(self, iprot):
26445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26447 
      return
26448 
    iprot.readStructBegin()
26449 
    while True:
26450 
      (fname, ftype, fid) = iprot.readFieldBegin()
26451 
      if ftype == TType.STOP:
26452 
        break
26453 
      if fid == 1:
26454 
        if ftype == TType.I64:
26455 
          self.orderId = iprot.readI64();
26456 
        else:
26457 
          iprot.skip(ftype)
26458 
      else:
26459 
        iprot.skip(ftype)
26460 
      iprot.readFieldEnd()
26461 
    iprot.readStructEnd()
26462 
 
26463 
  def write(self, oprot):
26464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26466 
      return
26467 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26468 
    if self.orderId is not None:
26469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26470 
      oprot.writeI64(self.orderId)
26471 
      oprot.writeFieldEnd()
26472 
    oprot.writeFieldStop()
26473 
    oprot.writeStructEnd()
26474 
 
26475 
  def validate(self):
26476 
    return
26477 
 
26478 
 
26479 
  def __repr__(self):
26480 
    L = ['%s=%r' % (key, value)
26481 
      for key, value in self.__dict__.iteritems()]
26482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26483 
 
26484 
  def __eq__(self, other):
26485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26486 
 
26487 
  def __ne__(self, other):
26488 
    return not (self == other)
26489 
 
26490 
class markOrderAsRtoInTransit_result:
26491 
  """
26492 
  Attributes:
26493 
   - success
26494 
  """
26495 
 
26496 
  thrift_spec = (
26497 
    (0, TType.BOOL, 'success', None, None, ), # 0
26498 
  )
26499 
 
26500 
  def __init__(self, success=None,):
26501 
    self.success = success
26502 
 
26503 
  def read(self, iprot):
26504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26506 
      return
26507 
    iprot.readStructBegin()
26508 
    while True:
26509 
      (fname, ftype, fid) = iprot.readFieldBegin()
26510 
      if ftype == TType.STOP:
26511 
        break
26512 
      if fid == 0:
26513 
        if ftype == TType.BOOL:
26514 
          self.success = iprot.readBool();
26515 
        else:
26516 
          iprot.skip(ftype)
26517 
      else:
26518 
        iprot.skip(ftype)
26519 
      iprot.readFieldEnd()
26520 
    iprot.readStructEnd()
26521 
 
26522 
  def write(self, oprot):
26523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26525 
      return
26526 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26527 
    if self.success is not None:
26528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26529 
      oprot.writeBool(self.success)
26530 
      oprot.writeFieldEnd()
26531 
    oprot.writeFieldStop()
26532 
    oprot.writeStructEnd()
26533 
 
26534 
  def validate(self):
26535 
    return
26536 
 
26537 
 
26538 
  def __repr__(self):
26539 
    L = ['%s=%r' % (key, value)
26540 
      for key, value in self.__dict__.iteritems()]
26541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26542 
 
26543 
  def __eq__(self, other):
26544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26545 
 
26546 
  def __ne__(self, other):
26547 
    return not (self == other)
26548 
 
5593 mandeep.dh 26549 
class acceptOrderForItem_args:
26550 
  """
26551 
  Attributes:
26552 
   - itemId
26553 
   - quantity
26554 
   - fulfilmentWarehouseId
26555 
   - billingWarehouseId
26556 
  """
26557 
 
26558 
  thrift_spec = (
26559 
    None, # 0
26560 
    (1, TType.I64, 'itemId', None, None, ), # 1
26561 
    (2, TType.I64, 'quantity', None, None, ), # 2
26562 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26563 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26564 
  )
26565 
 
26566 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26567 
    self.itemId = itemId
26568 
    self.quantity = quantity
26569 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26570 
    self.billingWarehouseId = billingWarehouseId
26571 
 
26572 
  def read(self, iprot):
26573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26575 
      return
26576 
    iprot.readStructBegin()
26577 
    while True:
26578 
      (fname, ftype, fid) = iprot.readFieldBegin()
26579 
      if ftype == TType.STOP:
26580 
        break
26581 
      if fid == 1:
26582 
        if ftype == TType.I64:
26583 
          self.itemId = iprot.readI64();
26584 
        else:
26585 
          iprot.skip(ftype)
26586 
      elif fid == 2:
26587 
        if ftype == TType.I64:
26588 
          self.quantity = iprot.readI64();
26589 
        else:
26590 
          iprot.skip(ftype)
26591 
      elif fid == 3:
26592 
        if ftype == TType.I64:
26593 
          self.fulfilmentWarehouseId = iprot.readI64();
26594 
        else:
26595 
          iprot.skip(ftype)
26596 
      elif fid == 4:
26597 
        if ftype == TType.I64:
26598 
          self.billingWarehouseId = iprot.readI64();
26599 
        else:
26600 
          iprot.skip(ftype)
26601 
      else:
26602 
        iprot.skip(ftype)
26603 
      iprot.readFieldEnd()
26604 
    iprot.readStructEnd()
26605 
 
26606 
  def write(self, oprot):
26607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26609 
      return
26610 
    oprot.writeStructBegin('acceptOrderForItem_args')
26611 
    if self.itemId is not None:
26612 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26613 
      oprot.writeI64(self.itemId)
26614 
      oprot.writeFieldEnd()
26615 
    if self.quantity is not None:
26616 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26617 
      oprot.writeI64(self.quantity)
26618 
      oprot.writeFieldEnd()
26619 
    if self.fulfilmentWarehouseId is not None:
26620 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26621 
      oprot.writeI64(self.fulfilmentWarehouseId)
26622 
      oprot.writeFieldEnd()
26623 
    if self.billingWarehouseId is not None:
26624 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26625 
      oprot.writeI64(self.billingWarehouseId)
26626 
      oprot.writeFieldEnd()
26627 
    oprot.writeFieldStop()
26628 
    oprot.writeStructEnd()
26629 
 
26630 
  def validate(self):
26631 
    return
26632 
 
26633 
 
26634 
  def __repr__(self):
26635 
    L = ['%s=%r' % (key, value)
26636 
      for key, value in self.__dict__.iteritems()]
26637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26638 
 
26639 
  def __eq__(self, other):
26640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26641 
 
26642 
  def __ne__(self, other):
26643 
    return not (self == other)
26644 
 
26645 
class acceptOrderForItem_result:
26646 
 
26647 
  thrift_spec = (
26648 
  )
26649 
 
26650 
  def read(self, iprot):
26651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26653 
      return
26654 
    iprot.readStructBegin()
26655 
    while True:
26656 
      (fname, ftype, fid) = iprot.readFieldBegin()
26657 
      if ftype == TType.STOP:
26658 
        break
26659 
      else:
26660 
        iprot.skip(ftype)
26661 
      iprot.readFieldEnd()
26662 
    iprot.readStructEnd()
26663 
 
26664 
  def write(self, oprot):
26665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26667 
      return
26668 
    oprot.writeStructBegin('acceptOrderForItem_result')
26669 
    oprot.writeFieldStop()
26670 
    oprot.writeStructEnd()
26671 
 
26672 
  def validate(self):
26673 
    return
26674 
 
26675 
 
26676 
  def __repr__(self):
26677 
    L = ['%s=%r' % (key, value)
26678 
      for key, value in self.__dict__.iteritems()]
26679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26680 
 
26681 
  def __eq__(self, other):
26682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26683 
 
26684 
  def __ne__(self, other):
26685 
    return not (self == other)
6000 mandeep.dh 26686 
 
26687 
class createRechargeOrder_args:
26688 
  """
26689 
  Attributes:
26690 
   - rechargeOrder
26691 
  """
26692 
 
26693 
  thrift_spec = (
26694 
    None, # 0
26695 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26696 
  )
26697 
 
26698 
  def __init__(self, rechargeOrder=None,):
26699 
    self.rechargeOrder = rechargeOrder
26700 
 
26701 
  def read(self, iprot):
26702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26704 
      return
26705 
    iprot.readStructBegin()
26706 
    while True:
26707 
      (fname, ftype, fid) = iprot.readFieldBegin()
26708 
      if ftype == TType.STOP:
26709 
        break
26710 
      if fid == 1:
26711 
        if ftype == TType.STRUCT:
26712 
          self.rechargeOrder = RechargeOrder()
26713 
          self.rechargeOrder.read(iprot)
26714 
        else:
26715 
          iprot.skip(ftype)
26716 
      else:
26717 
        iprot.skip(ftype)
26718 
      iprot.readFieldEnd()
26719 
    iprot.readStructEnd()
26720 
 
26721 
  def write(self, oprot):
26722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26724 
      return
26725 
    oprot.writeStructBegin('createRechargeOrder_args')
26726 
    if self.rechargeOrder is not None:
26727 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26728 
      self.rechargeOrder.write(oprot)
26729 
      oprot.writeFieldEnd()
26730 
    oprot.writeFieldStop()
26731 
    oprot.writeStructEnd()
26732 
 
26733 
  def validate(self):
26734 
    return
26735 
 
26736 
 
26737 
  def __repr__(self):
26738 
    L = ['%s=%r' % (key, value)
26739 
      for key, value in self.__dict__.iteritems()]
26740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26741 
 
26742 
  def __eq__(self, other):
26743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26744 
 
26745 
  def __ne__(self, other):
26746 
    return not (self == other)
26747 
 
26748 
class createRechargeOrder_result:
26749 
  """
26750 
  Attributes:
26751 
   - success
26752 
   - ex
26753 
  """
26754 
 
26755 
  thrift_spec = (
26756 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26757 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26758 
  )
26759 
 
26760 
  def __init__(self, success=None, ex=None,):
26761 
    self.success = success
26762 
    self.ex = ex
26763 
 
26764 
  def read(self, iprot):
26765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26767 
      return
26768 
    iprot.readStructBegin()
26769 
    while True:
26770 
      (fname, ftype, fid) = iprot.readFieldBegin()
26771 
      if ftype == TType.STOP:
26772 
        break
26773 
      if fid == 0:
26774 
        if ftype == TType.STRUCT:
26775 
          self.success = RechargeOrder()
26776 
          self.success.read(iprot)
26777 
        else:
26778 
          iprot.skip(ftype)
26779 
      elif fid == 1:
26780 
        if ftype == TType.STRUCT:
26781 
          self.ex = TransactionServiceException()
26782 
          self.ex.read(iprot)
26783 
        else:
26784 
          iprot.skip(ftype)
26785 
      else:
26786 
        iprot.skip(ftype)
26787 
      iprot.readFieldEnd()
26788 
    iprot.readStructEnd()
26789 
 
26790 
  def write(self, oprot):
26791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26793 
      return
26794 
    oprot.writeStructBegin('createRechargeOrder_result')
26795 
    if self.success is not None:
26796 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26797 
      self.success.write(oprot)
26798 
      oprot.writeFieldEnd()
26799 
    if self.ex is not None:
26800 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26801 
      self.ex.write(oprot)
26802 
      oprot.writeFieldEnd()
26803 
    oprot.writeFieldStop()
26804 
    oprot.writeStructEnd()
26805 
 
26806 
  def validate(self):
26807 
    return
26808 
 
26809 
 
26810 
  def __repr__(self):
26811 
    L = ['%s=%r' % (key, value)
26812 
      for key, value in self.__dict__.iteritems()]
26813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26814 
 
26815 
  def __eq__(self, other):
26816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26817 
 
26818 
  def __ne__(self, other):
26819 
    return not (self == other)
26820 
 
6031 rajveer 26821 
class getRechargeOrder_args:
26822 
  """
26823 
  Attributes:
26824 
   - rechargeRrderId
26825 
  """
26826 
 
26827 
  thrift_spec = (
26828 
    None, # 0
26829 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26830 
  )
26831 
 
26832 
  def __init__(self, rechargeRrderId=None,):
26833 
    self.rechargeRrderId = rechargeRrderId
26834 
 
26835 
  def read(self, iprot):
26836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26838 
      return
26839 
    iprot.readStructBegin()
26840 
    while True:
26841 
      (fname, ftype, fid) = iprot.readFieldBegin()
26842 
      if ftype == TType.STOP:
26843 
        break
26844 
      if fid == 1:
26845 
        if ftype == TType.I64:
26846 
          self.rechargeRrderId = iprot.readI64();
26847 
        else:
26848 
          iprot.skip(ftype)
26849 
      else:
26850 
        iprot.skip(ftype)
26851 
      iprot.readFieldEnd()
26852 
    iprot.readStructEnd()
26853 
 
26854 
  def write(self, oprot):
26855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26857 
      return
26858 
    oprot.writeStructBegin('getRechargeOrder_args')
26859 
    if self.rechargeRrderId is not None:
26860 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26861 
      oprot.writeI64(self.rechargeRrderId)
26862 
      oprot.writeFieldEnd()
26863 
    oprot.writeFieldStop()
26864 
    oprot.writeStructEnd()
26865 
 
26866 
  def validate(self):
26867 
    return
26868 
 
26869 
 
26870 
  def __repr__(self):
26871 
    L = ['%s=%r' % (key, value)
26872 
      for key, value in self.__dict__.iteritems()]
26873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26874 
 
26875 
  def __eq__(self, other):
26876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26877 
 
26878 
  def __ne__(self, other):
26879 
    return not (self == other)
26880 
 
26881 
class getRechargeOrder_result:
26882 
  """
26883 
  Attributes:
26884 
   - success
26885 
   - ex
26886 
  """
26887 
 
26888 
  thrift_spec = (
26889 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26890 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26891 
  )
26892 
 
26893 
  def __init__(self, success=None, ex=None,):
26894 
    self.success = success
26895 
    self.ex = ex
26896 
 
26897 
  def read(self, iprot):
26898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26900 
      return
26901 
    iprot.readStructBegin()
26902 
    while True:
26903 
      (fname, ftype, fid) = iprot.readFieldBegin()
26904 
      if ftype == TType.STOP:
26905 
        break
26906 
      if fid == 0:
26907 
        if ftype == TType.STRUCT:
26908 
          self.success = RechargeOrder()
26909 
          self.success.read(iprot)
26910 
        else:
26911 
          iprot.skip(ftype)
26912 
      elif fid == 1:
26913 
        if ftype == TType.STRUCT:
26914 
          self.ex = TransactionServiceException()
26915 
          self.ex.read(iprot)
26916 
        else:
26917 
          iprot.skip(ftype)
26918 
      else:
26919 
        iprot.skip(ftype)
26920 
      iprot.readFieldEnd()
26921 
    iprot.readStructEnd()
26922 
 
26923 
  def write(self, oprot):
26924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26926 
      return
26927 
    oprot.writeStructBegin('getRechargeOrder_result')
26928 
    if self.success is not None:
26929 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26930 
      self.success.write(oprot)
26931 
      oprot.writeFieldEnd()
26932 
    if self.ex is not None:
26933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26934 
      self.ex.write(oprot)
26935 
      oprot.writeFieldEnd()
26936 
    oprot.writeFieldStop()
26937 
    oprot.writeStructEnd()
26938 
 
26939 
  def validate(self):
26940 
    return
26941 
 
26942 
 
26943 
  def __repr__(self):
26944 
    L = ['%s=%r' % (key, value)
26945 
      for key, value in self.__dict__.iteritems()]
26946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26947 
 
26948 
  def __eq__(self, other):
26949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26950 
 
26951 
  def __ne__(self, other):
26952 
    return not (self == other)
26953 
 
26954 
class getRechargeOrders_args:
26955 
  """
26956 
  Attributes:
26957 
   - userId
26958 
  """
26959 
 
26960 
  thrift_spec = (
26961 
    None, # 0
26962 
    (1, TType.I64, 'userId', None, None, ), # 1
26963 
  )
26964 
 
26965 
  def __init__(self, userId=None,):
26966 
    self.userId = userId
26967 
 
26968 
  def read(self, iprot):
26969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26971 
      return
26972 
    iprot.readStructBegin()
26973 
    while True:
26974 
      (fname, ftype, fid) = iprot.readFieldBegin()
26975 
      if ftype == TType.STOP:
26976 
        break
26977 
      if fid == 1:
26978 
        if ftype == TType.I64:
26979 
          self.userId = iprot.readI64();
26980 
        else:
26981 
          iprot.skip(ftype)
26982 
      else:
26983 
        iprot.skip(ftype)
26984 
      iprot.readFieldEnd()
26985 
    iprot.readStructEnd()
26986 
 
26987 
  def write(self, oprot):
26988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26990 
      return
26991 
    oprot.writeStructBegin('getRechargeOrders_args')
26992 
    if self.userId is not None:
26993 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26994 
      oprot.writeI64(self.userId)
26995 
      oprot.writeFieldEnd()
26996 
    oprot.writeFieldStop()
26997 
    oprot.writeStructEnd()
26998 
 
26999 
  def validate(self):
27000 
    return
27001 
 
27002 
 
27003 
  def __repr__(self):
27004 
    L = ['%s=%r' % (key, value)
27005 
      for key, value in self.__dict__.iteritems()]
27006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27007 
 
27008 
  def __eq__(self, other):
27009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27010 
 
27011 
  def __ne__(self, other):
27012 
    return not (self == other)
27013 
 
27014 
class getRechargeOrders_result:
27015 
  """
27016 
  Attributes:
27017 
   - success
27018 
  """
27019 
 
27020 
  thrift_spec = (
27021 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27022 
  )
27023 
 
27024 
  def __init__(self, success=None,):
27025 
    self.success = success
27026 
 
27027 
  def read(self, iprot):
27028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27030 
      return
27031 
    iprot.readStructBegin()
27032 
    while True:
27033 
      (fname, ftype, fid) = iprot.readFieldBegin()
27034 
      if ftype == TType.STOP:
27035 
        break
27036 
      if fid == 0:
27037 
        if ftype == TType.LIST:
27038 
          self.success = []
6188 rajveer 27039 
          (_etype659, _size656) = iprot.readListBegin()
27040 
          for _i660 in xrange(_size656):
27041 
            _elem661 = RechargeOrder()
27042 
            _elem661.read(iprot)
27043 
            self.success.append(_elem661)
6031 rajveer 27044 
          iprot.readListEnd()
27045 
        else:
27046 
          iprot.skip(ftype)
27047 
      else:
27048 
        iprot.skip(ftype)
27049 
      iprot.readFieldEnd()
27050 
    iprot.readStructEnd()
27051 
 
27052 
  def write(self, oprot):
27053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27055 
      return
27056 
    oprot.writeStructBegin('getRechargeOrders_result')
27057 
    if self.success is not None:
27058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27060 
      for iter662 in self.success:
27061 
        iter662.write(oprot)
6031 rajveer 27062 
      oprot.writeListEnd()
27063 
      oprot.writeFieldEnd()
27064 
    oprot.writeFieldStop()
27065 
    oprot.writeStructEnd()
27066 
 
27067 
  def validate(self):
27068 
    return
27069 
 
27070 
 
27071 
  def __repr__(self):
27072 
    L = ['%s=%r' % (key, value)
27073 
      for key, value in self.__dict__.iteritems()]
27074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27075 
 
27076 
  def __eq__(self, other):
27077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27078 
 
27079 
  def __ne__(self, other):
27080 
    return not (self == other)
27081 
 
6000 mandeep.dh 27082 
class updateRechargeOrderStatus_args:
27083 
  """
27084 
  Attributes:
27085 
   - rechargeOrderId
27086 
   - rechargeOrderStatus
27087 
  """
27088 
 
27089 
  thrift_spec = (
27090 
    None, # 0
27091 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27092 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27093 
  )
27094 
 
27095 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27096 
    self.rechargeOrderId = rechargeOrderId
27097 
    self.rechargeOrderStatus = rechargeOrderStatus
27098 
 
27099 
  def read(self, iprot):
27100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27102 
      return
27103 
    iprot.readStructBegin()
27104 
    while True:
27105 
      (fname, ftype, fid) = iprot.readFieldBegin()
27106 
      if ftype == TType.STOP:
27107 
        break
27108 
      if fid == 1:
27109 
        if ftype == TType.I64:
27110 
          self.rechargeOrderId = iprot.readI64();
27111 
        else:
27112 
          iprot.skip(ftype)
27113 
      elif fid == 2:
27114 
        if ftype == TType.I32:
27115 
          self.rechargeOrderStatus = iprot.readI32();
27116 
        else:
27117 
          iprot.skip(ftype)
27118 
      else:
27119 
        iprot.skip(ftype)
27120 
      iprot.readFieldEnd()
27121 
    iprot.readStructEnd()
27122 
 
27123 
  def write(self, oprot):
27124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27126 
      return
27127 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27128 
    if self.rechargeOrderId is not None:
27129 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27130 
      oprot.writeI64(self.rechargeOrderId)
27131 
      oprot.writeFieldEnd()
27132 
    if self.rechargeOrderStatus is not None:
27133 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27134 
      oprot.writeI32(self.rechargeOrderStatus)
27135 
      oprot.writeFieldEnd()
27136 
    oprot.writeFieldStop()
27137 
    oprot.writeStructEnd()
27138 
 
27139 
  def validate(self):
27140 
    return
27141 
 
27142 
 
27143 
  def __repr__(self):
27144 
    L = ['%s=%r' % (key, value)
27145 
      for key, value in self.__dict__.iteritems()]
27146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27147 
 
27148 
  def __eq__(self, other):
27149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27150 
 
27151 
  def __ne__(self, other):
27152 
    return not (self == other)
27153 
 
27154 
class updateRechargeOrderStatus_result:
27155 
  """
27156 
  Attributes:
6031 rajveer 27157 
   - success
6000 mandeep.dh 27158 
   - ex
27159 
  """
27160 
 
27161 
  thrift_spec = (
6031 rajveer 27162 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27163 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27164 
  )
27165 
 
6031 rajveer 27166 
  def __init__(self, success=None, ex=None,):
27167 
    self.success = success
6000 mandeep.dh 27168 
    self.ex = ex
27169 
 
27170 
  def read(self, iprot):
27171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27173 
      return
27174 
    iprot.readStructBegin()
27175 
    while True:
27176 
      (fname, ftype, fid) = iprot.readFieldBegin()
27177 
      if ftype == TType.STOP:
27178 
        break
6031 rajveer 27179 
      if fid == 0:
27180 
        if ftype == TType.BOOL:
27181 
          self.success = iprot.readBool();
27182 
        else:
27183 
          iprot.skip(ftype)
27184 
      elif fid == 1:
6000 mandeep.dh 27185 
        if ftype == TType.STRUCT:
27186 
          self.ex = TransactionServiceException()
27187 
          self.ex.read(iprot)
27188 
        else:
27189 
          iprot.skip(ftype)
27190 
      else:
27191 
        iprot.skip(ftype)
27192 
      iprot.readFieldEnd()
27193 
    iprot.readStructEnd()
27194 
 
27195 
  def write(self, oprot):
27196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27198 
      return
27199 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27200 
    if self.success is not None:
27201 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27202 
      oprot.writeBool(self.success)
27203 
      oprot.writeFieldEnd()
6000 mandeep.dh 27204 
    if self.ex is not None:
27205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27206 
      self.ex.write(oprot)
27207 
      oprot.writeFieldEnd()
27208 
    oprot.writeFieldStop()
27209 
    oprot.writeStructEnd()
27210 
 
27211 
  def validate(self):
27212 
    return
27213 
 
27214 
 
27215 
  def __repr__(self):
27216 
    L = ['%s=%r' % (key, value)
27217 
      for key, value in self.__dict__.iteritems()]
27218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27219 
 
27220 
  def __eq__(self, other):
27221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27222 
 
27223 
  def __ne__(self, other):
27224 
    return not (self == other)
27225 
 
27226 
class activateRechargeTxn_args:
27227 
  """
27228 
  Attributes:
6031 rajveer 27229 
   - rechargeOrderId
6000 mandeep.dh 27230 
  """
27231 
 
27232 
  thrift_spec = (
27233 
    None, # 0
6031 rajveer 27234 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27235 
  )
27236 
 
6031 rajveer 27237 
  def __init__(self, rechargeOrderId=None,):
27238 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27239 
 
27240 
  def read(self, iprot):
27241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27243 
      return
27244 
    iprot.readStructBegin()
27245 
    while True:
27246 
      (fname, ftype, fid) = iprot.readFieldBegin()
27247 
      if ftype == TType.STOP:
27248 
        break
27249 
      if fid == 1:
6031 rajveer 27250 
        if ftype == TType.I64:
27251 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27252 
        else:
27253 
          iprot.skip(ftype)
27254 
      else:
27255 
        iprot.skip(ftype)
27256 
      iprot.readFieldEnd()
27257 
    iprot.readStructEnd()
27258 
 
27259 
  def write(self, oprot):
27260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27262 
      return
27263 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27264 
    if self.rechargeOrderId is not None:
27265 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27266 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27267 
      oprot.writeFieldEnd()
27268 
    oprot.writeFieldStop()
27269 
    oprot.writeStructEnd()
27270 
 
27271 
  def validate(self):
27272 
    return
27273 
 
27274 
 
27275 
  def __repr__(self):
27276 
    L = ['%s=%r' % (key, value)
27277 
      for key, value in self.__dict__.iteritems()]
27278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27279 
 
27280 
  def __eq__(self, other):
27281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27282 
 
27283 
  def __ne__(self, other):
27284 
    return not (self == other)
27285 
 
27286 
class activateRechargeTxn_result:
27287 
  """
27288 
  Attributes:
27289 
   - success
27290 
   - ex
27291 
  """
27292 
 
27293 
  thrift_spec = (
6031 rajveer 27294 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27296 
  )
27297 
 
27298 
  def __init__(self, success=None, ex=None,):
27299 
    self.success = success
27300 
    self.ex = ex
27301 
 
27302 
  def read(self, iprot):
27303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27305 
      return
27306 
    iprot.readStructBegin()
27307 
    while True:
27308 
      (fname, ftype, fid) = iprot.readFieldBegin()
27309 
      if ftype == TType.STOP:
27310 
        break
27311 
      if fid == 0:
6031 rajveer 27312 
        if ftype == TType.BOOL:
27313 
          self.success = iprot.readBool();
6000 mandeep.dh 27314 
        else:
27315 
          iprot.skip(ftype)
27316 
      elif fid == 1:
27317 
        if ftype == TType.STRUCT:
27318 
          self.ex = TransactionServiceException()
27319 
          self.ex.read(iprot)
27320 
        else:
27321 
          iprot.skip(ftype)
27322 
      else:
27323 
        iprot.skip(ftype)
27324 
      iprot.readFieldEnd()
27325 
    iprot.readStructEnd()
27326 
 
27327 
  def write(self, oprot):
27328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27330 
      return
27331 
    oprot.writeStructBegin('activateRechargeTxn_result')
27332 
    if self.success is not None:
6031 rajveer 27333 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27334 
      oprot.writeBool(self.success)
6000 mandeep.dh 27335 
      oprot.writeFieldEnd()
27336 
    if self.ex is not None:
27337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27338 
      self.ex.write(oprot)
27339 
      oprot.writeFieldEnd()
27340 
    oprot.writeFieldStop()
27341 
    oprot.writeStructEnd()
27342 
 
27343 
  def validate(self):
27344 
    return
27345 
 
27346 
 
27347 
  def __repr__(self):
27348 
    L = ['%s=%r' % (key, value)
27349 
      for key, value in self.__dict__.iteritems()]
27350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27351 
 
27352 
  def __eq__(self, other):
27353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27354 
 
27355 
  def __ne__(self, other):
27356 
    return not (self == other)
27357 
 
6031 rajveer 27358 
class getUserWallet_args:
6000 mandeep.dh 27359 
  """
27360 
  Attributes:
6031 rajveer 27361 
   - userId
6000 mandeep.dh 27362 
  """
27363 
 
27364 
  thrift_spec = (
27365 
    None, # 0
6031 rajveer 27366 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27367 
  )
27368 
 
6031 rajveer 27369 
  def __init__(self, userId=None,):
27370 
    self.userId = userId
6000 mandeep.dh 27371 
 
27372 
  def read(self, iprot):
27373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27375 
      return
27376 
    iprot.readStructBegin()
27377 
    while True:
27378 
      (fname, ftype, fid) = iprot.readFieldBegin()
27379 
      if ftype == TType.STOP:
27380 
        break
27381 
      if fid == 1:
27382 
        if ftype == TType.I64:
6031 rajveer 27383 
          self.userId = iprot.readI64();
6000 mandeep.dh 27384 
        else:
27385 
          iprot.skip(ftype)
27386 
      else:
27387 
        iprot.skip(ftype)
27388 
      iprot.readFieldEnd()
27389 
    iprot.readStructEnd()
27390 
 
27391 
  def write(self, oprot):
27392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27394 
      return
6031 rajveer 27395 
    oprot.writeStructBegin('getUserWallet_args')
27396 
    if self.userId is not None:
27397 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27398 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27399 
      oprot.writeFieldEnd()
27400 
    oprot.writeFieldStop()
27401 
    oprot.writeStructEnd()
27402 
 
27403 
  def validate(self):
27404 
    return
27405 
 
27406 
 
27407 
  def __repr__(self):
27408 
    L = ['%s=%r' % (key, value)
27409 
      for key, value in self.__dict__.iteritems()]
27410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27411 
 
27412 
  def __eq__(self, other):
27413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27414 
 
27415 
  def __ne__(self, other):
27416 
    return not (self == other)
27417 
 
6031 rajveer 27418 
class getUserWallet_result:
6000 mandeep.dh 27419 
  """
27420 
  Attributes:
27421 
   - success
27422 
  """
27423 
 
27424 
  thrift_spec = (
6031 rajveer 27425 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27426 
  )
27427 
 
27428 
  def __init__(self, success=None,):
27429 
    self.success = success
27430 
 
27431 
  def read(self, iprot):
27432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27434 
      return
27435 
    iprot.readStructBegin()
27436 
    while True:
27437 
      (fname, ftype, fid) = iprot.readFieldBegin()
27438 
      if ftype == TType.STOP:
27439 
        break
27440 
      if fid == 0:
6031 rajveer 27441 
        if ftype == TType.STRUCT:
27442 
          self.success = UserWallet()
27443 
          self.success.read(iprot)
6000 mandeep.dh 27444 
        else:
27445 
          iprot.skip(ftype)
27446 
      else:
27447 
        iprot.skip(ftype)
27448 
      iprot.readFieldEnd()
27449 
    iprot.readStructEnd()
27450 
 
27451 
  def write(self, oprot):
27452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27454 
      return
6031 rajveer 27455 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27456 
    if self.success is not None:
6031 rajveer 27457 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27458 
      self.success.write(oprot)
6000 mandeep.dh 27459 
      oprot.writeFieldEnd()
27460 
    oprot.writeFieldStop()
27461 
    oprot.writeStructEnd()
27462 
 
27463 
  def validate(self):
27464 
    return
27465 
 
27466 
 
27467 
  def __repr__(self):
27468 
    L = ['%s=%r' % (key, value)
27469 
      for key, value in self.__dict__.iteritems()]
27470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27471 
 
27472 
  def __eq__(self, other):
27473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27474 
 
27475 
  def __ne__(self, other):
27476 
    return not (self == other)
27477 
 
6031 rajveer 27478 
class getUserWalletHistory_args:
6000 mandeep.dh 27479 
  """
27480 
  Attributes:
6031 rajveer 27481 
   - userId
6000 mandeep.dh 27482 
  """
27483 
 
27484 
  thrift_spec = (
27485 
    None, # 0
6031 rajveer 27486 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27487 
  )
27488 
 
6031 rajveer 27489 
  def __init__(self, userId=None,):
27490 
    self.userId = userId
6000 mandeep.dh 27491 
 
27492 
  def read(self, iprot):
27493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27495 
      return
27496 
    iprot.readStructBegin()
27497 
    while True:
27498 
      (fname, ftype, fid) = iprot.readFieldBegin()
27499 
      if ftype == TType.STOP:
27500 
        break
27501 
      if fid == 1:
27502 
        if ftype == TType.I64:
6031 rajveer 27503 
          self.userId = iprot.readI64();
6000 mandeep.dh 27504 
        else:
27505 
          iprot.skip(ftype)
27506 
      else:
27507 
        iprot.skip(ftype)
27508 
      iprot.readFieldEnd()
27509 
    iprot.readStructEnd()
27510 
 
27511 
  def write(self, oprot):
27512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27514 
      return
6031 rajveer 27515 
    oprot.writeStructBegin('getUserWalletHistory_args')
27516 
    if self.userId is not None:
27517 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27518 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27519 
      oprot.writeFieldEnd()
27520 
    oprot.writeFieldStop()
27521 
    oprot.writeStructEnd()
27522 
 
27523 
  def validate(self):
27524 
    return
27525 
 
27526 
 
27527 
  def __repr__(self):
27528 
    L = ['%s=%r' % (key, value)
27529 
      for key, value in self.__dict__.iteritems()]
27530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27531 
 
27532 
  def __eq__(self, other):
27533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27534 
 
27535 
  def __ne__(self, other):
27536 
    return not (self == other)
27537 
 
6031 rajveer 27538 
class getUserWalletHistory_result:
6000 mandeep.dh 27539 
  """
27540 
  Attributes:
27541 
   - success
27542 
  """
27543 
 
27544 
  thrift_spec = (
6031 rajveer 27545 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27546 
  )
27547 
 
27548 
  def __init__(self, success=None,):
27549 
    self.success = success
27550 
 
27551 
  def read(self, iprot):
27552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27554 
      return
27555 
    iprot.readStructBegin()
27556 
    while True:
27557 
      (fname, ftype, fid) = iprot.readFieldBegin()
27558 
      if ftype == TType.STOP:
27559 
        break
27560 
      if fid == 0:
27561 
        if ftype == TType.LIST:
27562 
          self.success = []
6188 rajveer 27563 
          (_etype666, _size663) = iprot.readListBegin()
27564 
          for _i667 in xrange(_size663):
27565 
            _elem668 = UserWalletHistory()
27566 
            _elem668.read(iprot)
27567 
            self.success.append(_elem668)
6000 mandeep.dh 27568 
          iprot.readListEnd()
27569 
        else:
27570 
          iprot.skip(ftype)
27571 
      else:
27572 
        iprot.skip(ftype)
27573 
      iprot.readFieldEnd()
27574 
    iprot.readStructEnd()
27575 
 
27576 
  def write(self, oprot):
27577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27579 
      return
6031 rajveer 27580 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27581 
    if self.success is not None:
27582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27584 
      for iter669 in self.success:
27585 
        iter669.write(oprot)
6000 mandeep.dh 27586 
      oprot.writeListEnd()
27587 
      oprot.writeFieldEnd()
27588 
    oprot.writeFieldStop()
27589 
    oprot.writeStructEnd()
27590 
 
27591 
  def validate(self):
27592 
    return
27593 
 
27594 
 
27595 
  def __repr__(self):
27596 
    L = ['%s=%r' % (key, value)
27597 
      for key, value in self.__dict__.iteritems()]
27598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27599 
 
27600 
  def __eq__(self, other):
27601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27602 
 
27603 
  def __ne__(self, other):
27604 
    return not (self == other)
6048 rajveer 27605 
 
6050 anupam.sin 27606 
class getRechargeOrdersForTransaction_args:
27607 
  """
27608 
  Attributes:
27609 
   - txnId
27610 
  """
27611 
 
27612 
  thrift_spec = (
27613 
    None, # 0
27614 
    (1, TType.I64, 'txnId', None, None, ), # 1
27615 
  )
27616 
 
27617 
  def __init__(self, txnId=None,):
27618 
    self.txnId = txnId
27619 
 
27620 
  def read(self, iprot):
27621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27623 
      return
27624 
    iprot.readStructBegin()
27625 
    while True:
27626 
      (fname, ftype, fid) = iprot.readFieldBegin()
27627 
      if ftype == TType.STOP:
27628 
        break
27629 
      if fid == 1:
27630 
        if ftype == TType.I64:
27631 
          self.txnId = iprot.readI64();
27632 
        else:
27633 
          iprot.skip(ftype)
27634 
      else:
27635 
        iprot.skip(ftype)
27636 
      iprot.readFieldEnd()
27637 
    iprot.readStructEnd()
27638 
 
27639 
  def write(self, oprot):
27640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27642 
      return
27643 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27644 
    if self.txnId is not None:
27645 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27646 
      oprot.writeI64(self.txnId)
27647 
      oprot.writeFieldEnd()
27648 
    oprot.writeFieldStop()
27649 
    oprot.writeStructEnd()
27650 
 
27651 
  def validate(self):
27652 
    return
27653 
 
27654 
 
27655 
  def __repr__(self):
27656 
    L = ['%s=%r' % (key, value)
27657 
      for key, value in self.__dict__.iteritems()]
27658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27659 
 
27660 
  def __eq__(self, other):
27661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27662 
 
27663 
  def __ne__(self, other):
27664 
    return not (self == other)
27665 
 
27666 
class getRechargeOrdersForTransaction_result:
27667 
  """
27668 
  Attributes:
27669 
   - success
27670 
   - ex
27671 
  """
27672 
 
27673 
  thrift_spec = (
27674 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27676 
  )
27677 
 
27678 
  def __init__(self, success=None, ex=None,):
27679 
    self.success = success
27680 
    self.ex = ex
27681 
 
27682 
  def read(self, iprot):
27683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27685 
      return
27686 
    iprot.readStructBegin()
27687 
    while True:
27688 
      (fname, ftype, fid) = iprot.readFieldBegin()
27689 
      if ftype == TType.STOP:
27690 
        break
27691 
      if fid == 0:
27692 
        if ftype == TType.STRUCT:
27693 
          self.success = RechargeOrder()
27694 
          self.success.read(iprot)
27695 
        else:
27696 
          iprot.skip(ftype)
27697 
      elif fid == 1:
27698 
        if ftype == TType.STRUCT:
27699 
          self.ex = TransactionServiceException()
27700 
          self.ex.read(iprot)
27701 
        else:
27702 
          iprot.skip(ftype)
27703 
      else:
27704 
        iprot.skip(ftype)
27705 
      iprot.readFieldEnd()
27706 
    iprot.readStructEnd()
27707 
 
27708 
  def write(self, oprot):
27709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27711 
      return
27712 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27713 
    if self.success is not None:
27714 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27715 
      self.success.write(oprot)
27716 
      oprot.writeFieldEnd()
27717 
    if self.ex is not None:
27718 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27719 
      self.ex.write(oprot)
27720 
      oprot.writeFieldEnd()
27721 
    oprot.writeFieldStop()
27722 
    oprot.writeStructEnd()
27723 
 
27724 
  def validate(self):
27725 
    return
27726 
 
27727 
 
27728 
  def __repr__(self):
27729 
    L = ['%s=%r' % (key, value)
27730 
      for key, value in self.__dict__.iteritems()]
27731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27732 
 
27733 
  def __eq__(self, other):
27734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27735 
 
27736 
  def __ne__(self, other):
27737 
    return not (self == other)
27738 
 
6048 rajveer 27739 
class getServiceProviders_args:
27740 
  """
27741 
  Attributes:
27742 
   - rechargeType
6206 rajveer 27743 
   - onlyActive
6048 rajveer 27744 
  """
27745 
 
27746 
  thrift_spec = (
27747 
    None, # 0
27748 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27749 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27750 
  )
27751 
 
6206 rajveer 27752 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27753 
    self.rechargeType = rechargeType
6206 rajveer 27754 
    self.onlyActive = onlyActive
6048 rajveer 27755 
 
27756 
  def read(self, iprot):
27757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27759 
      return
27760 
    iprot.readStructBegin()
27761 
    while True:
27762 
      (fname, ftype, fid) = iprot.readFieldBegin()
27763 
      if ftype == TType.STOP:
27764 
        break
27765 
      if fid == 1:
27766 
        if ftype == TType.I32:
27767 
          self.rechargeType = iprot.readI32();
27768 
        else:
27769 
          iprot.skip(ftype)
6206 rajveer 27770 
      elif fid == 2:
27771 
        if ftype == TType.BOOL:
27772 
          self.onlyActive = iprot.readBool();
27773 
        else:
27774 
          iprot.skip(ftype)
6048 rajveer 27775 
      else:
27776 
        iprot.skip(ftype)
27777 
      iprot.readFieldEnd()
27778 
    iprot.readStructEnd()
27779 
 
27780 
  def write(self, oprot):
27781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27783 
      return
27784 
    oprot.writeStructBegin('getServiceProviders_args')
27785 
    if self.rechargeType is not None:
27786 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27787 
      oprot.writeI32(self.rechargeType)
27788 
      oprot.writeFieldEnd()
6206 rajveer 27789 
    if self.onlyActive is not None:
27790 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27791 
      oprot.writeBool(self.onlyActive)
27792 
      oprot.writeFieldEnd()
6048 rajveer 27793 
    oprot.writeFieldStop()
27794 
    oprot.writeStructEnd()
27795 
 
27796 
  def validate(self):
27797 
    return
27798 
 
27799 
 
27800 
  def __repr__(self):
27801 
    L = ['%s=%r' % (key, value)
27802 
      for key, value in self.__dict__.iteritems()]
27803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27804 
 
27805 
  def __eq__(self, other):
27806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27807 
 
27808 
  def __ne__(self, other):
27809 
    return not (self == other)
27810 
 
27811 
class getServiceProviders_result:
27812 
  """
27813 
  Attributes:
27814 
   - success
27815 
  """
27816 
 
27817 
  thrift_spec = (
27818 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27819 
  )
27820 
 
27821 
  def __init__(self, success=None,):
27822 
    self.success = success
27823 
 
27824 
  def read(self, iprot):
27825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27827 
      return
27828 
    iprot.readStructBegin()
27829 
    while True:
27830 
      (fname, ftype, fid) = iprot.readFieldBegin()
27831 
      if ftype == TType.STOP:
27832 
        break
27833 
      if fid == 0:
27834 
        if ftype == TType.MAP:
27835 
          self.success = {}
6188 rajveer 27836 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27837 
          for _i674 in xrange(_size670):
27838 
            _key675 = iprot.readI64();
27839 
            _val676 = iprot.readString();
27840 
            self.success[_key675] = _val676
6048 rajveer 27841 
          iprot.readMapEnd()
27842 
        else:
27843 
          iprot.skip(ftype)
27844 
      else:
27845 
        iprot.skip(ftype)
27846 
      iprot.readFieldEnd()
27847 
    iprot.readStructEnd()
27848 
 
27849 
  def write(self, oprot):
27850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27852 
      return
27853 
    oprot.writeStructBegin('getServiceProviders_result')
27854 
    if self.success is not None:
27855 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27856 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27857 
      for kiter677,viter678 in self.success.items():
27858 
        oprot.writeI64(kiter677)
27859 
        oprot.writeString(viter678)
6048 rajveer 27860 
      oprot.writeMapEnd()
27861 
      oprot.writeFieldEnd()
27862 
    oprot.writeFieldStop()
27863 
    oprot.writeStructEnd()
27864 
 
27865 
  def validate(self):
27866 
    return
27867 
 
27868 
 
27869 
  def __repr__(self):
27870 
    L = ['%s=%r' % (key, value)
27871 
      for key, value in self.__dict__.iteritems()]
27872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27873 
 
27874 
  def __eq__(self, other):
27875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27876 
 
27877 
  def __ne__(self, other):
27878 
    return not (self == other)
27879 
 
27880 
class getServiceProviderForDevice_args:
27881 
  """
27882 
  Attributes:
6049 rajveer 27883 
   - rechargeType
6048 rajveer 27884 
   - deviceNumber
27885 
  """
27886 
 
27887 
  thrift_spec = (
27888 
    None, # 0
6049 rajveer 27889 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27890 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27891 
  )
27892 
 
6049 rajveer 27893 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27894 
    self.rechargeType = rechargeType
6048 rajveer 27895 
    self.deviceNumber = deviceNumber
27896 
 
27897 
  def read(self, iprot):
27898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27900 
      return
27901 
    iprot.readStructBegin()
27902 
    while True:
27903 
      (fname, ftype, fid) = iprot.readFieldBegin()
27904 
      if ftype == TType.STOP:
27905 
        break
27906 
      if fid == 1:
6049 rajveer 27907 
        if ftype == TType.I32:
27908 
          self.rechargeType = iprot.readI32();
27909 
        else:
27910 
          iprot.skip(ftype)
27911 
      elif fid == 2:
6048 rajveer 27912 
        if ftype == TType.STRING:
27913 
          self.deviceNumber = iprot.readString();
27914 
        else:
27915 
          iprot.skip(ftype)
27916 
      else:
27917 
        iprot.skip(ftype)
27918 
      iprot.readFieldEnd()
27919 
    iprot.readStructEnd()
27920 
 
27921 
  def write(self, oprot):
27922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27924 
      return
27925 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27926 
    if self.rechargeType is not None:
27927 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27928 
      oprot.writeI32(self.rechargeType)
27929 
      oprot.writeFieldEnd()
6048 rajveer 27930 
    if self.deviceNumber is not None:
6049 rajveer 27931 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27932 
      oprot.writeString(self.deviceNumber)
27933 
      oprot.writeFieldEnd()
27934 
    oprot.writeFieldStop()
27935 
    oprot.writeStructEnd()
27936 
 
27937 
  def validate(self):
27938 
    return
27939 
 
27940 
 
27941 
  def __repr__(self):
27942 
    L = ['%s=%r' % (key, value)
27943 
      for key, value in self.__dict__.iteritems()]
27944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27945 
 
27946 
  def __eq__(self, other):
27947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27948 
 
27949 
  def __ne__(self, other):
27950 
    return not (self == other)
27951 
 
27952 
class getServiceProviderForDevice_result:
27953 
  """
27954 
  Attributes:
27955 
   - success
27956 
  """
27957 
 
27958 
  thrift_spec = (
6289 anupam.sin 27959 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27960 
  )
27961 
 
27962 
  def __init__(self, success=None,):
27963 
    self.success = success
27964 
 
27965 
  def read(self, iprot):
27966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27968 
      return
27969 
    iprot.readStructBegin()
27970 
    while True:
27971 
      (fname, ftype, fid) = iprot.readFieldBegin()
27972 
      if ftype == TType.STOP:
27973 
        break
27974 
      if fid == 0:
6289 anupam.sin 27975 
        if ftype == TType.STRUCT:
27976 
          self.success = DeviceNumberInfo()
27977 
          self.success.read(iprot)
6048 rajveer 27978 
        else:
27979 
          iprot.skip(ftype)
27980 
      else:
27981 
        iprot.skip(ftype)
27982 
      iprot.readFieldEnd()
27983 
    iprot.readStructEnd()
27984 
 
27985 
  def write(self, oprot):
27986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27988 
      return
27989 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27990 
    if self.success is not None:
6289 anupam.sin 27991 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27992 
      self.success.write(oprot)
6048 rajveer 27993 
      oprot.writeFieldEnd()
27994 
    oprot.writeFieldStop()
27995 
    oprot.writeStructEnd()
27996 
 
27997 
  def validate(self):
27998 
    return
27999 
 
28000 
 
28001 
  def __repr__(self):
28002 
    L = ['%s=%r' % (key, value)
28003 
      for key, value in self.__dict__.iteritems()]
28004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28005 
 
28006 
  def __eq__(self, other):
28007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28008 
 
28009 
  def __ne__(self, other):
28010 
    return not (self == other)
6094 rajveer 28011 
 
6269 rajveer 28012 
class validateRecharge_args:
28013 
  """
28014 
  Attributes:
28015 
   - rechargeType
28016 
   - deviceNumber
6307 anupam.sin 28017 
   - userSelectedProviderId
6269 rajveer 28018 
  """
28019 
 
28020 
  thrift_spec = (
28021 
    None, # 0
28022 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28023 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28024 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6269 rajveer 28025 
  )
28026 
 
6336 anupam.sin 28027 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None,):
6269 rajveer 28028 
    self.rechargeType = rechargeType
28029 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28030 
    self.userSelectedProviderId = userSelectedProviderId
6269 rajveer 28031 
 
28032 
  def read(self, iprot):
28033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28035 
      return
28036 
    iprot.readStructBegin()
28037 
    while True:
28038 
      (fname, ftype, fid) = iprot.readFieldBegin()
28039 
      if ftype == TType.STOP:
28040 
        break
28041 
      if fid == 1:
28042 
        if ftype == TType.I32:
28043 
          self.rechargeType = iprot.readI32();
28044 
        else:
28045 
          iprot.skip(ftype)
28046 
      elif fid == 2:
28047 
        if ftype == TType.STRING:
28048 
          self.deviceNumber = iprot.readString();
28049 
        else:
28050 
          iprot.skip(ftype)
6307 anupam.sin 28051 
      elif fid == 3:
28052 
        if ftype == TType.I64:
28053 
          self.userSelectedProviderId = iprot.readI64();
28054 
        else:
28055 
          iprot.skip(ftype)
6269 rajveer 28056 
      else:
28057 
        iprot.skip(ftype)
28058 
      iprot.readFieldEnd()
28059 
    iprot.readStructEnd()
28060 
 
28061 
  def write(self, oprot):
28062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28064 
      return
28065 
    oprot.writeStructBegin('validateRecharge_args')
28066 
    if self.rechargeType is not None:
28067 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28068 
      oprot.writeI32(self.rechargeType)
28069 
      oprot.writeFieldEnd()
28070 
    if self.deviceNumber is not None:
28071 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28072 
      oprot.writeString(self.deviceNumber)
28073 
      oprot.writeFieldEnd()
6307 anupam.sin 28074 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28075 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28076 
      oprot.writeI64(self.userSelectedProviderId)
28077 
      oprot.writeFieldEnd()
6269 rajveer 28078 
    oprot.writeFieldStop()
28079 
    oprot.writeStructEnd()
28080 
 
28081 
  def validate(self):
28082 
    return
28083 
 
28084 
 
28085 
  def __repr__(self):
28086 
    L = ['%s=%r' % (key, value)
28087 
      for key, value in self.__dict__.iteritems()]
28088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28089 
 
28090 
  def __eq__(self, other):
28091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28092 
 
28093 
  def __ne__(self, other):
28094 
    return not (self == other)
28095 
 
28096 
class validateRecharge_result:
28097 
  """
28098 
  Attributes:
28099 
   - success
28100 
  """
28101 
 
28102 
  thrift_spec = (
28103 
    (0, TType.STRING, 'success', None, None, ), # 0
28104 
  )
28105 
 
28106 
  def __init__(self, success=None,):
28107 
    self.success = success
28108 
 
28109 
  def read(self, iprot):
28110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28112 
      return
28113 
    iprot.readStructBegin()
28114 
    while True:
28115 
      (fname, ftype, fid) = iprot.readFieldBegin()
28116 
      if ftype == TType.STOP:
28117 
        break
28118 
      if fid == 0:
28119 
        if ftype == TType.STRING:
28120 
          self.success = iprot.readString();
28121 
        else:
28122 
          iprot.skip(ftype)
28123 
      else:
28124 
        iprot.skip(ftype)
28125 
      iprot.readFieldEnd()
28126 
    iprot.readStructEnd()
28127 
 
28128 
  def write(self, oprot):
28129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28131 
      return
28132 
    oprot.writeStructBegin('validateRecharge_result')
28133 
    if self.success is not None:
28134 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28135 
      oprot.writeString(self.success)
28136 
      oprot.writeFieldEnd()
28137 
    oprot.writeFieldStop()
28138 
    oprot.writeStructEnd()
28139 
 
28140 
  def validate(self):
28141 
    return
28142 
 
28143 
 
28144 
  def __repr__(self):
28145 
    L = ['%s=%r' % (key, value)
28146 
      for key, value in self.__dict__.iteritems()]
28147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28148 
 
28149 
  def __eq__(self, other):
28150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28151 
 
28152 
  def __ne__(self, other):
28153 
    return not (self == other)
28154 
 
6094 rajveer 28155 
class getRechargeOrdersForDevice_args:
28156 
  """
28157 
  Attributes:
28158 
   - deviceNumber
28159 
  """
28160 
 
28161 
  thrift_spec = (
28162 
    None, # 0
28163 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28164 
  )
28165 
 
28166 
  def __init__(self, deviceNumber=None,):
28167 
    self.deviceNumber = deviceNumber
28168 
 
28169 
  def read(self, iprot):
28170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28172 
      return
28173 
    iprot.readStructBegin()
28174 
    while True:
28175 
      (fname, ftype, fid) = iprot.readFieldBegin()
28176 
      if ftype == TType.STOP:
28177 
        break
28178 
      if fid == 1:
28179 
        if ftype == TType.STRING:
28180 
          self.deviceNumber = iprot.readString();
28181 
        else:
28182 
          iprot.skip(ftype)
28183 
      else:
28184 
        iprot.skip(ftype)
28185 
      iprot.readFieldEnd()
28186 
    iprot.readStructEnd()
28187 
 
28188 
  def write(self, oprot):
28189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28191 
      return
28192 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28193 
    if self.deviceNumber is not None:
28194 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28195 
      oprot.writeString(self.deviceNumber)
28196 
      oprot.writeFieldEnd()
28197 
    oprot.writeFieldStop()
28198 
    oprot.writeStructEnd()
28199 
 
28200 
  def validate(self):
28201 
    return
28202 
 
28203 
 
28204 
  def __repr__(self):
28205 
    L = ['%s=%r' % (key, value)
28206 
      for key, value in self.__dict__.iteritems()]
28207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28208 
 
28209 
  def __eq__(self, other):
28210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28211 
 
28212 
  def __ne__(self, other):
28213 
    return not (self == other)
28214 
 
28215 
class getRechargeOrdersForDevice_result:
28216 
  """
28217 
  Attributes:
28218 
   - success
28219 
  """
28220 
 
28221 
  thrift_spec = (
28222 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28223 
  )
28224 
 
28225 
  def __init__(self, success=None,):
28226 
    self.success = success
28227 
 
28228 
  def read(self, iprot):
28229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28231 
      return
28232 
    iprot.readStructBegin()
28233 
    while True:
28234 
      (fname, ftype, fid) = iprot.readFieldBegin()
28235 
      if ftype == TType.STOP:
28236 
        break
28237 
      if fid == 0:
28238 
        if ftype == TType.LIST:
28239 
          self.success = []
6188 rajveer 28240 
          (_etype682, _size679) = iprot.readListBegin()
28241 
          for _i683 in xrange(_size679):
28242 
            _elem684 = RechargeOrder()
28243 
            _elem684.read(iprot)
28244 
            self.success.append(_elem684)
6094 rajveer 28245 
          iprot.readListEnd()
28246 
        else:
28247 
          iprot.skip(ftype)
28248 
      else:
28249 
        iprot.skip(ftype)
28250 
      iprot.readFieldEnd()
28251 
    iprot.readStructEnd()
28252 
 
28253 
  def write(self, oprot):
28254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28256 
      return
28257 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28258 
    if self.success is not None:
28259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28261 
      for iter685 in self.success:
28262 
        iter685.write(oprot)
6094 rajveer 28263 
      oprot.writeListEnd()
28264 
      oprot.writeFieldEnd()
28265 
    oprot.writeFieldStop()
28266 
    oprot.writeStructEnd()
28267 
 
28268 
  def validate(self):
28269 
    return
28270 
 
28271 
 
28272 
  def __repr__(self):
28273 
    L = ['%s=%r' % (key, value)
28274 
      for key, value in self.__dict__.iteritems()]
28275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28276 
 
28277 
  def __eq__(self, other):
28278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28279 
 
28280 
  def __ne__(self, other):
28281 
    return not (self == other)
28282 
 
28283 
class addAmountToWallet_args:
28284 
  """
28285 
  Attributes:
28286 
   - userId
28287 
   - orderId
28288 
   - amount
28289 
  """
28290 
 
28291 
  thrift_spec = (
28292 
    None, # 0
28293 
    (1, TType.I64, 'userId', None, None, ), # 1
28294 
    (2, TType.I64, 'orderId', None, None, ), # 2
28295 
    (3, TType.I64, 'amount', None, None, ), # 3
28296 
  )
28297 
 
28298 
  def __init__(self, userId=None, orderId=None, amount=None,):
28299 
    self.userId = userId
28300 
    self.orderId = orderId
28301 
    self.amount = amount
28302 
 
28303 
  def read(self, iprot):
28304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28306 
      return
28307 
    iprot.readStructBegin()
28308 
    while True:
28309 
      (fname, ftype, fid) = iprot.readFieldBegin()
28310 
      if ftype == TType.STOP:
28311 
        break
28312 
      if fid == 1:
28313 
        if ftype == TType.I64:
28314 
          self.userId = iprot.readI64();
28315 
        else:
28316 
          iprot.skip(ftype)
28317 
      elif fid == 2:
28318 
        if ftype == TType.I64:
28319 
          self.orderId = iprot.readI64();
28320 
        else:
28321 
          iprot.skip(ftype)
28322 
      elif fid == 3:
28323 
        if ftype == TType.I64:
28324 
          self.amount = iprot.readI64();
28325 
        else:
28326 
          iprot.skip(ftype)
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_args')
28337 
    if self.userId is not None:
28338 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28339 
      oprot.writeI64(self.userId)
28340 
      oprot.writeFieldEnd()
28341 
    if self.orderId is not None:
28342 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28343 
      oprot.writeI64(self.orderId)
28344 
      oprot.writeFieldEnd()
28345 
    if self.amount is not None:
28346 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28347 
      oprot.writeI64(self.amount)
28348 
      oprot.writeFieldEnd()
28349 
    oprot.writeFieldStop()
28350 
    oprot.writeStructEnd()
28351 
 
28352 
  def validate(self):
28353 
    return
28354 
 
28355 
 
28356 
  def __repr__(self):
28357 
    L = ['%s=%r' % (key, value)
28358 
      for key, value in self.__dict__.iteritems()]
28359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28360 
 
28361 
  def __eq__(self, other):
28362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28363 
 
28364 
  def __ne__(self, other):
28365 
    return not (self == other)
28366 
 
28367 
class addAmountToWallet_result:
28368 
 
28369 
  thrift_spec = (
28370 
  )
28371 
 
28372 
  def read(self, iprot):
28373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28375 
      return
28376 
    iprot.readStructBegin()
28377 
    while True:
28378 
      (fname, ftype, fid) = iprot.readFieldBegin()
28379 
      if ftype == TType.STOP:
28380 
        break
28381 
      else:
28382 
        iprot.skip(ftype)
28383 
      iprot.readFieldEnd()
28384 
    iprot.readStructEnd()
28385 
 
28386 
  def write(self, oprot):
28387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28389 
      return
28390 
    oprot.writeStructBegin('addAmountToWallet_result')
28391 
    oprot.writeFieldStop()
28392 
    oprot.writeStructEnd()
28393 
 
28394 
  def validate(self):
28395 
    return
28396 
 
28397 
 
28398 
  def __repr__(self):
28399 
    L = ['%s=%r' % (key, value)
28400 
      for key, value in self.__dict__.iteritems()]
28401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28402 
 
28403 
  def __eq__(self, other):
28404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28405 
 
28406 
  def __ne__(self, other):
28407 
    return not (self == other)
6154 rajveer 28408 
 
6188 rajveer 28409 
class getRechargeStatistics_args:
28410 
 
28411 
  thrift_spec = (
28412 
  )
28413 
 
28414 
  def read(self, iprot):
28415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28417 
      return
28418 
    iprot.readStructBegin()
28419 
    while True:
28420 
      (fname, ftype, fid) = iprot.readFieldBegin()
28421 
      if ftype == TType.STOP:
28422 
        break
28423 
      else:
28424 
        iprot.skip(ftype)
28425 
      iprot.readFieldEnd()
28426 
    iprot.readStructEnd()
28427 
 
28428 
  def write(self, oprot):
28429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28431 
      return
28432 
    oprot.writeStructBegin('getRechargeStatistics_args')
28433 
    oprot.writeFieldStop()
28434 
    oprot.writeStructEnd()
28435 
 
28436 
  def validate(self):
28437 
    return
28438 
 
28439 
 
28440 
  def __repr__(self):
28441 
    L = ['%s=%r' % (key, value)
28442 
      for key, value in self.__dict__.iteritems()]
28443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28444 
 
28445 
  def __eq__(self, other):
28446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28447 
 
28448 
  def __ne__(self, other):
28449 
    return not (self == other)
28450 
 
28451 
class getRechargeStatistics_result:
28452 
  """
28453 
  Attributes:
28454 
   - success
28455 
  """
28456 
 
28457 
  thrift_spec = (
28458 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28459 
  )
28460 
 
28461 
  def __init__(self, success=None,):
28462 
    self.success = success
28463 
 
28464 
  def read(self, iprot):
28465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28467 
      return
28468 
    iprot.readStructBegin()
28469 
    while True:
28470 
      (fname, ftype, fid) = iprot.readFieldBegin()
28471 
      if ftype == TType.STOP:
28472 
        break
28473 
      if fid == 0:
28474 
        if ftype == TType.STRUCT:
28475 
          self.success = RechargeStatistics()
28476 
          self.success.read(iprot)
28477 
        else:
28478 
          iprot.skip(ftype)
28479 
      else:
28480 
        iprot.skip(ftype)
28481 
      iprot.readFieldEnd()
28482 
    iprot.readStructEnd()
28483 
 
28484 
  def write(self, oprot):
28485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28487 
      return
28488 
    oprot.writeStructBegin('getRechargeStatistics_result')
28489 
    if self.success is not None:
28490 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28491 
      self.success.write(oprot)
28492 
      oprot.writeFieldEnd()
28493 
    oprot.writeFieldStop()
28494 
    oprot.writeStructEnd()
28495 
 
28496 
  def validate(self):
28497 
    return
28498 
 
28499 
 
28500 
  def __repr__(self):
28501 
    L = ['%s=%r' % (key, value)
28502 
      for key, value in self.__dict__.iteritems()]
28503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28504 
 
28505 
  def __eq__(self, other):
28506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28507 
 
28508 
  def __ne__(self, other):
28509 
    return not (self == other)
28510 
 
6154 rajveer 28511 
class getRechargeOrdersForStatus_args:
28512 
  """
28513 
  Attributes:
28514 
   - status
28515 
  """
28516 
 
28517 
  thrift_spec = (
28518 
    None, # 0
28519 
    (1, TType.I64, 'status', None, None, ), # 1
28520 
  )
28521 
 
28522 
  def __init__(self, status=None,):
28523 
    self.status = status
28524 
 
28525 
  def read(self, iprot):
28526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28528 
      return
28529 
    iprot.readStructBegin()
28530 
    while True:
28531 
      (fname, ftype, fid) = iprot.readFieldBegin()
28532 
      if ftype == TType.STOP:
28533 
        break
28534 
      if fid == 1:
28535 
        if ftype == TType.I64:
28536 
          self.status = iprot.readI64();
28537 
        else:
28538 
          iprot.skip(ftype)
28539 
      else:
28540 
        iprot.skip(ftype)
28541 
      iprot.readFieldEnd()
28542 
    iprot.readStructEnd()
28543 
 
28544 
  def write(self, oprot):
28545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28547 
      return
28548 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28549 
    if self.status is not None:
28550 
      oprot.writeFieldBegin('status', TType.I64, 1)
28551 
      oprot.writeI64(self.status)
28552 
      oprot.writeFieldEnd()
28553 
    oprot.writeFieldStop()
28554 
    oprot.writeStructEnd()
28555 
 
28556 
  def validate(self):
28557 
    return
28558 
 
28559 
 
28560 
  def __repr__(self):
28561 
    L = ['%s=%r' % (key, value)
28562 
      for key, value in self.__dict__.iteritems()]
28563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28564 
 
28565 
  def __eq__(self, other):
28566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28567 
 
28568 
  def __ne__(self, other):
28569 
    return not (self == other)
28570 
 
28571 
class getRechargeOrdersForStatus_result:
28572 
  """
28573 
  Attributes:
28574 
   - success
28575 
  """
28576 
 
28577 
  thrift_spec = (
28578 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28579 
  )
28580 
 
28581 
  def __init__(self, success=None,):
28582 
    self.success = success
28583 
 
28584 
  def read(self, iprot):
28585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28587 
      return
28588 
    iprot.readStructBegin()
28589 
    while True:
28590 
      (fname, ftype, fid) = iprot.readFieldBegin()
28591 
      if ftype == TType.STOP:
28592 
        break
28593 
      if fid == 0:
28594 
        if ftype == TType.LIST:
28595 
          self.success = []
6188 rajveer 28596 
          (_etype689, _size686) = iprot.readListBegin()
28597 
          for _i690 in xrange(_size686):
28598 
            _elem691 = RechargeOrder()
28599 
            _elem691.read(iprot)
28600 
            self.success.append(_elem691)
6154 rajveer 28601 
          iprot.readListEnd()
28602 
        else:
28603 
          iprot.skip(ftype)
28604 
      else:
28605 
        iprot.skip(ftype)
28606 
      iprot.readFieldEnd()
28607 
    iprot.readStructEnd()
28608 
 
28609 
  def write(self, oprot):
28610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28612 
      return
28613 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28614 
    if self.success is not None:
28615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28617 
      for iter692 in self.success:
28618 
        iter692.write(oprot)
6154 rajveer 28619 
      oprot.writeListEnd()
28620 
      oprot.writeFieldEnd()
28621 
    oprot.writeFieldStop()
28622 
    oprot.writeStructEnd()
28623 
 
28624 
  def validate(self):
28625 
    return
28626 
 
28627 
 
28628 
  def __repr__(self):
28629 
    L = ['%s=%r' % (key, value)
28630 
      for key, value in self.__dict__.iteritems()]
28631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28632 
 
28633 
  def __eq__(self, other):
28634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28635 
 
28636 
  def __ne__(self, other):
28637 
    return not (self == other)
6159 rajveer 28638 
 
28639 
class getPlansForOperator_args:
28640 
  """
28641 
  Attributes:
28642 
   - operatorId
28643 
  """
28644 
 
28645 
  thrift_spec = (
28646 
    None, # 0
28647 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28648 
  )
28649 
 
28650 
  def __init__(self, operatorId=None,):
28651 
    self.operatorId = operatorId
28652 
 
28653 
  def read(self, iprot):
28654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28656 
      return
28657 
    iprot.readStructBegin()
28658 
    while True:
28659 
      (fname, ftype, fid) = iprot.readFieldBegin()
28660 
      if ftype == TType.STOP:
28661 
        break
28662 
      if fid == 1:
28663 
        if ftype == TType.I64:
28664 
          self.operatorId = iprot.readI64();
28665 
        else:
28666 
          iprot.skip(ftype)
28667 
      else:
28668 
        iprot.skip(ftype)
28669 
      iprot.readFieldEnd()
28670 
    iprot.readStructEnd()
28671 
 
28672 
  def write(self, oprot):
28673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28675 
      return
28676 
    oprot.writeStructBegin('getPlansForOperator_args')
28677 
    if self.operatorId is not None:
28678 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28679 
      oprot.writeI64(self.operatorId)
28680 
      oprot.writeFieldEnd()
28681 
    oprot.writeFieldStop()
28682 
    oprot.writeStructEnd()
28683 
 
28684 
  def validate(self):
28685 
    return
28686 
 
28687 
 
28688 
  def __repr__(self):
28689 
    L = ['%s=%r' % (key, value)
28690 
      for key, value in self.__dict__.iteritems()]
28691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28692 
 
28693 
  def __eq__(self, other):
28694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28695 
 
28696 
  def __ne__(self, other):
28697 
    return not (self == other)
28698 
 
28699 
class getPlansForOperator_result:
28700 
  """
28701 
  Attributes:
28702 
   - success
28703 
  """
28704 
 
28705 
  thrift_spec = (
28706 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28707 
  )
28708 
 
28709 
  def __init__(self, success=None,):
28710 
    self.success = success
28711 
 
28712 
  def read(self, iprot):
28713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28715 
      return
28716 
    iprot.readStructBegin()
28717 
    while True:
28718 
      (fname, ftype, fid) = iprot.readFieldBegin()
28719 
      if ftype == TType.STOP:
28720 
        break
28721 
      if fid == 0:
28722 
        if ftype == TType.LIST:
28723 
          self.success = []
6188 rajveer 28724 
          (_etype696, _size693) = iprot.readListBegin()
28725 
          for _i697 in xrange(_size693):
28726 
            _elem698 = RechargePlan()
28727 
            _elem698.read(iprot)
28728 
            self.success.append(_elem698)
6159 rajveer 28729 
          iprot.readListEnd()
28730 
        else:
28731 
          iprot.skip(ftype)
28732 
      else:
28733 
        iprot.skip(ftype)
28734 
      iprot.readFieldEnd()
28735 
    iprot.readStructEnd()
28736 
 
28737 
  def write(self, oprot):
28738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28740 
      return
28741 
    oprot.writeStructBegin('getPlansForOperator_result')
28742 
    if self.success is not None:
28743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28745 
      for iter699 in self.success:
28746 
        iter699.write(oprot)
6159 rajveer 28747 
      oprot.writeListEnd()
28748 
      oprot.writeFieldEnd()
28749 
    oprot.writeFieldStop()
28750 
    oprot.writeStructEnd()
28751 
 
28752 
  def validate(self):
28753 
    return
28754 
 
28755 
 
28756 
  def __repr__(self):
28757 
    L = ['%s=%r' % (key, value)
28758 
      for key, value in self.__dict__.iteritems()]
28759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28760 
 
28761 
  def __eq__(self, other):
28762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28763 
 
28764 
  def __ne__(self, other):
28765 
    return not (self == other)
6289 anupam.sin 28766 
 
28767 
class getRechargeDenominations_args:
28768 
  """
28769 
  Attributes:
28770 
   - operatorId
6307 anupam.sin 28771 
   - circleCode
6289 anupam.sin 28772 
   - denominationType
28773 
  """
28774 
 
28775 
  thrift_spec = (
28776 
    None, # 0
28777 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28778 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28779 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28780 
  )
28781 
 
6307 anupam.sin 28782 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28783 
    self.operatorId = operatorId
6307 anupam.sin 28784 
    self.circleCode = circleCode
6289 anupam.sin 28785 
    self.denominationType = denominationType
28786 
 
28787 
  def read(self, iprot):
28788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28790 
      return
28791 
    iprot.readStructBegin()
28792 
    while True:
28793 
      (fname, ftype, fid) = iprot.readFieldBegin()
28794 
      if ftype == TType.STOP:
28795 
        break
28796 
      if fid == 1:
28797 
        if ftype == TType.I64:
28798 
          self.operatorId = iprot.readI64();
28799 
        else:
28800 
          iprot.skip(ftype)
28801 
      elif fid == 2:
28802 
        if ftype == TType.STRING:
6307 anupam.sin 28803 
          self.circleCode = iprot.readString();
6289 anupam.sin 28804 
        else:
28805 
          iprot.skip(ftype)
28806 
      elif fid == 3:
28807 
        if ftype == TType.I32:
28808 
          self.denominationType = iprot.readI32();
28809 
        else:
28810 
          iprot.skip(ftype)
28811 
      else:
28812 
        iprot.skip(ftype)
28813 
      iprot.readFieldEnd()
28814 
    iprot.readStructEnd()
28815 
 
28816 
  def write(self, oprot):
28817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28819 
      return
28820 
    oprot.writeStructBegin('getRechargeDenominations_args')
28821 
    if self.operatorId is not None:
28822 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28823 
      oprot.writeI64(self.operatorId)
28824 
      oprot.writeFieldEnd()
6307 anupam.sin 28825 
    if self.circleCode is not None:
28826 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28827 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28828 
      oprot.writeFieldEnd()
28829 
    if self.denominationType is not None:
28830 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28831 
      oprot.writeI32(self.denominationType)
28832 
      oprot.writeFieldEnd()
28833 
    oprot.writeFieldStop()
28834 
    oprot.writeStructEnd()
28835 
 
28836 
  def validate(self):
28837 
    return
28838 
 
28839 
 
28840 
  def __repr__(self):
28841 
    L = ['%s=%r' % (key, value)
28842 
      for key, value in self.__dict__.iteritems()]
28843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28844 
 
28845 
  def __eq__(self, other):
28846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28847 
 
28848 
  def __ne__(self, other):
28849 
    return not (self == other)
28850 
 
28851 
class getRechargeDenominations_result:
28852 
  """
28853 
  Attributes:
28854 
   - success
28855 
   - ex
28856 
  """
28857 
 
28858 
  thrift_spec = (
28859 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28860 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28861 
  )
28862 
 
28863 
  def __init__(self, success=None, ex=None,):
28864 
    self.success = success
28865 
    self.ex = ex
28866 
 
28867 
  def read(self, iprot):
28868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28870 
      return
28871 
    iprot.readStructBegin()
28872 
    while True:
28873 
      (fname, ftype, fid) = iprot.readFieldBegin()
28874 
      if ftype == TType.STOP:
28875 
        break
28876 
      if fid == 0:
28877 
        if ftype == TType.LIST:
28878 
          self.success = []
28879 
          (_etype703, _size700) = iprot.readListBegin()
28880 
          for _i704 in xrange(_size700):
28881 
            _elem705 = RechargeDenomination()
28882 
            _elem705.read(iprot)
28883 
            self.success.append(_elem705)
28884 
          iprot.readListEnd()
28885 
        else:
28886 
          iprot.skip(ftype)
28887 
      elif fid == 1:
28888 
        if ftype == TType.STRUCT:
28889 
          self.ex = TransactionServiceException()
28890 
          self.ex.read(iprot)
28891 
        else:
28892 
          iprot.skip(ftype)
28893 
      else:
28894 
        iprot.skip(ftype)
28895 
      iprot.readFieldEnd()
28896 
    iprot.readStructEnd()
28897 
 
28898 
  def write(self, oprot):
28899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28901 
      return
28902 
    oprot.writeStructBegin('getRechargeDenominations_result')
28903 
    if self.success is not None:
28904 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28905 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28906 
      for iter706 in self.success:
28907 
        iter706.write(oprot)
28908 
      oprot.writeListEnd()
28909 
      oprot.writeFieldEnd()
28910 
    if self.ex is not None:
28911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28912 
      self.ex.write(oprot)
28913 
      oprot.writeFieldEnd()
28914 
    oprot.writeFieldStop()
28915 
    oprot.writeStructEnd()
28916 
 
28917 
  def validate(self):
28918 
    return
28919 
 
28920 
 
28921 
  def __repr__(self):
28922 
    L = ['%s=%r' % (key, value)
28923 
      for key, value in self.__dict__.iteritems()]
28924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28925 
 
28926 
  def __eq__(self, other):
28927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28928 
 
28929 
  def __ne__(self, other):
28930 
    return not (self == other)
6371 rajveer 28931 
 
28932 
class updateAvailabilityStatus_args:
28933 
  """
28934 
  Attributes:
28935 
   - operatorId
28936 
   - circleId
28937 
   - isAvailable
28938 
  """
28939 
 
28940 
  thrift_spec = (
28941 
    None, # 0
28942 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28943 
    (2, TType.I64, 'circleId', None, None, ), # 2
28944 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
28945 
  )
28946 
 
28947 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
28948 
    self.operatorId = operatorId
28949 
    self.circleId = circleId
28950 
    self.isAvailable = isAvailable
28951 
 
28952 
  def read(self, iprot):
28953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28955 
      return
28956 
    iprot.readStructBegin()
28957 
    while True:
28958 
      (fname, ftype, fid) = iprot.readFieldBegin()
28959 
      if ftype == TType.STOP:
28960 
        break
28961 
      if fid == 1:
28962 
        if ftype == TType.I64:
28963 
          self.operatorId = iprot.readI64();
28964 
        else:
28965 
          iprot.skip(ftype)
28966 
      elif fid == 2:
28967 
        if ftype == TType.I64:
28968 
          self.circleId = iprot.readI64();
28969 
        else:
28970 
          iprot.skip(ftype)
28971 
      elif fid == 3:
28972 
        if ftype == TType.BOOL:
28973 
          self.isAvailable = iprot.readBool();
28974 
        else:
28975 
          iprot.skip(ftype)
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_args')
28986 
    if self.operatorId is not None:
28987 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28988 
      oprot.writeI64(self.operatorId)
28989 
      oprot.writeFieldEnd()
28990 
    if self.circleId is not None:
28991 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
28992 
      oprot.writeI64(self.circleId)
28993 
      oprot.writeFieldEnd()
28994 
    if self.isAvailable is not None:
28995 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
28996 
      oprot.writeBool(self.isAvailable)
28997 
      oprot.writeFieldEnd()
28998 
    oprot.writeFieldStop()
28999 
    oprot.writeStructEnd()
29000 
 
29001 
  def validate(self):
29002 
    return
29003 
 
29004 
 
29005 
  def __repr__(self):
29006 
    L = ['%s=%r' % (key, value)
29007 
      for key, value in self.__dict__.iteritems()]
29008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29009 
 
29010 
  def __eq__(self, other):
29011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29012 
 
29013 
  def __ne__(self, other):
29014 
    return not (self == other)
29015 
 
29016 
class updateAvailabilityStatus_result:
29017 
 
29018 
  thrift_spec = (
29019 
  )
29020 
 
29021 
  def read(self, iprot):
29022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29024 
      return
29025 
    iprot.readStructBegin()
29026 
    while True:
29027 
      (fname, ftype, fid) = iprot.readFieldBegin()
29028 
      if ftype == TType.STOP:
29029 
        break
29030 
      else:
29031 
        iprot.skip(ftype)
29032 
      iprot.readFieldEnd()
29033 
    iprot.readStructEnd()
29034 
 
29035 
  def write(self, oprot):
29036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29038 
      return
29039 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29040 
    oprot.writeFieldStop()
29041 
    oprot.writeStructEnd()
29042 
 
29043 
  def validate(self):
29044 
    return
29045 
 
29046 
 
29047 
  def __repr__(self):
29048 
    L = ['%s=%r' % (key, value)
29049 
      for key, value in self.__dict__.iteritems()]
29050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29051 
 
29052 
  def __eq__(self, other):
29053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29054 
 
29055 
  def __ne__(self, other):
29056 
    return not (self == other)
6389 rajveer 29057 
 
29058 
class getAvailableEmiSchemes_args:
29059 
 
29060 
  thrift_spec = (
29061 
  )
29062 
 
29063 
  def read(self, iprot):
29064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29066 
      return
29067 
    iprot.readStructBegin()
29068 
    while True:
29069 
      (fname, ftype, fid) = iprot.readFieldBegin()
29070 
      if ftype == TType.STOP:
29071 
        break
29072 
      else:
29073 
        iprot.skip(ftype)
29074 
      iprot.readFieldEnd()
29075 
    iprot.readStructEnd()
29076 
 
29077 
  def write(self, oprot):
29078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29080 
      return
29081 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29082 
    oprot.writeFieldStop()
29083 
    oprot.writeStructEnd()
29084 
 
29085 
  def validate(self):
29086 
    return
29087 
 
29088 
 
29089 
  def __repr__(self):
29090 
    L = ['%s=%r' % (key, value)
29091 
      for key, value in self.__dict__.iteritems()]
29092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29093 
 
29094 
  def __eq__(self, other):
29095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29096 
 
29097 
  def __ne__(self, other):
29098 
    return not (self == other)
29099 
 
29100 
class getAvailableEmiSchemes_result:
29101 
  """
29102 
  Attributes:
29103 
   - success
29104 
  """
29105 
 
29106 
  thrift_spec = (
29107 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29108 
  )
29109 
 
29110 
  def __init__(self, success=None,):
29111 
    self.success = success
29112 
 
29113 
  def read(self, iprot):
29114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29116 
      return
29117 
    iprot.readStructBegin()
29118 
    while True:
29119 
      (fname, ftype, fid) = iprot.readFieldBegin()
29120 
      if ftype == TType.STOP:
29121 
        break
29122 
      if fid == 0:
29123 
        if ftype == TType.LIST:
29124 
          self.success = []
29125 
          (_etype710, _size707) = iprot.readListBegin()
29126 
          for _i711 in xrange(_size707):
29127 
            _elem712 = EmiScheme()
29128 
            _elem712.read(iprot)
29129 
            self.success.append(_elem712)
29130 
          iprot.readListEnd()
29131 
        else:
29132 
          iprot.skip(ftype)
29133 
      else:
29134 
        iprot.skip(ftype)
29135 
      iprot.readFieldEnd()
29136 
    iprot.readStructEnd()
29137 
 
29138 
  def write(self, oprot):
29139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29141 
      return
29142 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29143 
    if self.success is not None:
29144 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29145 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29146 
      for iter713 in self.success:
29147 
        iter713.write(oprot)
29148 
      oprot.writeListEnd()
29149 
      oprot.writeFieldEnd()
29150 
    oprot.writeFieldStop()
29151 
    oprot.writeStructEnd()
29152 
 
29153 
  def validate(self):
29154 
    return
29155 
 
29156 
 
29157 
  def __repr__(self):
29158 
    L = ['%s=%r' % (key, value)
29159 
      for key, value in self.__dict__.iteritems()]
29160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29161 
 
29162 
  def __eq__(self, other):
29163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29164 
 
29165 
  def __ne__(self, other):
29166 
    return not (self == other)
29167 
 
29168 
class getMiscCharges_args:
29169 
  """
29170 
  Attributes:
29171 
   - transactionId
29172 
  """
29173 
 
29174 
  thrift_spec = (
29175 
    None, # 0
29176 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29177 
  )
29178 
 
29179 
  def __init__(self, transactionId=None,):
29180 
    self.transactionId = transactionId
29181 
 
29182 
  def read(self, iprot):
29183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29185 
      return
29186 
    iprot.readStructBegin()
29187 
    while True:
29188 
      (fname, ftype, fid) = iprot.readFieldBegin()
29189 
      if ftype == TType.STOP:
29190 
        break
29191 
      if fid == 1:
29192 
        if ftype == TType.I64:
29193 
          self.transactionId = iprot.readI64();
29194 
        else:
29195 
          iprot.skip(ftype)
29196 
      else:
29197 
        iprot.skip(ftype)
29198 
      iprot.readFieldEnd()
29199 
    iprot.readStructEnd()
29200 
 
29201 
  def write(self, oprot):
29202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29204 
      return
29205 
    oprot.writeStructBegin('getMiscCharges_args')
29206 
    if self.transactionId is not None:
29207 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29208 
      oprot.writeI64(self.transactionId)
29209 
      oprot.writeFieldEnd()
29210 
    oprot.writeFieldStop()
29211 
    oprot.writeStructEnd()
29212 
 
29213 
  def validate(self):
29214 
    return
29215 
 
29216 
 
29217 
  def __repr__(self):
29218 
    L = ['%s=%r' % (key, value)
29219 
      for key, value in self.__dict__.iteritems()]
29220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29221 
 
29222 
  def __eq__(self, other):
29223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29224 
 
29225 
  def __ne__(self, other):
29226 
    return not (self == other)
29227 
 
29228 
class getMiscCharges_result:
29229 
  """
29230 
  Attributes:
29231 
   - success
29232 
  """
29233 
 
29234 
  thrift_spec = (
6412 rajveer 29235 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29236 
  )
29237 
 
29238 
  def __init__(self, success=None,):
29239 
    self.success = success
29240 
 
29241 
  def read(self, iprot):
29242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29244 
      return
29245 
    iprot.readStructBegin()
29246 
    while True:
29247 
      (fname, ftype, fid) = iprot.readFieldBegin()
29248 
      if ftype == TType.STOP:
29249 
        break
29250 
      if fid == 0:
29251 
        if ftype == TType.MAP:
29252 
          self.success = {}
29253 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29254 
          for _i718 in xrange(_size714):
29255 
            _key719 = iprot.readI64();
6412 rajveer 29256 
            _val720 = iprot.readDouble();
6389 rajveer 29257 
            self.success[_key719] = _val720
29258 
          iprot.readMapEnd()
29259 
        else:
29260 
          iprot.skip(ftype)
29261 
      else:
29262 
        iprot.skip(ftype)
29263 
      iprot.readFieldEnd()
29264 
    iprot.readStructEnd()
29265 
 
29266 
  def write(self, oprot):
29267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29269 
      return
29270 
    oprot.writeStructBegin('getMiscCharges_result')
29271 
    if self.success is not None:
29272 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29273 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29274 
      for kiter721,viter722 in self.success.items():
29275 
        oprot.writeI64(kiter721)
6412 rajveer 29276 
        oprot.writeDouble(viter722)
6389 rajveer 29277 
      oprot.writeMapEnd()
29278 
      oprot.writeFieldEnd()
29279 
    oprot.writeFieldStop()
29280 
    oprot.writeStructEnd()
29281 
 
29282 
  def validate(self):
29283 
    return
29284 
 
29285 
 
29286 
  def __repr__(self):
29287 
    L = ['%s=%r' % (key, value)
29288 
      for key, value in self.__dict__.iteritems()]
29289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29290 
 
29291 
  def __eq__(self, other):
29292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29293 
 
29294 
  def __ne__(self, other):
29295 
    return not (self == other)
6507 anupam.sin 29296 
 
29297 
class refundRechargeOrder_args:
29298 
  """
29299 
  Attributes:
29300 
   - rechargeOrderId
29301 
  """
29302 
 
29303 
  thrift_spec = (
29304 
    None, # 0
29305 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29306 
  )
29307 
 
29308 
  def __init__(self, rechargeOrderId=None,):
29309 
    self.rechargeOrderId = rechargeOrderId
29310 
 
29311 
  def read(self, iprot):
29312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29314 
      return
29315 
    iprot.readStructBegin()
29316 
    while True:
29317 
      (fname, ftype, fid) = iprot.readFieldBegin()
29318 
      if ftype == TType.STOP:
29319 
        break
29320 
      if fid == 1:
29321 
        if ftype == TType.I64:
29322 
          self.rechargeOrderId = iprot.readI64();
29323 
        else:
29324 
          iprot.skip(ftype)
29325 
      else:
29326 
        iprot.skip(ftype)
29327 
      iprot.readFieldEnd()
29328 
    iprot.readStructEnd()
29329 
 
29330 
  def write(self, oprot):
29331 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29332 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29333 
      return
29334 
    oprot.writeStructBegin('refundRechargeOrder_args')
29335 
    if self.rechargeOrderId is not None:
29336 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29337 
      oprot.writeI64(self.rechargeOrderId)
29338 
      oprot.writeFieldEnd()
29339 
    oprot.writeFieldStop()
29340 
    oprot.writeStructEnd()
29341 
 
29342 
  def validate(self):
29343 
    return
29344 
 
29345 
 
29346 
  def __repr__(self):
29347 
    L = ['%s=%r' % (key, value)
29348 
      for key, value in self.__dict__.iteritems()]
29349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29350 
 
29351 
  def __eq__(self, other):
29352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29353 
 
29354 
  def __ne__(self, other):
29355 
    return not (self == other)
29356 
 
29357 
class refundRechargeOrder_result:
29358 
  """
29359 
  Attributes:
29360 
   - success
29361 
   - ex
29362 
  """
29363 
 
29364 
  thrift_spec = (
29365 
    (0, TType.BOOL, 'success', None, None, ), # 0
29366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29367 
  )
29368 
 
29369 
  def __init__(self, success=None, ex=None,):
29370 
    self.success = success
29371 
    self.ex = ex
29372 
 
29373 
  def read(self, iprot):
29374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29376 
      return
29377 
    iprot.readStructBegin()
29378 
    while True:
29379 
      (fname, ftype, fid) = iprot.readFieldBegin()
29380 
      if ftype == TType.STOP:
29381 
        break
29382 
      if fid == 0:
29383 
        if ftype == TType.BOOL:
29384 
          self.success = iprot.readBool();
29385 
        else:
29386 
          iprot.skip(ftype)
29387 
      elif fid == 1:
29388 
        if ftype == TType.STRUCT:
29389 
          self.ex = TransactionServiceException()
29390 
          self.ex.read(iprot)
29391 
        else:
29392 
          iprot.skip(ftype)
29393 
      else:
29394 
        iprot.skip(ftype)
29395 
      iprot.readFieldEnd()
29396 
    iprot.readStructEnd()
29397 
 
29398 
  def write(self, oprot):
29399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29401 
      return
29402 
    oprot.writeStructBegin('refundRechargeOrder_result')
29403 
    if self.success is not None:
29404 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29405 
      oprot.writeBool(self.success)
29406 
      oprot.writeFieldEnd()
29407 
    if self.ex is not None:
29408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29409 
      self.ex.write(oprot)
29410 
      oprot.writeFieldEnd()
29411 
    oprot.writeFieldStop()
29412 
    oprot.writeStructEnd()
29413 
 
29414 
  def validate(self):
29415 
    return
29416 
 
29417 
 
29418 
  def __repr__(self):
29419 
    L = ['%s=%r' % (key, value)
29420 
      for key, value in self.__dict__.iteritems()]
29421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29422 
 
29423 
  def __eq__(self, other):
29424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29425 
 
29426 
  def __ne__(self, other):
29427 
    return not (self == other)