Subversion Repositories SmartDukaan

Rev

Rev 6289 | Rev 6336 | 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 
 
6307 anupam.sin 1365 
  def validateRecharge(self, rechargeType, deviceNumber, circleCode, userSelectedProviderId):
6269 rajveer 1366 
    """
1367 
    Parameters:
1368 
     - rechargeType
1369 
     - deviceNumber
6307 anupam.sin 1370 
     - circleCode
1371 
     - userSelectedProviderId
6269 rajveer 1372 
    """
1373 
    pass
1374 
 
6094 rajveer 1375 
  def getRechargeOrdersForDevice(self, deviceNumber):
1376 
    """
1377 
    Parameters:
1378 
     - deviceNumber
1379 
    """
1380 
    pass
6048 rajveer 1381 
 
6094 rajveer 1382 
  def addAmountToWallet(self, userId, orderId, amount):
1383 
    """
1384 
    Parameters:
1385 
     - userId
1386 
     - orderId
1387 
     - amount
1388 
    """
1389 
    pass
1390 
 
6188 rajveer 1391 
  def getRechargeStatistics(self, ):
1392 
    pass
1393 
 
6154 rajveer 1394 
  def getRechargeOrdersForStatus(self, status):
1395 
    """
1396 
    Parameters:
1397 
     - status
1398 
    """
1399 
    pass
6094 rajveer 1400 
 
6159 rajveer 1401 
  def getPlansForOperator(self, operatorId):
1402 
    """
1403 
    Parameters:
1404 
     - operatorId
1405 
    """
1406 
    pass
6154 rajveer 1407 
 
6307 anupam.sin 1408 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1409 
    """
1410 
    Returns denominations for a given operator and circle
6159 rajveer 1411 
 
6289 anupam.sin 1412 
    Parameters:
1413 
     - operatorId
6307 anupam.sin 1414 
     - circleCode
6289 anupam.sin 1415 
     - denominationType
1416 
    """
1417 
    pass
1418 
 
1419 
 
3376 rajveer 1420 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1421 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1422 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1423 
 
1424 
  def createTransaction(self, transaction):
1425 
    """
1426 
    Parameters:
1427 
     - transaction
1428 
    """
1429 
    self.send_createTransaction(transaction)
132 ashish 1430 
    return self.recv_createTransaction()
94 ashish 1431 
 
1432 
  def send_createTransaction(self, transaction):
1433 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1434 
    args = createTransaction_args()
1435 
    args.transaction = transaction
1436 
    args.write(self._oprot)
1437 
    self._oprot.writeMessageEnd()
1438 
    self._oprot.trans.flush()
1439 
 
1440 
  def recv_createTransaction(self, ):
1441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1442 
    if mtype == TMessageType.EXCEPTION:
1443 
      x = TApplicationException()
1444 
      x.read(self._iprot)
1445 
      self._iprot.readMessageEnd()
1446 
      raise x
1447 
    result = createTransaction_result()
1448 
    result.read(self._iprot)
1449 
    self._iprot.readMessageEnd()
3431 rajveer 1450 
    if result.success is not None:
132 ashish 1451 
      return result.success
3431 rajveer 1452 
    if result.ex is not None:
94 ashish 1453 
      raise result.ex
132 ashish 1454 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1455 
 
1456 
  def getTransaction(self, id):
1457 
    """
1458 
    Parameters:
1459 
     - id
1460 
    """
1461 
    self.send_getTransaction(id)
1462 
    return self.recv_getTransaction()
1463 
 
1464 
  def send_getTransaction(self, id):
1465 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1466 
    args = getTransaction_args()
1467 
    args.id = id
1468 
    args.write(self._oprot)
1469 
    self._oprot.writeMessageEnd()
1470 
    self._oprot.trans.flush()
1471 
 
1472 
  def recv_getTransaction(self, ):
1473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1474 
    if mtype == TMessageType.EXCEPTION:
1475 
      x = TApplicationException()
1476 
      x.read(self._iprot)
1477 
      self._iprot.readMessageEnd()
1478 
      raise x
1479 
    result = getTransaction_result()
1480 
    result.read(self._iprot)
1481 
    self._iprot.readMessageEnd()
3431 rajveer 1482 
    if result.success is not None:
94 ashish 1483 
      return result.success
3431 rajveer 1484 
    if result.ex is not None:
94 ashish 1485 
      raise result.ex
1486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1487 
 
1488 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1489 
    """
1490 
    Parameters:
1491 
     - customerId
1492 
     - from_date
1493 
     - to_date
1494 
     - status
1495 
    """
1496 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1497 
    return self.recv_getTransactionsForCustomer()
1498 
 
1499 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1500 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1501 
    args = getTransactionsForCustomer_args()
1502 
    args.customerId = customerId
1503 
    args.from_date = from_date
1504 
    args.to_date = to_date
1505 
    args.status = status
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_getTransactionsForCustomer(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = getTransactionsForCustomer_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
94 ashish 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
94 ashish 1523 
      raise result.ex
1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1525 
 
132 ashish 1526 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1527 
    """
1528 
    Parameters:
1529 
     - shoppingCartId
1530 
    """
1531 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1532 
    return self.recv_getTransactionsForShoppingCartId()
1533 
 
1534 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1535 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1536 
    args = getTransactionsForShoppingCartId_args()
1537 
    args.shoppingCartId = shoppingCartId
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getTransactionsForShoppingCartId(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getTransactionsForShoppingCartId_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
3431 rajveer 1552 
    if result.success is not None:
132 ashish 1553 
      return result.success
3431 rajveer 1554 
    if result.ex is not None:
132 ashish 1555 
      raise result.ex
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1557 
 
94 ashish 1558 
  def getTransactionStatus(self, transactionId):
1559 
    """
1560 
    Parameters:
1561 
     - transactionId
1562 
    """
1563 
    self.send_getTransactionStatus(transactionId)
1564 
    return self.recv_getTransactionStatus()
1565 
 
1566 
  def send_getTransactionStatus(self, transactionId):
1567 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1568 
    args = getTransactionStatus_args()
1569 
    args.transactionId = transactionId
1570 
    args.write(self._oprot)
1571 
    self._oprot.writeMessageEnd()
1572 
    self._oprot.trans.flush()
1573 
 
1574 
  def recv_getTransactionStatus(self, ):
1575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1576 
    if mtype == TMessageType.EXCEPTION:
1577 
      x = TApplicationException()
1578 
      x.read(self._iprot)
1579 
      self._iprot.readMessageEnd()
1580 
      raise x
1581 
    result = getTransactionStatus_result()
1582 
    result.read(self._iprot)
1583 
    self._iprot.readMessageEnd()
3431 rajveer 1584 
    if result.success is not None:
94 ashish 1585 
      return result.success
3431 rajveer 1586 
    if result.ex is not None:
94 ashish 1587 
      raise result.ex
1588 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1589 
 
5527 anupam.sin 1590 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1591 
    """
1592 
    Parameters:
1593 
     - transactionId
1594 
     - status
1595 
     - description
5527 anupam.sin 1596 
     - pickUp
1597 
     - orderType
94 ashish 1598 
    """
5527 anupam.sin 1599 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1600 
    return self.recv_changeTransactionStatus()
1601 
 
5527 anupam.sin 1602 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1603 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1604 
    args = changeTransactionStatus_args()
1605 
    args.transactionId = transactionId
1606 
    args.status = status
1607 
    args.description = description
5527 anupam.sin 1608 
    args.pickUp = pickUp
1609 
    args.orderType = orderType
94 ashish 1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_changeTransactionStatus(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = changeTransactionStatus_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
3431 rajveer 1624 
    if result.success is not None:
94 ashish 1625 
      return result.success
3431 rajveer 1626 
    if result.ex is not None:
94 ashish 1627 
      raise result.ex
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1629 
 
1398 varun.gupt 1630 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1631 
    """
1632 
    Parameters:
1633 
     - transactionId
1634 
    """
1398 varun.gupt 1635 
    self.send_enqueueTransactionInfoEmail(transactionId)
1636 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1637 
 
1398 varun.gupt 1638 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1639 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1640 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1641 
    args.transactionId = transactionId
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1398 varun.gupt 1646 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1398 varun.gupt 1653 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
3431 rajveer 1656 
    if result.success is not None:
1382 varun.gupt 1657 
      return result.success
3431 rajveer 1658 
    if result.ex is not None:
1382 varun.gupt 1659 
      raise result.ex
1398 varun.gupt 1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1661 
 
4801 anupam.sin 1662 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1663 
    """
1664 
    Parameters:
4801 anupam.sin 1665 
     - statuses
483 rajveer 1666 
     - from_date
1667 
     - to_date
1668 
     - warehouse_id
94 ashish 1669 
    """
4801 anupam.sin 1670 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1671 
    return self.recv_getAllOrders()
94 ashish 1672 
 
4801 anupam.sin 1673 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1674 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1675 
    args = getAllOrders_args()
4801 anupam.sin 1676 
    args.statuses = statuses
483 rajveer 1677 
    args.from_date = from_date
1678 
    args.to_date = to_date
1679 
    args.warehouse_id = warehouse_id
94 ashish 1680 
    args.write(self._oprot)
1681 
    self._oprot.writeMessageEnd()
1682 
    self._oprot.trans.flush()
1683 
 
483 rajveer 1684 
  def recv_getAllOrders(self, ):
94 ashish 1685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1686 
    if mtype == TMessageType.EXCEPTION:
1687 
      x = TApplicationException()
1688 
      x.read(self._iprot)
1689 
      self._iprot.readMessageEnd()
1690 
      raise x
483 rajveer 1691 
    result = getAllOrders_result()
94 ashish 1692 
    result.read(self._iprot)
1693 
    self._iprot.readMessageEnd()
3431 rajveer 1694 
    if result.success is not None:
94 ashish 1695 
      return result.success
3431 rajveer 1696 
    if result.ex is not None:
94 ashish 1697 
      raise result.ex
483 rajveer 1698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1699 
 
4133 chandransh 1700 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1701 
    """
1702 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1703 
    Pass the status as null and the limit as 0 to ignore them.
1704 
 
1705 
    Parameters:
1706 
     - statuses
1707 
     - offset
1708 
     - limit
1709 
     - warehouse_id
1710 
    """
1711 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1712 
    return self.recv_getOrdersInBatch()
1713 
 
1714 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1715 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1716 
    args = getOrdersInBatch_args()
1717 
    args.statuses = statuses
1718 
    args.offset = offset
1719 
    args.limit = limit
1720 
    args.warehouse_id = warehouse_id
1721 
    args.write(self._oprot)
1722 
    self._oprot.writeMessageEnd()
1723 
    self._oprot.trans.flush()
1724 
 
1725 
  def recv_getOrdersInBatch(self, ):
1726 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1727 
    if mtype == TMessageType.EXCEPTION:
1728 
      x = TApplicationException()
1729 
      x.read(self._iprot)
1730 
      self._iprot.readMessageEnd()
1731 
      raise x
1732 
    result = getOrdersInBatch_result()
1733 
    result.read(self._iprot)
1734 
    self._iprot.readMessageEnd()
1735 
    if result.success is not None:
1736 
      return result.success
1737 
    if result.ex is not None:
1738 
      raise result.ex
1739 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1740 
 
1741 
  def getOrderCount(self, statuses, warehouseId):
1742 
    """
1743 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1744 
 
1745 
    Parameters:
1746 
     - statuses
1747 
     - warehouseId
1748 
    """
1749 
    self.send_getOrderCount(statuses, warehouseId)
1750 
    return self.recv_getOrderCount()
1751 
 
1752 
  def send_getOrderCount(self, statuses, warehouseId):
1753 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1754 
    args = getOrderCount_args()
1755 
    args.statuses = statuses
1756 
    args.warehouseId = warehouseId
1757 
    args.write(self._oprot)
1758 
    self._oprot.writeMessageEnd()
1759 
    self._oprot.trans.flush()
1760 
 
1761 
  def recv_getOrderCount(self, ):
1762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1763 
    if mtype == TMessageType.EXCEPTION:
1764 
      x = TApplicationException()
1765 
      x.read(self._iprot)
1766 
      self._iprot.readMessageEnd()
1767 
      raise x
1768 
    result = getOrderCount_result()
1769 
    result.read(self._iprot)
1770 
    self._iprot.readMessageEnd()
1771 
    if result.success is not None:
1772 
      return result.success
1773 
    if result.ex is not None:
1774 
      raise result.ex
1775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1776 
 
999 varun.gupt 1777 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1778 
    """
1132 chandransh 1779 
    Returns orders within a range of their billing dates
3431 rajveer 1780 
 
999 varun.gupt 1781 
    Parameters:
1782 
     - status
1783 
     - start_billing_date
1784 
     - end_billing_date
1785 
     - warehouse_id
1786 
    """
1787 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1788 
    return self.recv_getOrdersByBillingDate()
1789 
 
1790 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1791 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1792 
    args = getOrdersByBillingDate_args()
1793 
    args.status = status
1794 
    args.start_billing_date = start_billing_date
1795 
    args.end_billing_date = end_billing_date
1796 
    args.warehouse_id = warehouse_id
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getOrdersByBillingDate(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getOrdersByBillingDate_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
3431 rajveer 1811 
    if result.success is not None:
999 varun.gupt 1812 
      return result.success
3431 rajveer 1813 
    if result.ex is not None:
999 varun.gupt 1814 
      raise result.ex
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1816 
 
3451 chandransh 1817 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1818 
    """
1819 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1820 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1821 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1822 
 
3427 chandransh 1823 
    Parameters:
1824 
     - fromShippingDate
1825 
     - toShippingDate
1826 
     - providerId
1827 
     - warehouseId
3451 chandransh 1828 
     - cod
3427 chandransh 1829 
    """
3451 chandransh 1830 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1831 
    return self.recv_getOrdersByShippingDate()
1832 
 
3451 chandransh 1833 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1834 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1835 
    args = getOrdersByShippingDate_args()
1836 
    args.fromShippingDate = fromShippingDate
1837 
    args.toShippingDate = toShippingDate
1838 
    args.providerId = providerId
1839 
    args.warehouseId = warehouseId
3451 chandransh 1840 
    args.cod = cod
3427 chandransh 1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1845 
  def recv_getOrdersByShippingDate(self, ):
1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1852 
    result = getOrdersByShippingDate_result()
1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
3427 chandransh 1856 
      return result.success
3431 rajveer 1857 
    if result.ex is not None:
3427 chandransh 1858 
      raise result.ex
1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1860 
 
1382 varun.gupt 1861 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1862 
    """
1863 
    Returns order ids for orders which can be returned
3431 rajveer 1864 
 
1382 varun.gupt 1865 
    Parameters:
1866 
     - customer_id
1867 
     - limit
1868 
    """
1869 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1870 
    return self.recv_getReturnableOrdersForCustomer()
1871 
 
1872 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1873 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1874 
    args = getReturnableOrdersForCustomer_args()
1875 
    args.customer_id = customer_id
1876 
    args.limit = limit
1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
1881 
  def recv_getReturnableOrdersForCustomer(self, ):
1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
1888 
    result = getReturnableOrdersForCustomer_result()
1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
3431 rajveer 1891 
    if result.success is not None:
1382 varun.gupt 1892 
      return result.success
3431 rajveer 1893 
    if result.ex is not None:
1382 varun.gupt 1894 
      raise result.ex
1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1896 
 
1897 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1898 
    """
1899 
    Returns order ids for orders which can be cancelled
3431 rajveer 1900 
 
1382 varun.gupt 1901 
    Parameters:
1902 
     - customer_id
1903 
     - limit
1904 
    """
1905 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1906 
    return self.recv_getCancellableOrdersForCustomer()
1907 
 
1908 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1909 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1910 
    args = getCancellableOrdersForCustomer_args()
1911 
    args.customer_id = customer_id
1912 
    args.limit = limit
1913 
    args.write(self._oprot)
1914 
    self._oprot.writeMessageEnd()
1915 
    self._oprot.trans.flush()
1916 
 
1917 
  def recv_getCancellableOrdersForCustomer(self, ):
1918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1919 
    if mtype == TMessageType.EXCEPTION:
1920 
      x = TApplicationException()
1921 
      x.read(self._iprot)
1922 
      self._iprot.readMessageEnd()
1923 
      raise x
1924 
    result = getCancellableOrdersForCustomer_result()
1925 
    result.read(self._iprot)
1926 
    self._iprot.readMessageEnd()
3431 rajveer 1927 
    if result.success is not None:
1382 varun.gupt 1928 
      return result.success
3431 rajveer 1929 
    if result.ex is not None:
1382 varun.gupt 1930 
      raise result.ex
1931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1932 
 
483 rajveer 1933 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1934 
    """
1935 
    Parameters:
483 rajveer 1936 
     - orderId
1937 
     - status
1938 
     - description
94 ashish 1939 
    """
483 rajveer 1940 
    self.send_changeOrderStatus(orderId, status, description)
1941 
    return self.recv_changeOrderStatus()
94 ashish 1942 
 
483 rajveer 1943 
  def send_changeOrderStatus(self, orderId, status, description):
1944 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1945 
    args = changeOrderStatus_args()
1946 
    args.orderId = orderId
1947 
    args.status = status
1948 
    args.description = description
94 ashish 1949 
    args.write(self._oprot)
1950 
    self._oprot.writeMessageEnd()
1951 
    self._oprot.trans.flush()
1952 
 
483 rajveer 1953 
  def recv_changeOrderStatus(self, ):
94 ashish 1954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1955 
    if mtype == TMessageType.EXCEPTION:
1956 
      x = TApplicationException()
1957 
      x.read(self._iprot)
1958 
      self._iprot.readMessageEnd()
1959 
      raise x
483 rajveer 1960 
    result = changeOrderStatus_result()
94 ashish 1961 
    result.read(self._iprot)
1962 
    self._iprot.readMessageEnd()
3431 rajveer 1963 
    if result.success is not None:
94 ashish 1964 
      return result.success
3431 rajveer 1965 
    if result.ex is not None:
94 ashish 1966 
      raise result.ex
483 rajveer 1967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1968 
 
1528 ankur.sing 1969 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1970 
    """
1528 ankur.sing 1971 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1972 
    only user who owns the transaction can view its order details.
3431 rajveer 1973 
 
94 ashish 1974 
    Parameters:
1975 
     - transactionId
1528 ankur.sing 1976 
     - customerId
94 ashish 1977 
    """
1528 ankur.sing 1978 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1979 
    return self.recv_getOrdersForTransaction()
94 ashish 1980 
 
1528 ankur.sing 1981 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1982 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1983 
    args = getOrdersForTransaction_args()
94 ashish 1984 
    args.transactionId = transactionId
1528 ankur.sing 1985 
    args.customerId = customerId
94 ashish 1986 
    args.write(self._oprot)
1987 
    self._oprot.writeMessageEnd()
1988 
    self._oprot.trans.flush()
1989 
 
483 rajveer 1990 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1991 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1992 
    if mtype == TMessageType.EXCEPTION:
1993 
      x = TApplicationException()
1994 
      x.read(self._iprot)
1995 
      self._iprot.readMessageEnd()
1996 
      raise x
483 rajveer 1997 
    result = getOrdersForTransaction_result()
94 ashish 1998 
    result.read(self._iprot)
1999 
    self._iprot.readMessageEnd()
3431 rajveer 2000 
    if result.success is not None:
94 ashish 2001 
      return result.success
3431 rajveer 2002 
    if result.ex is not None:
94 ashish 2003 
      raise result.ex
483 rajveer 2004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2005 
 
3014 chandransh 2006 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2007 
    """
3014 chandransh 2008 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2009 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2010 
 
94 ashish 2011 
    Parameters:
483 rajveer 2012 
     - customerId
2013 
     - from_date
2014 
     - to_date
3014 chandransh 2015 
     - statuses
94 ashish 2016 
    """
3014 chandransh 2017 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2018 
    return self.recv_getOrdersForCustomer()
94 ashish 2019 
 
3014 chandransh 2020 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2021 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2022 
    args = getOrdersForCustomer_args()
2023 
    args.customerId = customerId
2024 
    args.from_date = from_date
2025 
    args.to_date = to_date
3014 chandransh 2026 
    args.statuses = statuses
94 ashish 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
483 rajveer 2031 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
483 rajveer 2038 
    result = getOrdersForCustomer_result()
94 ashish 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
3431 rajveer 2041 
    if result.success is not None:
94 ashish 2042 
      return result.success
3431 rajveer 2043 
    if result.ex is not None:
94 ashish 2044 
      raise result.ex
483 rajveer 2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2046 
 
483 rajveer 2047 
  def createOrder(self, order):
94 ashish 2048 
    """
2049 
    Parameters:
483 rajveer 2050 
     - order
94 ashish 2051 
    """
483 rajveer 2052 
    self.send_createOrder(order)
2053 
    return self.recv_createOrder()
94 ashish 2054 
 
483 rajveer 2055 
  def send_createOrder(self, order):
2056 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2057 
    args = createOrder_args()
2058 
    args.order = order
94 ashish 2059 
    args.write(self._oprot)
2060 
    self._oprot.writeMessageEnd()
2061 
    self._oprot.trans.flush()
2062 
 
483 rajveer 2063 
  def recv_createOrder(self, ):
94 ashish 2064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2065 
    if mtype == TMessageType.EXCEPTION:
2066 
      x = TApplicationException()
2067 
      x.read(self._iprot)
2068 
      self._iprot.readMessageEnd()
2069 
      raise x
483 rajveer 2070 
    result = createOrder_result()
94 ashish 2071 
    result.read(self._iprot)
2072 
    self._iprot.readMessageEnd()
3431 rajveer 2073 
    if result.success is not None:
94 ashish 2074 
      return result.success
3431 rajveer 2075 
    if result.ex is not None:
94 ashish 2076 
      raise result.ex
483 rajveer 2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2078 
 
483 rajveer 2079 
  def getOrder(self, id):
94 ashish 2080 
    """
2081 
    Parameters:
483 rajveer 2082 
     - id
94 ashish 2083 
    """
483 rajveer 2084 
    self.send_getOrder(id)
2085 
    return self.recv_getOrder()
94 ashish 2086 
 
483 rajveer 2087 
  def send_getOrder(self, id):
2088 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2089 
    args = getOrder_args()
2090 
    args.id = id
94 ashish 2091 
    args.write(self._oprot)
2092 
    self._oprot.writeMessageEnd()
2093 
    self._oprot.trans.flush()
2094 
 
483 rajveer 2095 
  def recv_getOrder(self, ):
94 ashish 2096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2097 
    if mtype == TMessageType.EXCEPTION:
2098 
      x = TApplicationException()
2099 
      x.read(self._iprot)
2100 
      self._iprot.readMessageEnd()
2101 
      raise x
483 rajveer 2102 
    result = getOrder_result()
94 ashish 2103 
    result.read(self._iprot)
2104 
    self._iprot.readMessageEnd()
3431 rajveer 2105 
    if result.success is not None:
94 ashish 2106 
      return result.success
3431 rajveer 2107 
    if result.ex is not None:
94 ashish 2108 
      raise result.ex
483 rajveer 2109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2110 
 
483 rajveer 2111 
  def getLineItemsForOrder(self, orderId):
94 ashish 2112 
    """
2113 
    Parameters:
483 rajveer 2114 
     - orderId
94 ashish 2115 
    """
483 rajveer 2116 
    self.send_getLineItemsForOrder(orderId)
2117 
    return self.recv_getLineItemsForOrder()
94 ashish 2118 
 
483 rajveer 2119 
  def send_getLineItemsForOrder(self, orderId):
2120 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2121 
    args = getLineItemsForOrder_args()
2122 
    args.orderId = orderId
94 ashish 2123 
    args.write(self._oprot)
2124 
    self._oprot.writeMessageEnd()
2125 
    self._oprot.trans.flush()
2126 
 
483 rajveer 2127 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2129 
    if mtype == TMessageType.EXCEPTION:
2130 
      x = TApplicationException()
2131 
      x.read(self._iprot)
2132 
      self._iprot.readMessageEnd()
2133 
      raise x
483 rajveer 2134 
    result = getLineItemsForOrder_result()
94 ashish 2135 
    result.read(self._iprot)
2136 
    self._iprot.readMessageEnd()
3431 rajveer 2137 
    if result.success is not None:
94 ashish 2138 
      return result.success
3431 rajveer 2139 
    if result.ex is not None:
94 ashish 2140 
      raise result.ex
483 rajveer 2141 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2142 
 
4999 phani.kuma 2143 
  def getOrderList(self, order_ids):
2144 
    """
2145 
    Parameters:
2146 
     - order_ids
2147 
    """
2148 
    self.send_getOrderList(order_ids)
2149 
    return self.recv_getOrderList()
2150 
 
2151 
  def send_getOrderList(self, order_ids):
2152 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2153 
    args = getOrderList_args()
2154 
    args.order_ids = order_ids
2155 
    args.write(self._oprot)
2156 
    self._oprot.writeMessageEnd()
2157 
    self._oprot.trans.flush()
2158 
 
2159 
  def recv_getOrderList(self, ):
2160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2161 
    if mtype == TMessageType.EXCEPTION:
2162 
      x = TApplicationException()
2163 
      x.read(self._iprot)
2164 
      self._iprot.readMessageEnd()
2165 
      raise x
2166 
    result = getOrderList_result()
2167 
    result.read(self._iprot)
2168 
    self._iprot.readMessageEnd()
2169 
    if result.success is not None:
2170 
      return result.success
2171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2172 
 
5386 phani.kuma 2173 
  def getOrderListForVendor(self, order_ids, vendorId):
2174 
    """
2175 
    Parameters:
2176 
     - order_ids
2177 
     - vendorId
2178 
    """
2179 
    self.send_getOrderListForVendor(order_ids, vendorId)
2180 
    return self.recv_getOrderListForVendor()
2181 
 
2182 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2183 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2184 
    args = getOrderListForVendor_args()
2185 
    args.order_ids = order_ids
2186 
    args.vendorId = vendorId
2187 
    args.write(self._oprot)
2188 
    self._oprot.writeMessageEnd()
2189 
    self._oprot.trans.flush()
2190 
 
2191 
  def recv_getOrderListForVendor(self, ):
2192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2193 
    if mtype == TMessageType.EXCEPTION:
2194 
      x = TApplicationException()
2195 
      x.read(self._iprot)
2196 
      self._iprot.readMessageEnd()
2197 
      raise x
2198 
    result = getOrderListForVendor_result()
2199 
    result.read(self._iprot)
2200 
    self._iprot.readMessageEnd()
2201 
    if result.success is not None:
2202 
      return result.success
2203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2204 
 
1528 ankur.sing 2205 
  def getOrderForCustomer(self, orderId, customerId):
2206 
    """
2207 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2208 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2209 
 
1528 ankur.sing 2210 
    Parameters:
2211 
     - orderId
2212 
     - customerId
2213 
    """
2214 
    self.send_getOrderForCustomer(orderId, customerId)
2215 
    return self.recv_getOrderForCustomer()
2216 
 
2217 
  def send_getOrderForCustomer(self, orderId, customerId):
2218 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2219 
    args = getOrderForCustomer_args()
2220 
    args.orderId = orderId
2221 
    args.customerId = customerId
2222 
    args.write(self._oprot)
2223 
    self._oprot.writeMessageEnd()
2224 
    self._oprot.trans.flush()
2225 
 
2226 
  def recv_getOrderForCustomer(self, ):
2227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2228 
    if mtype == TMessageType.EXCEPTION:
2229 
      x = TApplicationException()
2230 
      x.read(self._iprot)
2231 
      self._iprot.readMessageEnd()
2232 
      raise x
2233 
    result = getOrderForCustomer_result()
2234 
    result.read(self._iprot)
2235 
    self._iprot.readMessageEnd()
3431 rajveer 2236 
    if result.success is not None:
1528 ankur.sing 2237 
      return result.success
3431 rajveer 2238 
    if result.ex is not None:
1528 ankur.sing 2239 
      raise result.ex
2240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2241 
 
4444 rajveer 2242 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2243 
    """
2244 
    Parameters:
4394 rajveer 2245 
     - type
4444 rajveer 2246 
     - warehouseId
4394 rajveer 2247 
     - status
2248 
     - timestamp
3064 chandransh 2249 
    """
4444 rajveer 2250 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2251 
    return self.recv_getAlerts()
2252 
 
4444 rajveer 2253 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2254 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2255 
    args = getAlerts_args()
4394 rajveer 2256 
    args.type = type
4444 rajveer 2257 
    args.warehouseId = warehouseId
4394 rajveer 2258 
    args.status = status
2259 
    args.timestamp = timestamp
3064 chandransh 2260 
    args.write(self._oprot)
2261 
    self._oprot.writeMessageEnd()
2262 
    self._oprot.trans.flush()
2263 
 
2264 
  def recv_getAlerts(self, ):
2265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2266 
    if mtype == TMessageType.EXCEPTION:
2267 
      x = TApplicationException()
2268 
      x.read(self._iprot)
2269 
      self._iprot.readMessageEnd()
2270 
      raise x
2271 
    result = getAlerts_result()
2272 
    result.read(self._iprot)
2273 
    self._iprot.readMessageEnd()
3431 rajveer 2274 
    if result.success is not None:
3064 chandransh 2275 
      return result.success
2276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2277 
 
4444 rajveer 2278 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2279 
    """
2280 
    Parameters:
2281 
     - type
4444 rajveer 2282 
     - warehouseId
4394 rajveer 2283 
     - description
3064 chandransh 2284 
    """
4444 rajveer 2285 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2286 
    self.recv_addAlert()
3064 chandransh 2287 
 
4444 rajveer 2288 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2289 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2290 
    args = addAlert_args()
3064 chandransh 2291 
    args.type = type
4444 rajveer 2292 
    args.warehouseId = warehouseId
4394 rajveer 2293 
    args.description = description
3064 chandransh 2294 
    args.write(self._oprot)
2295 
    self._oprot.writeMessageEnd()
2296 
    self._oprot.trans.flush()
2297 
 
4394 rajveer 2298 
  def recv_addAlert(self, ):
3064 chandransh 2299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2300 
    if mtype == TMessageType.EXCEPTION:
2301 
      x = TApplicationException()
2302 
      x.read(self._iprot)
2303 
      self._iprot.readMessageEnd()
2304 
      raise x
4394 rajveer 2305 
    result = addAlert_result()
3064 chandransh 2306 
    result.read(self._iprot)
2307 
    self._iprot.readMessageEnd()
2308 
    return
2309 
 
4444 rajveer 2310 
  def markAlertsAsSeen(self, warehouseId):
2311 
    """
2312 
    Parameters:
2313 
     - warehouseId
2314 
    """
2315 
    self.send_markAlertsAsSeen(warehouseId)
2316 
    self.recv_markAlertsAsSeen()
2317 
 
2318 
  def send_markAlertsAsSeen(self, warehouseId):
2319 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2320 
    args = markAlertsAsSeen_args()
2321 
    args.warehouseId = warehouseId
2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
2326 
  def recv_markAlertsAsSeen(self, ):
2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
2333 
    result = markAlertsAsSeen_result()
2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
2336 
    return
2337 
 
3064 chandransh 2338 
  def getValidOrderCount(self, ):
2339 
    """
2340 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2341 
    """
2342 
    self.send_getValidOrderCount()
2343 
    return self.recv_getValidOrderCount()
2344 
 
2345 
  def send_getValidOrderCount(self, ):
2346 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2347 
    args = getValidOrderCount_args()
2348 
    args.write(self._oprot)
2349 
    self._oprot.writeMessageEnd()
2350 
    self._oprot.trans.flush()
2351 
 
2352 
  def recv_getValidOrderCount(self, ):
2353 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2354 
    if mtype == TMessageType.EXCEPTION:
2355 
      x = TApplicationException()
2356 
      x.read(self._iprot)
2357 
      self._iprot.readMessageEnd()
2358 
      raise x
2359 
    result = getValidOrderCount_result()
2360 
    result.read(self._iprot)
2361 
    self._iprot.readMessageEnd()
3431 rajveer 2362 
    if result.success is not None:
3064 chandransh 2363 
      return result.success
2364 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2365 
 
2366 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2367 
    """
2368 
    Returns the number of distinct customers who have done successful transactions
2369 
    """
2370 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2371 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2372 
 
2373 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2374 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2375 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
3431 rajveer 2390 
    if result.success is not None:
3064 chandransh 2391 
      return result.success
2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2393 
 
2394 
  def getValidOrdersAmountRange(self, ):
2395 
    """
2396 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2397 
    List contains two values, first minimum amount and second maximum amount.
2398 
    """
2399 
    self.send_getValidOrdersAmountRange()
2400 
    return self.recv_getValidOrdersAmountRange()
2401 
 
2402 
  def send_getValidOrdersAmountRange(self, ):
2403 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2404 
    args = getValidOrdersAmountRange_args()
2405 
    args.write(self._oprot)
2406 
    self._oprot.writeMessageEnd()
2407 
    self._oprot.trans.flush()
2408 
 
2409 
  def recv_getValidOrdersAmountRange(self, ):
2410 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2411 
    if mtype == TMessageType.EXCEPTION:
2412 
      x = TApplicationException()
2413 
      x.read(self._iprot)
2414 
      self._iprot.readMessageEnd()
2415 
      raise x
2416 
    result = getValidOrdersAmountRange_result()
2417 
    result.read(self._iprot)
2418 
    self._iprot.readMessageEnd()
3431 rajveer 2419 
    if result.success is not None:
3064 chandransh 2420 
      return result.success
2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2422 
 
5874 rajveer 2423 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2424 
    """
2425 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2426 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2427 
 
3064 chandransh 2428 
    Parameters:
2429 
     - limit
5874 rajveer 2430 
     - onlyStore
3064 chandransh 2431 
    """
5874 rajveer 2432 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2433 
    return self.recv_getValidOrders()
2434 
 
5874 rajveer 2435 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2436 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2437 
    args = getValidOrders_args()
2438 
    args.limit = limit
5874 rajveer 2439 
    args.onlyStore = onlyStore
3064 chandransh 2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
2444 
  def recv_getValidOrders(self, ):
2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
2451 
    result = getValidOrders_result()
2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
3431 rajveer 2454 
    if result.success is not None:
3064 chandransh 2455 
      return result.success
2456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2457 
 
1220 chandransh 2458 
  def batchOrders(self, warehouseId):
2459 
    """
2460 
    Create a batch of all the pending orders for the given warehouse.
2461 
    The returned list is orderd by created_timestamp.
2462 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2463 
 
1220 chandransh 2464 
    Parameters:
2465 
     - warehouseId
2466 
    """
2467 
    self.send_batchOrders(warehouseId)
2468 
    return self.recv_batchOrders()
2469 
 
2470 
  def send_batchOrders(self, warehouseId):
2471 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2472 
    args = batchOrders_args()
2473 
    args.warehouseId = warehouseId
2474 
    args.write(self._oprot)
2475 
    self._oprot.writeMessageEnd()
2476 
    self._oprot.trans.flush()
2477 
 
2478 
  def recv_batchOrders(self, ):
2479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2480 
    if mtype == TMessageType.EXCEPTION:
2481 
      x = TApplicationException()
2482 
      x.read(self._iprot)
2483 
      self._iprot.readMessageEnd()
2484 
      raise x
2485 
    result = batchOrders_result()
2486 
    result.read(self._iprot)
2487 
    self._iprot.readMessageEnd()
3431 rajveer 2488 
    if result.success is not None:
1220 chandransh 2489 
      return result.success
3431 rajveer 2490 
    if result.ex is not None:
1220 chandransh 2491 
      raise result.ex
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2493 
 
1208 chandransh 2494 
  def markOrderAsOutOfStock(self, orderId):
2495 
    """
2496 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2497 
 
1208 chandransh 2498 
    Parameters:
2499 
     - orderId
2500 
    """
2501 
    self.send_markOrderAsOutOfStock(orderId)
2502 
    return self.recv_markOrderAsOutOfStock()
2503 
 
2504 
  def send_markOrderAsOutOfStock(self, orderId):
2505 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2506 
    args = markOrderAsOutOfStock_args()
2507 
    args.orderId = orderId
2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_markOrderAsOutOfStock(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = markOrderAsOutOfStock_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
3431 rajveer 2522 
    if result.success is not None:
1208 chandransh 2523 
      return result.success
3431 rajveer 2524 
    if result.ex is not None:
1208 chandransh 2525 
      raise result.ex
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2527 
 
3064 chandransh 2528 
  def verifyOrder(self, orderId):
759 chandransh 2529 
    """
3064 chandransh 2530 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2531 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2532 
    used for all other orders as well.
2533 
    Throws an exception if no such order exists.
3431 rajveer 2534 
 
759 chandransh 2535 
    Parameters:
3064 chandransh 2536 
     - orderId
759 chandransh 2537 
    """
3064 chandransh 2538 
    self.send_verifyOrder(orderId)
2539 
    return self.recv_verifyOrder()
759 chandransh 2540 
 
3064 chandransh 2541 
  def send_verifyOrder(self, orderId):
2542 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2543 
    args = verifyOrder_args()
2544 
    args.orderId = orderId
759 chandransh 2545 
    args.write(self._oprot)
2546 
    self._oprot.writeMessageEnd()
2547 
    self._oprot.trans.flush()
2548 
 
3064 chandransh 2549 
  def recv_verifyOrder(self, ):
759 chandransh 2550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2551 
    if mtype == TMessageType.EXCEPTION:
2552 
      x = TApplicationException()
2553 
      x.read(self._iprot)
2554 
      self._iprot.readMessageEnd()
2555 
      raise x
3064 chandransh 2556 
    result = verifyOrder_result()
759 chandransh 2557 
    result.read(self._iprot)
2558 
    self._iprot.readMessageEnd()
3431 rajveer 2559 
    if result.success is not None:
759 chandransh 2560 
      return result.success
3431 rajveer 2561 
    if result.ex is not None:
759 chandransh 2562 
      raise result.ex
3064 chandransh 2563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2564 
 
3064 chandransh 2565 
  def acceptOrder(self, orderId):
1113 chandransh 2566 
    """
3064 chandransh 2567 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2568 
    given order is not a COD order, it also captures the payment if the same has
2569 
    not been captured.
2570 
    Throws an exception if no such order exists.
3431 rajveer 2571 
 
1113 chandransh 2572 
    Parameters:
3064 chandransh 2573 
     - orderId
1113 chandransh 2574 
    """
3064 chandransh 2575 
    self.send_acceptOrder(orderId)
2576 
    return self.recv_acceptOrder()
1113 chandransh 2577 
 
3064 chandransh 2578 
  def send_acceptOrder(self, orderId):
2579 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2580 
    args = acceptOrder_args()
2581 
    args.orderId = orderId
1113 chandransh 2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
3064 chandransh 2586 
  def recv_acceptOrder(self, ):
1113 chandransh 2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
3064 chandransh 2593 
    result = acceptOrder_result()
1113 chandransh 2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
3431 rajveer 2596 
    if result.success is not None:
1113 chandransh 2597 
      return result.success
3431 rajveer 2598 
    if result.ex is not None:
1113 chandransh 2599 
      raise result.ex
3064 chandransh 2600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2601 
 
5110 mandeep.dh 2602 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2603 
    """
3064 chandransh 2604 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2605 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2606 
    the IMEI no. if a -1 is supplied.
2607 
    Also, it generates an invoice number for the order, marks the order as
2608 
    BILLED and sets the billing timestamp.
2609 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2610 
 
1135 chandransh 2611 
    Parameters:
3064 chandransh 2612 
     - orderId
2613 
     - invoice_number
4658 mandeep.dh 2614 
     - serialNumber
4283 anupam.sin 2615 
     - itemNumber
3064 chandransh 2616 
     - billed_by
4264 rajveer 2617 
     - jacketNumber
4283 anupam.sin 2618 
     - billingType
5110 mandeep.dh 2619 
     - fulfilmentWarehouseId
4763 rajveer 2620 
     - authorize
1135 chandransh 2621 
    """
5110 mandeep.dh 2622 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2623 
    return self.recv_addBillingDetails()
1135 chandransh 2624 
 
5110 mandeep.dh 2625 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2626 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2627 
    args = addBillingDetails_args()
2628 
    args.orderId = orderId
2629 
    args.invoice_number = invoice_number
4658 mandeep.dh 2630 
    args.serialNumber = serialNumber
4283 anupam.sin 2631 
    args.itemNumber = itemNumber
3064 chandransh 2632 
    args.billed_by = billed_by
4264 rajveer 2633 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2634 
    args.billingType = billingType
5110 mandeep.dh 2635 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2636 
    args.authorize = authorize
1135 chandransh 2637 
    args.write(self._oprot)
2638 
    self._oprot.writeMessageEnd()
2639 
    self._oprot.trans.flush()
2640 
 
3064 chandransh 2641 
  def recv_addBillingDetails(self, ):
1135 chandransh 2642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2643 
    if mtype == TMessageType.EXCEPTION:
2644 
      x = TApplicationException()
2645 
      x.read(self._iprot)
2646 
      self._iprot.readMessageEnd()
2647 
      raise x
3064 chandransh 2648 
    result = addBillingDetails_result()
1135 chandransh 2649 
    result.read(self._iprot)
2650 
    self._iprot.readMessageEnd()
3431 rajveer 2651 
    if result.success is not None:
3064 chandransh 2652 
      return result.success
3431 rajveer 2653 
    if result.ex is not None:
1135 chandransh 2654 
      raise result.ex
3064 chandransh 2655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2656 
 
4763 rajveer 2657 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2658 
    """
2659 
    Add the invoice number to the order.
2660 
 
2661 
    Parameters:
2662 
     - orderId
2663 
     - invoiceNumber
4763 rajveer 2664 
     - color
4579 rajveer 2665 
    """
4763 rajveer 2666 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2667 
    self.recv_addInvoiceNumber()
2668 
 
4763 rajveer 2669 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2670 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2671 
    args = addInvoiceNumber_args()
2672 
    args.orderId = orderId
2673 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2674 
    args.color = color
4579 rajveer 2675 
    args.write(self._oprot)
2676 
    self._oprot.writeMessageEnd()
2677 
    self._oprot.trans.flush()
2678 
 
2679 
  def recv_addInvoiceNumber(self, ):
2680 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2681 
    if mtype == TMessageType.EXCEPTION:
2682 
      x = TApplicationException()
2683 
      x.read(self._iprot)
2684 
      self._iprot.readMessageEnd()
2685 
      raise x
2686 
    result = addInvoiceNumber_result()
2687 
    result.read(self._iprot)
2688 
    self._iprot.readMessageEnd()
2689 
    if result.ex is not None:
2690 
      raise result.ex
2691 
    return
2692 
 
4910 phani.kuma 2693 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2694 
    """
3064 chandransh 2695 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2696 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2697 
 
1408 ankur.sing 2698 
    Parameters:
3064 chandransh 2699 
     - warehouseId
1408 ankur.sing 2700 
     - providerId
3064 chandransh 2701 
     - cod
4910 phani.kuma 2702 
     - orderIds
1408 ankur.sing 2703 
    """
4910 phani.kuma 2704 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2705 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2706 
 
4910 phani.kuma 2707 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2708 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2709 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2710 
    args.warehouseId = warehouseId
1408 ankur.sing 2711 
    args.providerId = providerId
3064 chandransh 2712 
    args.cod = cod
4910 phani.kuma 2713 
    args.orderIds = orderIds
1408 ankur.sing 2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
4910 phani.kuma 2718 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
4910 phani.kuma 2725 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
3431 rajveer 2728 
    if result.success is not None:
1408 ankur.sing 2729 
      return result.success
3431 rajveer 2730 
    if result.ex is not None:
3064 chandransh 2731 
      raise result.ex
4910 phani.kuma 2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2733 
 
5713 rajveer 2734 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2735 
    """
2736 
    Parameters:
2737 
     - providerId
2738 
     - orderIds
5713 rajveer 2739 
     - awbs
5676 rajveer 2740 
    """
5713 rajveer 2741 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2742 
    return self.recv_markOrdersAsReturnedFromStore()
2743 
 
5713 rajveer 2744 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2745 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2746 
    args = markOrdersAsReturnedFromStore_args()
2747 
    args.providerId = providerId
2748 
    args.orderIds = orderIds
5713 rajveer 2749 
    args.awbs = awbs
5676 rajveer 2750 
    args.write(self._oprot)
2751 
    self._oprot.writeMessageEnd()
2752 
    self._oprot.trans.flush()
2753 
 
2754 
  def recv_markOrdersAsReturnedFromStore(self, ):
2755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2756 
    if mtype == TMessageType.EXCEPTION:
2757 
      x = TApplicationException()
2758 
      x.read(self._iprot)
2759 
      self._iprot.readMessageEnd()
2760 
      raise x
2761 
    result = markOrdersAsReturnedFromStore_result()
2762 
    result.read(self._iprot)
2763 
    self._iprot.readMessageEnd()
2764 
    if result.success is not None:
2765 
      return result.success
2766 
    if result.ex is not None:
2767 
      raise result.ex
2768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2769 
 
4910 phani.kuma 2770 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2771 
    """
4910 phani.kuma 2772 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2773 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2774 
 
2775 
    Parameters:
2776 
     - providerId
4910 phani.kuma 2777 
     - pickupDetails
4410 rajveer 2778 
    """
4910 phani.kuma 2779 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2780 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2781 
 
4910 phani.kuma 2782 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2783 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2784 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2785 
    args.providerId = providerId
4910 phani.kuma 2786 
    args.pickupDetails = pickupDetails
4410 rajveer 2787 
    args.write(self._oprot)
2788 
    self._oprot.writeMessageEnd()
2789 
    self._oprot.trans.flush()
2790 
 
4910 phani.kuma 2791 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2792 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2793 
    if mtype == TMessageType.EXCEPTION:
2794 
      x = TApplicationException()
2795 
      x.read(self._iprot)
2796 
      self._iprot.readMessageEnd()
2797 
      raise x
4910 phani.kuma 2798 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2799 
    result.read(self._iprot)
2800 
    self._iprot.readMessageEnd()
2801 
    if result.ex is not None:
2802 
      raise result.ex
4910 phani.kuma 2803 
    return
4410 rajveer 2804 
 
4910 phani.kuma 2805 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2806 
    """
3064 chandransh 2807 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2808 
 
94 ashish 2809 
    Parameters:
3064 chandransh 2810 
     - providerId
304 ashish 2811 
    """
4910 phani.kuma 2812 
    self.send_getOrdersNotPickedUp(providerId)
2813 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2814 
 
4910 phani.kuma 2815 
  def send_getOrdersNotPickedUp(self, providerId):
2816 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2817 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2818 
    args.providerId = providerId
304 ashish 2819 
    args.write(self._oprot)
2820 
    self._oprot.writeMessageEnd()
2821 
    self._oprot.trans.flush()
2822 
 
4910 phani.kuma 2823 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2825 
    if mtype == TMessageType.EXCEPTION:
2826 
      x = TApplicationException()
2827 
      x.read(self._iprot)
2828 
      self._iprot.readMessageEnd()
2829 
      raise x
4910 phani.kuma 2830 
    result = getOrdersNotPickedUp_result()
304 ashish 2831 
    result.read(self._iprot)
2832 
    self._iprot.readMessageEnd()
3431 rajveer 2833 
    if result.success is not None:
304 ashish 2834 
      return result.success
4910 phani.kuma 2835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2836 
 
3064 chandransh 2837 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2838 
    """
3064 chandransh 2839 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2840 
    the name of the receiver.
2841 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2842 
 
304 ashish 2843 
    Parameters:
3064 chandransh 2844 
     - providerId
2845 
     - deliveredOrders
304 ashish 2846 
    """
3064 chandransh 2847 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2848 
    self.recv_markOrdersAsDelivered()
304 ashish 2849 
 
3064 chandransh 2850 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2851 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2852 
    args = markOrdersAsDelivered_args()
2853 
    args.providerId = providerId
2854 
    args.deliveredOrders = deliveredOrders
304 ashish 2855 
    args.write(self._oprot)
2856 
    self._oprot.writeMessageEnd()
2857 
    self._oprot.trans.flush()
2858 
 
3064 chandransh 2859 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2861 
    if mtype == TMessageType.EXCEPTION:
2862 
      x = TApplicationException()
2863 
      x.read(self._iprot)
2864 
      self._iprot.readMessageEnd()
2865 
      raise x
3064 chandransh 2866 
    result = markOrdersAsDelivered_result()
304 ashish 2867 
    result.read(self._iprot)
2868 
    self._iprot.readMessageEnd()
3431 rajveer 2869 
    if result.ex is not None:
3064 chandransh 2870 
      raise result.ex
304 ashish 2871 
    return
2872 
 
4910 phani.kuma 2873 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2874 
    """
4910 phani.kuma 2875 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2876 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2877 
 
3064 chandransh 2878 
    Parameters:
2879 
     - providerId
2880 
     - returnedOrders
1596 ankur.sing 2881 
    """
4910 phani.kuma 2882 
    self.send_markAsRTOrders(providerId, returnedOrders)
2883 
    self.recv_markAsRTOrders()
304 ashish 2884 
 
4910 phani.kuma 2885 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2886 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2887 
    args = markAsRTOrders_args()
3064 chandransh 2888 
    args.providerId = providerId
2889 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2890 
    args.write(self._oprot)
2891 
    self._oprot.writeMessageEnd()
2892 
    self._oprot.trans.flush()
2893 
 
4910 phani.kuma 2894 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2896 
    if mtype == TMessageType.EXCEPTION:
2897 
      x = TApplicationException()
2898 
      x.read(self._iprot)
2899 
      self._iprot.readMessageEnd()
2900 
      raise x
4910 phani.kuma 2901 
    result = markAsRTOrders_result()
1596 ankur.sing 2902 
    result.read(self._iprot)
2903 
    self._iprot.readMessageEnd()
3431 rajveer 2904 
    if result.ex is not None:
3064 chandransh 2905 
      raise result.ex
2906 
    return
1596 ankur.sing 2907 
 
4910 phani.kuma 2908 
  def getRTOrders(self, providerId):
2909 
    """
2910 
    Returns a list of orders that were returned by courier.
2911 
 
2912 
    Parameters:
2913 
     - providerId
2914 
    """
2915 
    self.send_getRTOrders(providerId)
2916 
    return self.recv_getRTOrders()
2917 
 
2918 
  def send_getRTOrders(self, providerId):
2919 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2920 
    args = getRTOrders_args()
2921 
    args.providerId = providerId
2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
2926 
  def recv_getRTOrders(self, ):
2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
2933 
    result = getRTOrders_result()
2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
2936 
    if result.success is not None:
2937 
      return result.success
2938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2939 
 
3064 chandransh 2940 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2941 
    """
3064 chandransh 2942 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2943 
 
3064 chandransh 2944 
    Parameters:
2945 
     - providerId
2946 
     - undeliveredOrders
1627 ankur.sing 2947 
    """
3064 chandransh 2948 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2949 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2950 
 
3064 chandransh 2951 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2952 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2953 
    args = updateNonDeliveryReason_args()
2954 
    args.providerId = providerId
2955 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2956 
    args.write(self._oprot)
2957 
    self._oprot.writeMessageEnd()
2958 
    self._oprot.trans.flush()
2959 
 
3064 chandransh 2960 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2962 
    if mtype == TMessageType.EXCEPTION:
2963 
      x = TApplicationException()
2964 
      x.read(self._iprot)
2965 
      self._iprot.readMessageEnd()
2966 
      raise x
3064 chandransh 2967 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2968 
    result.read(self._iprot)
2969 
    self._iprot.readMessageEnd()
4910 phani.kuma 2970 
    if result.ex is not None:
2971 
      raise result.ex
2972 
    return
2973 
 
2974 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2975 
    """
2976 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2977 
 
2978 
    Parameters:
2979 
     - providerId
2980 
    """
2981 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2982 
    return self.recv_getNonDeliveredOrdersbyCourier()
2983 
 
2984 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2985 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2986 
    args = getNonDeliveredOrdersbyCourier_args()
2987 
    args.providerId = providerId
2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
2992 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
2999 
    result = getNonDeliveredOrdersbyCourier_result()
3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
4581 phani.kuma 3002 
    if result.success is not None:
3003 
      return result.success
4910 phani.kuma 3004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3005 
 
3006 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3007 
    """
3008 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3009 
 
3010 
    Parameters:
3011 
     - providerId
3012 
     - local_connected_orders
3013 
    """
3014 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3015 
    self.recv_markOrdersAsLocalConnected()
3016 
 
3017 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3018 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3019 
    args = markOrdersAsLocalConnected_args()
3020 
    args.providerId = providerId
3021 
    args.local_connected_orders = local_connected_orders
3022 
    args.write(self._oprot)
3023 
    self._oprot.writeMessageEnd()
3024 
    self._oprot.trans.flush()
3025 
 
3026 
  def recv_markOrdersAsLocalConnected(self, ):
3027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3028 
    if mtype == TMessageType.EXCEPTION:
3029 
      x = TApplicationException()
3030 
      x.read(self._iprot)
3031 
      self._iprot.readMessageEnd()
3032 
      raise x
3033 
    result = markOrdersAsLocalConnected_result()
3034 
    result.read(self._iprot)
3035 
    self._iprot.readMessageEnd()
3431 rajveer 3036 
    if result.ex is not None:
3064 chandransh 3037 
      raise result.ex
4910 phani.kuma 3038 
    return
1627 ankur.sing 3039 
 
4910 phani.kuma 3040 
  def getOrdersNotLocalConnected(self, providerId):
3041 
    """
3042 
    Returns a list of orders that were picked up or shipped but pending local connection.
3043 
 
3044 
    Parameters:
3045 
     - providerId
3046 
    """
3047 
    self.send_getOrdersNotLocalConnected(providerId)
3048 
    return self.recv_getOrdersNotLocalConnected()
3049 
 
3050 
  def send_getOrdersNotLocalConnected(self, providerId):
3051 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3052 
    args = getOrdersNotLocalConnected_args()
3053 
    args.providerId = providerId
3054 
    args.write(self._oprot)
3055 
    self._oprot.writeMessageEnd()
3056 
    self._oprot.trans.flush()
3057 
 
3058 
  def recv_getOrdersNotLocalConnected(self, ):
3059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3060 
    if mtype == TMessageType.EXCEPTION:
3061 
      x = TApplicationException()
3062 
      x.read(self._iprot)
3063 
      self._iprot.readMessageEnd()
3064 
      raise x
3065 
    result = getOrdersNotLocalConnected_result()
3066 
    result.read(self._iprot)
3067 
    self._iprot.readMessageEnd()
3068 
    if result.success is not None:
3069 
      return result.success
3070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3071 
 
3072 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3073 
    """
3074 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3075 
 
3076 
    Parameters:
3077 
     - providerId
3078 
     - destination_city_reached_orders
3079 
    """
3080 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3081 
    self.recv_markOrdersAsDestinationCityReached()
3082 
 
3083 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3084 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3085 
    args = markOrdersAsDestinationCityReached_args()
3086 
    args.providerId = providerId
3087 
    args.destination_city_reached_orders = destination_city_reached_orders
3088 
    args.write(self._oprot)
3089 
    self._oprot.writeMessageEnd()
3090 
    self._oprot.trans.flush()
3091 
 
3092 
  def recv_markOrdersAsDestinationCityReached(self, ):
3093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3094 
    if mtype == TMessageType.EXCEPTION:
3095 
      x = TApplicationException()
3096 
      x.read(self._iprot)
3097 
      self._iprot.readMessageEnd()
3098 
      raise x
3099 
    result = markOrdersAsDestinationCityReached_result()
3100 
    result.read(self._iprot)
3101 
    self._iprot.readMessageEnd()
3102 
    if result.ex is not None:
3103 
      raise result.ex
3104 
    return
3105 
 
3106 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3107 
    """
3108 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3109 
 
3110 
    Parameters:
3111 
     - providerId
3112 
     - first_atdl_orders
3113 
    """
3114 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3115 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3116 
 
3117 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3118 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3119 
    args = markOrdersAsFirstDeliveryAttempted_args()
3120 
    args.providerId = providerId
3121 
    args.first_atdl_orders = first_atdl_orders
3122 
    args.write(self._oprot)
3123 
    self._oprot.writeMessageEnd()
3124 
    self._oprot.trans.flush()
3125 
 
3126 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3128 
    if mtype == TMessageType.EXCEPTION:
3129 
      x = TApplicationException()
3130 
      x.read(self._iprot)
3131 
      self._iprot.readMessageEnd()
3132 
      raise x
3133 
    result = markOrdersAsFirstDeliveryAttempted_result()
3134 
    result.read(self._iprot)
3135 
    self._iprot.readMessageEnd()
3136 
    if result.ex is not None:
3137 
      raise result.ex
3138 
    return
3139 
 
3064 chandransh 3140 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3141 
    """
3064 chandransh 3142 
    Returns the list of orders whose delivery time has passed but have not been
3143 
    delivered yet for the given provider and warehouse. To get a complete list of
3144 
    undelivered orders, pass them as -1.
3145 
    Returns an empty list if no such orders exist.
3431 rajveer 3146 
 
1886 ankur.sing 3147 
    Parameters:
3064 chandransh 3148 
     - providerId
3149 
     - warehouseId
1886 ankur.sing 3150 
    """
3064 chandransh 3151 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3152 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3153 
 
3064 chandransh 3154 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3155 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3156 
    args = getUndeliveredOrders_args()
3157 
    args.providerId = providerId
3158 
    args.warehouseId = warehouseId
1886 ankur.sing 3159 
    args.write(self._oprot)
3160 
    self._oprot.writeMessageEnd()
3161 
    self._oprot.trans.flush()
3162 
 
3064 chandransh 3163 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3165 
    if mtype == TMessageType.EXCEPTION:
3166 
      x = TApplicationException()
3167 
      x.read(self._iprot)
3168 
      self._iprot.readMessageEnd()
3169 
      raise x
3064 chandransh 3170 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3171 
    result.read(self._iprot)
3172 
    self._iprot.readMessageEnd()
3431 rajveer 3173 
    if result.success is not None:
1886 ankur.sing 3174 
      return result.success
3064 chandransh 3175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3176 
 
4783 phani.kuma 3177 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3178 
    """
3179 
    Returns the list of orders whose expected delivery date has passed but have not been
3180 
    delivered yet.
3181 
    Returns an empty list if no such orders exist.
3182 
    """
3183 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3184 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3185 
 
3186 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3187 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3188 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3189 
    args.write(self._oprot)
3190 
    self._oprot.writeMessageEnd()
3191 
    self._oprot.trans.flush()
3192 
 
3193 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3194 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3195 
    if mtype == TMessageType.EXCEPTION:
3196 
      x = TApplicationException()
3197 
      x.read(self._iprot)
3198 
      self._iprot.readMessageEnd()
3199 
      raise x
3200 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3201 
    result.read(self._iprot)
3202 
    self._iprot.readMessageEnd()
3203 
    if result.success is not None:
3204 
      return result.success
3205 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3206 
 
2536 chandransh 3207 
  def toggleDOAFlag(self, orderId):
3208 
    """
3209 
    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.
3210 
    Returns the final flag status.
3211 
    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 3212 
 
2536 chandransh 3213 
    Parameters:
3214 
     - orderId
3215 
    """
3216 
    self.send_toggleDOAFlag(orderId)
3217 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3218 
 
2536 chandransh 3219 
  def send_toggleDOAFlag(self, orderId):
3220 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3221 
    args = toggleDOAFlag_args()
3222 
    args.orderId = orderId
3223 
    args.write(self._oprot)
3224 
    self._oprot.writeMessageEnd()
3225 
    self._oprot.trans.flush()
3226 
 
3227 
  def recv_toggleDOAFlag(self, ):
3228 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3229 
    if mtype == TMessageType.EXCEPTION:
3230 
      x = TApplicationException()
3231 
      x.read(self._iprot)
3232 
      self._iprot.readMessageEnd()
3233 
      raise x
3234 
    result = toggleDOAFlag_result()
3235 
    result.read(self._iprot)
3236 
    self._iprot.readMessageEnd()
3431 rajveer 3237 
    if result.success is not None:
2536 chandransh 3238 
      return result.success
3431 rajveer 3239 
    if result.ex is not None:
2536 chandransh 3240 
      raise result.ex
3241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3242 
 
4712 rajveer 3243 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3244 
    """
3245 
    Parameters:
3246 
     - orderId
3247 
     - deliveryTimestamp
3248 
     - receiver
3249 
    """
3250 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3251 
    self.recv_markOrderAsDelivered()
3252 
 
3253 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3254 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3255 
    args = markOrderAsDelivered_args()
3256 
    args.orderId = orderId
3257 
    args.deliveryTimestamp = deliveryTimestamp
3258 
    args.receiver = receiver
3259 
    args.write(self._oprot)
3260 
    self._oprot.writeMessageEnd()
3261 
    self._oprot.trans.flush()
3262 
 
3263 
  def recv_markOrderAsDelivered(self, ):
3264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3265 
    if mtype == TMessageType.EXCEPTION:
3266 
      x = TApplicationException()
3267 
      x.read(self._iprot)
3268 
      self._iprot.readMessageEnd()
3269 
      raise x
3270 
    result = markOrderAsDelivered_result()
3271 
    result.read(self._iprot)
3272 
    self._iprot.readMessageEnd()
3273 
    if result.ex is not None:
3274 
      raise result.ex
3275 
    return
3276 
 
5553 rajveer 3277 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3278 
    """
3279 
    Parameters:
3280 
     - orderId
3281 
     - deliveryTimestamp
3282 
    """
3283 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3284 
    self.recv_markOrderAsReceivedAtStore()
3285 
 
3286 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3287 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3288 
    args = markOrderAsReceivedAtStore_args()
3289 
    args.orderId = orderId
3290 
    args.deliveryTimestamp = deliveryTimestamp
3291 
    args.write(self._oprot)
3292 
    self._oprot.writeMessageEnd()
3293 
    self._oprot.trans.flush()
3294 
 
3295 
  def recv_markOrderAsReceivedAtStore(self, ):
3296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3297 
    if mtype == TMessageType.EXCEPTION:
3298 
      x = TApplicationException()
3299 
      x.read(self._iprot)
3300 
      self._iprot.readMessageEnd()
3301 
      raise x
3302 
    result = markOrderAsReceivedAtStore_result()
3303 
    result.read(self._iprot)
3304 
    self._iprot.readMessageEnd()
3305 
    if result.ex is not None:
3306 
      raise result.ex
3307 
    return
3308 
 
4454 rajveer 3309 
  def markOrderDoaRequestReceived(self, orderId):
3310 
    """
3311 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3312 
 
3313 
    Parameters:
3314 
     - orderId
3315 
    """
3316 
    self.send_markOrderDoaRequestReceived(orderId)
3317 
    return self.recv_markOrderDoaRequestReceived()
3318 
 
3319 
  def send_markOrderDoaRequestReceived(self, orderId):
3320 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3321 
    args = markOrderDoaRequestReceived_args()
3322 
    args.orderId = orderId
3323 
    args.write(self._oprot)
3324 
    self._oprot.writeMessageEnd()
3325 
    self._oprot.trans.flush()
3326 
 
3327 
  def recv_markOrderDoaRequestReceived(self, ):
3328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3329 
    if mtype == TMessageType.EXCEPTION:
3330 
      x = TApplicationException()
3331 
      x.read(self._iprot)
3332 
      self._iprot.readMessageEnd()
3333 
      raise x
3334 
    result = markOrderDoaRequestReceived_result()
3335 
    result.read(self._iprot)
3336 
    self._iprot.readMessageEnd()
3337 
    if result.success is not None:
3338 
      return result.success
3339 
    if result.ex is not None:
3340 
      raise result.ex
3341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3342 
 
3343 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3344 
    """
3345 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3346 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3347 
 
3348 
    Parameters:
3349 
     - orderId
3350 
     - isAuthorized
3351 
    """
3352 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3353 
    return self.recv_markOrderDoaRequestAuthorized()
3354 
 
3355 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3356 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3357 
    args = markOrderDoaRequestAuthorized_args()
3358 
    args.orderId = orderId
3359 
    args.isAuthorized = isAuthorized
3360 
    args.write(self._oprot)
3361 
    self._oprot.writeMessageEnd()
3362 
    self._oprot.trans.flush()
3363 
 
3364 
  def recv_markOrderDoaRequestAuthorized(self, ):
3365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3366 
    if mtype == TMessageType.EXCEPTION:
3367 
      x = TApplicationException()
3368 
      x.read(self._iprot)
3369 
      self._iprot.readMessageEnd()
3370 
      raise x
3371 
    result = markOrderDoaRequestAuthorized_result()
3372 
    result.read(self._iprot)
3373 
    self._iprot.readMessageEnd()
3374 
    if result.success is not None:
3375 
      return result.success
3376 
    if result.ex is not None:
3377 
      raise result.ex
3378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3379 
 
4488 rajveer 3380 
  def markOrderReturnRequestReceived(self, orderId):
3381 
    """
3382 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3383 
 
3384 
    Parameters:
3385 
     - orderId
3386 
    """
3387 
    self.send_markOrderReturnRequestReceived(orderId)
3388 
    return self.recv_markOrderReturnRequestReceived()
3389 
 
3390 
  def send_markOrderReturnRequestReceived(self, orderId):
3391 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3392 
    args = markOrderReturnRequestReceived_args()
3393 
    args.orderId = orderId
3394 
    args.write(self._oprot)
3395 
    self._oprot.writeMessageEnd()
3396 
    self._oprot.trans.flush()
3397 
 
3398 
  def recv_markOrderReturnRequestReceived(self, ):
3399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3400 
    if mtype == TMessageType.EXCEPTION:
3401 
      x = TApplicationException()
3402 
      x.read(self._iprot)
3403 
      self._iprot.readMessageEnd()
3404 
      raise x
3405 
    result = markOrderReturnRequestReceived_result()
3406 
    result.read(self._iprot)
3407 
    self._iprot.readMessageEnd()
3408 
    if result.success is not None:
3409 
      return result.success
3410 
    if result.ex is not None:
3411 
      raise result.ex
3412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3413 
 
3414 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3415 
    """
3416 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3417 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3418 
 
3419 
    Parameters:
3420 
     - orderId
3421 
     - isAuthorized
3422 
    """
3423 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3424 
    return self.recv_markOrderReturnRequestAuthorized()
3425 
 
3426 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3427 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3428 
    args = markOrderReturnRequestAuthorized_args()
3429 
    args.orderId = orderId
3430 
    args.isAuthorized = isAuthorized
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_markOrderReturnRequestAuthorized(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = markOrderReturnRequestAuthorized_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.success is not None:
3446 
      return result.success
3447 
    if result.ex is not None:
3448 
      raise result.ex
3449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3450 
 
4579 rajveer 3451 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3452 
    """
3453 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3454 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3455 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3456 
    For any other status, it returns false.
3457 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3458 
 
2536 chandransh 3459 
    Parameters:
3460 
     - orderId
4579 rajveer 3461 
     - providerId
2536 chandransh 3462 
    """
4579 rajveer 3463 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3464 
    return self.recv_requestPickupNumber()
3465 
 
4579 rajveer 3466 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3467 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3468 
    args = requestPickupNumber_args()
3469 
    args.orderId = orderId
4579 rajveer 3470 
    args.providerId = providerId
2536 chandransh 3471 
    args.write(self._oprot)
3472 
    self._oprot.writeMessageEnd()
3473 
    self._oprot.trans.flush()
3474 
 
3475 
  def recv_requestPickupNumber(self, ):
3476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3477 
    if mtype == TMessageType.EXCEPTION:
3478 
      x = TApplicationException()
3479 
      x.read(self._iprot)
3480 
      self._iprot.readMessageEnd()
3481 
      raise x
3482 
    result = requestPickupNumber_result()
3483 
    result.read(self._iprot)
3484 
    self._iprot.readMessageEnd()
3431 rajveer 3485 
    if result.success is not None:
2536 chandransh 3486 
      return result.success
3431 rajveer 3487 
    if result.ex is not None:
2536 chandransh 3488 
      raise result.ex
3489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3490 
 
4602 rajveer 3491 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3492 
    """
4452 rajveer 3493 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3494 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3495 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3496 
    	3. Returns true
2591 chandransh 3497 
    If the order is in any other status, it returns false.
2536 chandransh 3498 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3499 
 
2536 chandransh 3500 
    Parameters:
3501 
     - orderId
3502 
     - pickupNumber
4602 rajveer 3503 
     - providerId
2536 chandransh 3504 
    """
4602 rajveer 3505 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3506 
    return self.recv_authorizePickup()
3507 
 
4602 rajveer 3508 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3509 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3510 
    args = authorizePickup_args()
3511 
    args.orderId = orderId
3512 
    args.pickupNumber = pickupNumber
4602 rajveer 3513 
    args.providerId = providerId
2536 chandransh 3514 
    args.write(self._oprot)
3515 
    self._oprot.writeMessageEnd()
3516 
    self._oprot.trans.flush()
3517 
 
3518 
  def recv_authorizePickup(self, ):
3519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3520 
    if mtype == TMessageType.EXCEPTION:
3521 
      x = TApplicationException()
3522 
      x.read(self._iprot)
3523 
      self._iprot.readMessageEnd()
3524 
      raise x
3525 
    result = authorizePickup_result()
3526 
    result.read(self._iprot)
3527 
    self._iprot.readMessageEnd()
3431 rajveer 3528 
    if result.success is not None:
2536 chandransh 3529 
      return result.success
3431 rajveer 3530 
    if result.ex is not None:
2536 chandransh 3531 
      raise result.ex
3532 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3533 
 
2764 chandransh 3534 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3535 
    """
3536 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3537 
 
2764 chandransh 3538 
    Parameters:
3539 
     - providerId
3540 
     - pickupDetails
3541 
    """
3542 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3543 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3544 
 
3545 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3546 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3547 
    args = markDoasAsPickedUp_args()
3548 
    args.providerId = providerId
3549 
    args.pickupDetails = pickupDetails
3550 
    args.write(self._oprot)
3551 
    self._oprot.writeMessageEnd()
3552 
    self._oprot.trans.flush()
3553 
 
3554 
  def recv_markDoasAsPickedUp(self, ):
3555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3556 
    if mtype == TMessageType.EXCEPTION:
3557 
      x = TApplicationException()
3558 
      x.read(self._iprot)
3559 
      self._iprot.readMessageEnd()
3560 
      raise x
3561 
    result = markDoasAsPickedUp_result()
3562 
    result.read(self._iprot)
3563 
    self._iprot.readMessageEnd()
4910 phani.kuma 3564 
    return
3565 
 
3566 
  def getDoasNotPickedUp(self, providerId):
3567 
    """
3568 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3569 
 
3570 
    Parameters:
3571 
     - providerId
3572 
    """
3573 
    self.send_getDoasNotPickedUp(providerId)
3574 
    return self.recv_getDoasNotPickedUp()
3575 
 
3576 
  def send_getDoasNotPickedUp(self, providerId):
3577 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3578 
    args = getDoasNotPickedUp_args()
3579 
    args.providerId = providerId
3580 
    args.write(self._oprot)
3581 
    self._oprot.writeMessageEnd()
3582 
    self._oprot.trans.flush()
3583 
 
3584 
  def recv_getDoasNotPickedUp(self, ):
3585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3586 
    if mtype == TMessageType.EXCEPTION:
3587 
      x = TApplicationException()
3588 
      x.read(self._iprot)
3589 
      self._iprot.readMessageEnd()
3590 
      raise x
3591 
    result = getDoasNotPickedUp_result()
3592 
    result.read(self._iprot)
3593 
    self._iprot.readMessageEnd()
3431 rajveer 3594 
    if result.success is not None:
2764 chandransh 3595 
      return result.success
4910 phani.kuma 3596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3597 
 
4741 phani.kuma 3598 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3599 
    """
3600 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3601 
 
3602 
    Parameters:
3603 
     - providerId
3604 
     - pickupDetails
3605 
    """
3606 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3607 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3608 
 
3609 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3610 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3611 
    args = markReturnOrdersAsPickedUp_args()
3612 
    args.providerId = providerId
3613 
    args.pickupDetails = pickupDetails
3614 
    args.write(self._oprot)
3615 
    self._oprot.writeMessageEnd()
3616 
    self._oprot.trans.flush()
3617 
 
3618 
  def recv_markReturnOrdersAsPickedUp(self, ):
3619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3620 
    if mtype == TMessageType.EXCEPTION:
3621 
      x = TApplicationException()
3622 
      x.read(self._iprot)
3623 
      self._iprot.readMessageEnd()
3624 
      raise x
3625 
    result = markReturnOrdersAsPickedUp_result()
3626 
    result.read(self._iprot)
3627 
    self._iprot.readMessageEnd()
4910 phani.kuma 3628 
    return
3629 
 
3630 
  def getReturnOrdersNotPickedUp(self, providerId):
3631 
    """
3632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3633 
 
3634 
    Parameters:
3635 
     - providerId
3636 
    """
3637 
    self.send_getReturnOrdersNotPickedUp(providerId)
3638 
    return self.recv_getReturnOrdersNotPickedUp()
3639 
 
3640 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3641 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3642 
    args = getReturnOrdersNotPickedUp_args()
3643 
    args.providerId = providerId
3644 
    args.write(self._oprot)
3645 
    self._oprot.writeMessageEnd()
3646 
    self._oprot.trans.flush()
3647 
 
3648 
  def recv_getReturnOrdersNotPickedUp(self, ):
3649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3650 
    if mtype == TMessageType.EXCEPTION:
3651 
      x = TApplicationException()
3652 
      x.read(self._iprot)
3653 
      self._iprot.readMessageEnd()
3654 
      raise x
3655 
    result = getReturnOrdersNotPickedUp_result()
3656 
    result.read(self._iprot)
3657 
    self._iprot.readMessageEnd()
4741 phani.kuma 3658 
    if result.success is not None:
3659 
      return result.success
4910 phani.kuma 3660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3661 
 
4479 rajveer 3662 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3663 
    """
4452 rajveer 3664 
    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 3665 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3666 
    If the order is in any other state, it returns false.
3667 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3668 
 
2591 chandransh 3669 
    Parameters:
3670 
     - orderId
4479 rajveer 3671 
     - receiveCondition
2591 chandransh 3672 
    """
4479 rajveer 3673 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3674 
    return self.recv_receiveReturn()
2536 chandransh 3675 
 
4479 rajveer 3676 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3677 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3678 
    args = receiveReturn_args()
2591 chandransh 3679 
    args.orderId = orderId
4479 rajveer 3680 
    args.receiveCondition = receiveCondition
2591 chandransh 3681 
    args.write(self._oprot)
3682 
    self._oprot.writeMessageEnd()
3683 
    self._oprot.trans.flush()
3684 
 
2616 chandransh 3685 
  def recv_receiveReturn(self, ):
2591 chandransh 3686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3687 
    if mtype == TMessageType.EXCEPTION:
3688 
      x = TApplicationException()
3689 
      x.read(self._iprot)
3690 
      self._iprot.readMessageEnd()
3691 
      raise x
2616 chandransh 3692 
    result = receiveReturn_result()
2591 chandransh 3693 
    result.read(self._iprot)
3694 
    self._iprot.readMessageEnd()
3431 rajveer 3695 
    if result.success is not None:
2591 chandransh 3696 
      return result.success
3431 rajveer 3697 
    if result.ex is not None:
2591 chandransh 3698 
      raise result.ex
2616 chandransh 3699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3700 
 
3701 
  def validateDoa(self, orderId, isValid):
3702 
    """
4452 rajveer 3703 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3704 
    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 3705 
    If the order is in any other state, it returns false.
3706 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3707 
 
2591 chandransh 3708 
    Parameters:
3709 
     - orderId
3710 
     - isValid
3711 
    """
3712 
    self.send_validateDoa(orderId, isValid)
3713 
    return self.recv_validateDoa()
3714 
 
3715 
  def send_validateDoa(self, orderId, isValid):
3716 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3717 
    args = validateDoa_args()
3718 
    args.orderId = orderId
3719 
    args.isValid = isValid
3720 
    args.write(self._oprot)
3721 
    self._oprot.writeMessageEnd()
3722 
    self._oprot.trans.flush()
3723 
 
3724 
  def recv_validateDoa(self, ):
3725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3726 
    if mtype == TMessageType.EXCEPTION:
3727 
      x = TApplicationException()
3728 
      x.read(self._iprot)
3729 
      self._iprot.readMessageEnd()
3730 
      raise x
3731 
    result = validateDoa_result()
3732 
    result.read(self._iprot)
3733 
    self._iprot.readMessageEnd()
3431 rajveer 3734 
    if result.success is not None:
2591 chandransh 3735 
      return result.success
3431 rajveer 3736 
    if result.ex is not None:
2591 chandransh 3737 
      raise result.ex
3738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3739 
 
4495 rajveer 3740 
  def validateReturnProduct(self, orderId, isUsable):
3741 
    """
3742 
    Parameters:
3743 
     - orderId
3744 
     - isUsable
3745 
    """
3746 
    self.send_validateReturnProduct(orderId, isUsable)
3747 
    return self.recv_validateReturnProduct()
3748 
 
3749 
  def send_validateReturnProduct(self, orderId, isUsable):
3750 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3751 
    args = validateReturnProduct_args()
3752 
    args.orderId = orderId
3753 
    args.isUsable = isUsable
3754 
    args.write(self._oprot)
3755 
    self._oprot.writeMessageEnd()
3756 
    self._oprot.trans.flush()
3757 
 
3758 
  def recv_validateReturnProduct(self, ):
3759 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3760 
    if mtype == TMessageType.EXCEPTION:
3761 
      x = TApplicationException()
3762 
      x.read(self._iprot)
3763 
      self._iprot.readMessageEnd()
3764 
      raise x
3765 
    result = validateReturnProduct_result()
3766 
    result.read(self._iprot)
3767 
    self._iprot.readMessageEnd()
3768 
    if result.success is not None:
3769 
      return result.success
3770 
    if result.ex is not None:
3771 
      raise result.ex
3772 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3773 
 
2616 chandransh 3774 
  def reshipOrder(self, orderId):
3775 
    """
4484 rajveer 3776 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3777 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3778 
    	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 3779 
 
3780 
    If the order is in DOA_CERT_VALID state, it does the following:
3781 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3782 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3783 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3784 
 
2616 chandransh 3785 
    Returns the id of the newly created order.
3431 rajveer 3786 
 
2616 chandransh 3787 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3788 
 
2616 chandransh 3789 
    Parameters:
3790 
     - orderId
3791 
    """
3792 
    self.send_reshipOrder(orderId)
3793 
    return self.recv_reshipOrder()
2591 chandransh 3794 
 
2616 chandransh 3795 
  def send_reshipOrder(self, orderId):
3796 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3797 
    args = reshipOrder_args()
3798 
    args.orderId = orderId
3799 
    args.write(self._oprot)
3800 
    self._oprot.writeMessageEnd()
3801 
    self._oprot.trans.flush()
3802 
 
3803 
  def recv_reshipOrder(self, ):
3804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3805 
    if mtype == TMessageType.EXCEPTION:
3806 
      x = TApplicationException()
3807 
      x.read(self._iprot)
3808 
      self._iprot.readMessageEnd()
3809 
      raise x
3810 
    result = reshipOrder_result()
3811 
    result.read(self._iprot)
3812 
    self._iprot.readMessageEnd()
3431 rajveer 3813 
    if result.success is not None:
2616 chandransh 3814 
      return result.success
3431 rajveer 3815 
    if result.ex is not None:
2616 chandransh 3816 
      raise result.ex
3817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3818 
 
3226 chandransh 3819 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3820 
    """
4484 rajveer 3821 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3822 
    	1. Creates a refund request for batch processing.
3823 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3824 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3825 
 
2616 chandransh 3826 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3827 
    	1. Creates a refund request for batch processing.
3226 chandransh 3828 
    	2. Cancels the reservation of the item in the warehouse.
3829 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3830 
 
3226 chandransh 3831 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3832 
    	1. Cancels the reservation of the item in the warehouse.
3833 
    	2. Marks the current order as CANCELED.
3834 
 
3835 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3836 
 
2616 chandransh 3837 
    Returns True if it is successful, False otherwise.
3431 rajveer 3838 
 
2616 chandransh 3839 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3840 
 
2616 chandransh 3841 
    Parameters:
3842 
     - orderId
3226 chandransh 3843 
     - refundedBy
3844 
     - reason
2616 chandransh 3845 
    """
3226 chandransh 3846 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3847 
    return self.recv_refundOrder()
3848 
 
3226 chandransh 3849 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3850 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3851 
    args = refundOrder_args()
3852 
    args.orderId = orderId
3226 chandransh 3853 
    args.refundedBy = refundedBy
3854 
    args.reason = reason
2616 chandransh 3855 
    args.write(self._oprot)
3856 
    self._oprot.writeMessageEnd()
3857 
    self._oprot.trans.flush()
3858 
 
3859 
  def recv_refundOrder(self, ):
3860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3861 
    if mtype == TMessageType.EXCEPTION:
3862 
      x = TApplicationException()
3863 
      x.read(self._iprot)
3864 
      self._iprot.readMessageEnd()
3865 
      raise x
3866 
    result = refundOrder_result()
3867 
    result.read(self._iprot)
3868 
    self._iprot.readMessageEnd()
3431 rajveer 3869 
    if result.success is not None:
2616 chandransh 3870 
      return result.success
3431 rajveer 3871 
    if result.ex is not None:
2616 chandransh 3872 
      raise result.ex
3873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3874 
 
2690 chandransh 3875 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3876 
    """
3877 
    Get all return orders created between the from and to dates for the given warehouse.
3878 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3879 
 
2690 chandransh 3880 
    Parameters:
3881 
     - warehouseId
3882 
     - fromDate
3883 
     - toDate
3884 
    """
3885 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3886 
    return self.recv_getReturnOrders()
2616 chandransh 3887 
 
2690 chandransh 3888 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3889 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3890 
    args = getReturnOrders_args()
3891 
    args.warehouseId = warehouseId
3892 
    args.fromDate = fromDate
3893 
    args.toDate = toDate
3894 
    args.write(self._oprot)
3895 
    self._oprot.writeMessageEnd()
3896 
    self._oprot.trans.flush()
3897 
 
3898 
  def recv_getReturnOrders(self, ):
3899 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3900 
    if mtype == TMessageType.EXCEPTION:
3901 
      x = TApplicationException()
3902 
      x.read(self._iprot)
3903 
      self._iprot.readMessageEnd()
3904 
      raise x
3905 
    result = getReturnOrders_result()
3906 
    result.read(self._iprot)
3907 
    self._iprot.readMessageEnd()
3431 rajveer 3908 
    if result.success is not None:
2690 chandransh 3909 
      return result.success
3910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3911 
 
5481 phani.kuma 3912 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3913 
    """
3914 
    Get all return orders created between the from and to dates.
3915 
 
3916 
    Parameters:
3917 
     - onlyNotProcessed
3918 
     - fromDate
3919 
     - toDate
3920 
    """
3921 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3922 
    return self.recv_getAllReturnOrders()
3923 
 
3924 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3925 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3926 
    args = getAllReturnOrders_args()
3927 
    args.onlyNotProcessed = onlyNotProcessed
3928 
    args.fromDate = fromDate
3929 
    args.toDate = toDate
3930 
    args.write(self._oprot)
3931 
    self._oprot.writeMessageEnd()
3932 
    self._oprot.trans.flush()
3933 
 
3934 
  def recv_getAllReturnOrders(self, ):
3935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3936 
    if mtype == TMessageType.EXCEPTION:
3937 
      x = TApplicationException()
3938 
      x.read(self._iprot)
3939 
      self._iprot.readMessageEnd()
3940 
      raise x
3941 
    result = getAllReturnOrders_result()
3942 
    result.read(self._iprot)
3943 
    self._iprot.readMessageEnd()
3944 
    if result.success is not None:
3945 
      return result.success
3946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3947 
 
2700 chandransh 3948 
  def getReturnOrder(self, id):
3949 
    """
3950 
    Returns the ReturnOrder corresponding to the given id.
3951 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3952 
 
2700 chandransh 3953 
    Parameters:
3954 
     - id
3955 
    """
3956 
    self.send_getReturnOrder(id)
3957 
    return self.recv_getReturnOrder()
3958 
 
3959 
  def send_getReturnOrder(self, id):
3960 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3961 
    args = getReturnOrder_args()
3962 
    args.id = id
3963 
    args.write(self._oprot)
3964 
    self._oprot.writeMessageEnd()
3965 
    self._oprot.trans.flush()
3966 
 
3967 
  def recv_getReturnOrder(self, ):
3968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3969 
    if mtype == TMessageType.EXCEPTION:
3970 
      x = TApplicationException()
3971 
      x.read(self._iprot)
3972 
      self._iprot.readMessageEnd()
3973 
      raise x
3974 
    result = getReturnOrder_result()
3975 
    result.read(self._iprot)
3976 
    self._iprot.readMessageEnd()
3431 rajveer 3977 
    if result.success is not None:
2700 chandransh 3978 
      return result.success
3431 rajveer 3979 
    if result.ex is not None:
2700 chandransh 3980 
      raise result.ex
3981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3982 
 
2690 chandransh 3983 
  def processReturn(self, returnOrderId):
3984 
    """
3985 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3986 
 
2690 chandransh 3987 
    Parameters:
3988 
     - returnOrderId
3989 
    """
3990 
    self.send_processReturn(returnOrderId)
3991 
    self.recv_processReturn()
3992 
 
3993 
  def send_processReturn(self, returnOrderId):
3994 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3995 
    args = processReturn_args()
3996 
    args.returnOrderId = returnOrderId
3997 
    args.write(self._oprot)
3998 
    self._oprot.writeMessageEnd()
3999 
    self._oprot.trans.flush()
4000 
 
4001 
  def recv_processReturn(self, ):
4002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4003 
    if mtype == TMessageType.EXCEPTION:
4004 
      x = TApplicationException()
4005 
      x.read(self._iprot)
4006 
      self._iprot.readMessageEnd()
4007 
      raise x
4008 
    result = processReturn_result()
4009 
    result.read(self._iprot)
4010 
    self._iprot.readMessageEnd()
3431 rajveer 4011 
    if result.ex is not None:
2690 chandransh 4012 
      raise result.ex
4013 
    return
4014 
 
3451 chandransh 4015 
  def updateWeight(self, orderId, weight):
4016 
    """
4017 
    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 4018 
 
3451 chandransh 4019 
    Parameters:
4020 
     - orderId
4021 
     - weight
4022 
    """
4023 
    self.send_updateWeight(orderId, weight)
4024 
    return self.recv_updateWeight()
4025 
 
4026 
  def send_updateWeight(self, orderId, weight):
4027 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4028 
    args = updateWeight_args()
4029 
    args.orderId = orderId
4030 
    args.weight = weight
4031 
    args.write(self._oprot)
4032 
    self._oprot.writeMessageEnd()
4033 
    self._oprot.trans.flush()
4034 
 
4035 
  def recv_updateWeight(self, ):
4036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4037 
    if mtype == TMessageType.EXCEPTION:
4038 
      x = TApplicationException()
4039 
      x.read(self._iprot)
4040 
      self._iprot.readMessageEnd()
4041 
      raise x
4042 
    result = updateWeight_result()
4043 
    result.read(self._iprot)
4044 
    self._iprot.readMessageEnd()
4045 
    if result.success is not None:
4046 
      return result.success
4047 
    if result.ex is not None:
4048 
      raise result.ex
4049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4050 
 
3469 chandransh 4051 
  def changeItem(self, orderId, itemId):
4052 
    """
4053 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4054 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4055 
 
3469 chandransh 4056 
    Parameters:
4057 
     - orderId
4058 
     - itemId
4059 
    """
4060 
    self.send_changeItem(orderId, itemId)
4061 
    return self.recv_changeItem()
4062 
 
4063 
  def send_changeItem(self, orderId, itemId):
4064 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4065 
    args = changeItem_args()
4066 
    args.orderId = orderId
4067 
    args.itemId = itemId
4068 
    args.write(self._oprot)
4069 
    self._oprot.writeMessageEnd()
4070 
    self._oprot.trans.flush()
4071 
 
4072 
  def recv_changeItem(self, ):
4073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4074 
    if mtype == TMessageType.EXCEPTION:
4075 
      x = TApplicationException()
4076 
      x.read(self._iprot)
4077 
      self._iprot.readMessageEnd()
4078 
      raise x
4079 
    result = changeItem_result()
4080 
    result.read(self._iprot)
4081 
    self._iprot.readMessageEnd()
4082 
    if result.success is not None:
4083 
      return result.success
4084 
    if result.ex is not None:
4085 
      raise result.ex
4086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4087 
 
4088 
  def shiftToWarehouse(self, orderId, warehouseId):
4089 
    """
4090 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4091 
 
4092 
    Parameters:
4093 
     - orderId
4094 
     - warehouseId
4095 
    """
4096 
    self.send_shiftToWarehouse(orderId, warehouseId)
4097 
    return self.recv_shiftToWarehouse()
4098 
 
4099 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4100 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4101 
    args = shiftToWarehouse_args()
4102 
    args.orderId = orderId
4103 
    args.warehouseId = warehouseId
4104 
    args.write(self._oprot)
4105 
    self._oprot.writeMessageEnd()
4106 
    self._oprot.trans.flush()
4107 
 
4108 
  def recv_shiftToWarehouse(self, ):
4109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4110 
    if mtype == TMessageType.EXCEPTION:
4111 
      x = TApplicationException()
4112 
      x.read(self._iprot)
4113 
      self._iprot.readMessageEnd()
4114 
      raise x
4115 
    result = shiftToWarehouse_result()
4116 
    result.read(self._iprot)
4117 
    self._iprot.readMessageEnd()
4118 
    if result.success is not None:
4119 
      return result.success
4120 
    if result.ex is not None:
4121 
      raise result.ex
4122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4123 
 
4647 rajveer 4124 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4125 
    """
4126 
    Adds the given delay reason to the given order.
3986 chandransh 4127 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4128 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4129 
 
3553 chandransh 4130 
    Parameters:
4131 
     - orderId
4132 
     - delayReason
3986 chandransh 4133 
     - furtherDelay
4647 rajveer 4134 
     - delayReasonText
3553 chandransh 4135 
    """
4647 rajveer 4136 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4137 
    return self.recv_addDelayReason()
4138 
 
4647 rajveer 4139 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4140 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4141 
    args = addDelayReason_args()
4142 
    args.orderId = orderId
4143 
    args.delayReason = delayReason
3986 chandransh 4144 
    args.furtherDelay = furtherDelay
4647 rajveer 4145 
    args.delayReasonText = delayReasonText
3553 chandransh 4146 
    args.write(self._oprot)
4147 
    self._oprot.writeMessageEnd()
4148 
    self._oprot.trans.flush()
4149 
 
4150 
  def recv_addDelayReason(self, ):
4151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4152 
    if mtype == TMessageType.EXCEPTION:
4153 
      x = TApplicationException()
4154 
      x.read(self._iprot)
4155 
      self._iprot.readMessageEnd()
4156 
      raise x
4157 
    result = addDelayReason_result()
4158 
    result.read(self._iprot)
4159 
    self._iprot.readMessageEnd()
4160 
    if result.success is not None:
4161 
      return result.success
4162 
    if result.ex is not None:
4163 
      raise result.ex
4164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4165 
 
3956 chandransh 4166 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4167 
    """
4168 
    Marks the COD orders with given AWB nos. as having been processed.
4169 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4170 
 
3956 chandransh 4171 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4172 
    1. There is no order corresponding to an AWB number.
4173 
    2. The captured amount for a payment exceeds the total payment.
4174 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4175 
 
4176 
    Parameters:
4177 
     - collectedAmountMap
4178 
     - xferBy
4179 
     - xferTxnId
4180 
     - xferDate
4181 
    """
4182 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4183 
    return self.recv_reconcileCodCollection()
4184 
 
4185 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4186 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4187 
    args = reconcileCodCollection_args()
4188 
    args.collectedAmountMap = collectedAmountMap
4189 
    args.xferBy = xferBy
4190 
    args.xferTxnId = xferTxnId
4191 
    args.xferDate = xferDate
4192 
    args.write(self._oprot)
4193 
    self._oprot.writeMessageEnd()
4194 
    self._oprot.trans.flush()
4195 
 
4196 
  def recv_reconcileCodCollection(self, ):
4197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4198 
    if mtype == TMessageType.EXCEPTION:
4199 
      x = TApplicationException()
4200 
      x.read(self._iprot)
4201 
      self._iprot.readMessageEnd()
4202 
      raise x
4203 
    result = reconcileCodCollection_result()
4204 
    result.read(self._iprot)
4205 
    self._iprot.readMessageEnd()
4206 
    if result.success is not None:
4207 
      return result.success
4208 
    if result.ex is not None:
4209 
      raise result.ex
4210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4211 
 
4008 mandeep.dh 4212 
  def getTransactionsRequiringExtraProcessing(self, category):
4213 
    """
4065 mandeep.dh 4214 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4215 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4216 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4217 
 
4008 mandeep.dh 4218 
    Parameters:
4219 
     - category
4220 
    """
4221 
    self.send_getTransactionsRequiringExtraProcessing(category)
4222 
    return self.recv_getTransactionsRequiringExtraProcessing()
4223 
 
4224 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4225 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4226 
    args = getTransactionsRequiringExtraProcessing_args()
4227 
    args.category = category
4228 
    args.write(self._oprot)
4229 
    self._oprot.writeMessageEnd()
4230 
    self._oprot.trans.flush()
4231 
 
4232 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4234 
    if mtype == TMessageType.EXCEPTION:
4235 
      x = TApplicationException()
4236 
      x.read(self._iprot)
4237 
      self._iprot.readMessageEnd()
4238 
      raise x
4239 
    result = getTransactionsRequiringExtraProcessing_result()
4240 
    result.read(self._iprot)
4241 
    self._iprot.readMessageEnd()
4242 
    if result.success is not None:
4243 
      return result.success
4244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4245 
 
4246 
  def markTransactionAsProcessed(self, transactionId, category):
4247 
    """
4248 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4249 
    It essentially deletes the transaction id record for a particular
4250 
    processing type category (if present) from DB.
4251 
    This is currently used by CRM application.
4008 mandeep.dh 4252 
 
4253 
    Parameters:
4254 
     - transactionId
4255 
     - category
4256 
    """
4257 
    self.send_markTransactionAsProcessed(transactionId, category)
4258 
    self.recv_markTransactionAsProcessed()
4259 
 
4260 
  def send_markTransactionAsProcessed(self, transactionId, category):
4261 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4262 
    args = markTransactionAsProcessed_args()
4263 
    args.transactionId = transactionId
4264 
    args.category = category
4265 
    args.write(self._oprot)
4266 
    self._oprot.writeMessageEnd()
4267 
    self._oprot.trans.flush()
4268 
 
4269 
  def recv_markTransactionAsProcessed(self, ):
4270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4271 
    if mtype == TMessageType.EXCEPTION:
4272 
      x = TApplicationException()
4273 
      x.read(self._iprot)
4274 
      self._iprot.readMessageEnd()
4275 
      raise x
4276 
    result = markTransactionAsProcessed_result()
4277 
    result.read(self._iprot)
4278 
    self._iprot.readMessageEnd()
4279 
    return
4280 
 
4018 chandransh 4281 
  def getItemWiseRiskyOrdersCount(self, ):
4282 
    """
4283 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4284 
    is defined as one whose shipping date is about to expire.
4285 
    """
4286 
    self.send_getItemWiseRiskyOrdersCount()
4287 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4288 
 
4018 chandransh 4289 
  def send_getItemWiseRiskyOrdersCount(self, ):
4290 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4291 
    args = getItemWiseRiskyOrdersCount_args()
4292 
    args.write(self._oprot)
4293 
    self._oprot.writeMessageEnd()
4294 
    self._oprot.trans.flush()
4295 
 
4296 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4298 
    if mtype == TMessageType.EXCEPTION:
4299 
      x = TApplicationException()
4300 
      x.read(self._iprot)
4301 
      self._iprot.readMessageEnd()
4302 
      raise x
4303 
    result = getItemWiseRiskyOrdersCount_result()
4304 
    result.read(self._iprot)
4305 
    self._iprot.readMessageEnd()
4306 
    if result.success is not None:
4307 
      return result.success
4308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4309 
 
4295 varun.gupt 4310 
  def getOrdersForItemIds(self, itemIds):
4311 
    """
4312 
    Returns a list of all orders which have items with given id
4313 
 
4314 
    Parameters:
4315 
     - itemIds
4316 
    """
4317 
    self.send_getOrdersForItemIds(itemIds)
4318 
    return self.recv_getOrdersForItemIds()
4319 
 
4320 
  def send_getOrdersForItemIds(self, itemIds):
4321 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4322 
    args = getOrdersForItemIds_args()
4323 
    args.itemIds = itemIds
4324 
    args.write(self._oprot)
4325 
    self._oprot.writeMessageEnd()
4326 
    self._oprot.trans.flush()
4327 
 
4328 
  def recv_getOrdersForItemIds(self, ):
4329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4330 
    if mtype == TMessageType.EXCEPTION:
4331 
      x = TApplicationException()
4332 
      x.read(self._iprot)
4333 
      self._iprot.readMessageEnd()
4334 
      raise x
4335 
    result = getOrdersForItemIds_result()
4336 
    result.read(self._iprot)
4337 
    self._iprot.readMessageEnd()
4338 
    if result.success is not None:
4339 
      return result.success
4340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4341 
 
4247 rajveer 4342 
  def markOrderCancellationRequestReceived(self, orderId):
4343 
    """
4344 
    Mark order as cancellation request received. If customer sends request of cancellation of
4345 
    a particular order, this method will be called. It will just change status of the order
4346 
    depending on its current status. It also records the previous status, so that we can move
4347 
    back to that status if cancellation request is denied.
4018 chandransh 4348 
 
4247 rajveer 4349 
    Parameters:
4350 
     - orderId
4351 
    """
4352 
    self.send_markOrderCancellationRequestReceived(orderId)
4353 
    self.recv_markOrderCancellationRequestReceived()
4354 
 
4355 
  def send_markOrderCancellationRequestReceived(self, orderId):
4356 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4357 
    args = markOrderCancellationRequestReceived_args()
4358 
    args.orderId = orderId
4359 
    args.write(self._oprot)
4360 
    self._oprot.writeMessageEnd()
4361 
    self._oprot.trans.flush()
4362 
 
4363 
  def recv_markOrderCancellationRequestReceived(self, ):
4364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4365 
    if mtype == TMessageType.EXCEPTION:
4366 
      x = TApplicationException()
4367 
      x.read(self._iprot)
4368 
      self._iprot.readMessageEnd()
4369 
      raise x
4370 
    result = markOrderCancellationRequestReceived_result()
4371 
    result.read(self._iprot)
4372 
    self._iprot.readMessageEnd()
4373 
    if result.ex is not None:
4374 
      raise result.ex
4375 
    return
4376 
 
4377 
  def markOrderCancellationRequestConfirmed(self, orderId):
4378 
    """
4379 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4380 
    cancellation request confirmed. After this OM will be able to cancel the order.
4381 
 
4382 
    Parameters:
4383 
     - orderId
4384 
    """
4385 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4386 
    self.recv_markOrderCancellationRequestConfirmed()
4387 
 
4388 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4389 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4390 
    args = markOrderCancellationRequestConfirmed_args()
4391 
    args.orderId = orderId
4392 
    args.write(self._oprot)
4393 
    self._oprot.writeMessageEnd()
4394 
    self._oprot.trans.flush()
4395 
 
4396 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4398 
    if mtype == TMessageType.EXCEPTION:
4399 
      x = TApplicationException()
4400 
      x.read(self._iprot)
4401 
      self._iprot.readMessageEnd()
4402 
      raise x
4403 
    result = markOrderCancellationRequestConfirmed_result()
4404 
    result.read(self._iprot)
4405 
    self._iprot.readMessageEnd()
4406 
    if result.ex is not None:
4407 
      raise result.ex
4408 
    return
4409 
 
4410 
  def markOrderCancellationRequestDenied(self, orderId):
4411 
    """
4412 
    If we decide to not to cancel order, we will move the order ro previous status.
4413 
 
4414 
    Parameters:
4415 
     - orderId
4416 
    """
4417 
    self.send_markOrderCancellationRequestDenied(orderId)
4418 
    self.recv_markOrderCancellationRequestDenied()
4419 
 
4420 
  def send_markOrderCancellationRequestDenied(self, orderId):
4421 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4422 
    args = markOrderCancellationRequestDenied_args()
4423 
    args.orderId = orderId
4424 
    args.write(self._oprot)
4425 
    self._oprot.writeMessageEnd()
4426 
    self._oprot.trans.flush()
4427 
 
4428 
  def recv_markOrderCancellationRequestDenied(self, ):
4429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4430 
    if mtype == TMessageType.EXCEPTION:
4431 
      x = TApplicationException()
4432 
      x.read(self._iprot)
4433 
      self._iprot.readMessageEnd()
4434 
      raise x
4435 
    result = markOrderCancellationRequestDenied_result()
4436 
    result.read(self._iprot)
4437 
    self._iprot.readMessageEnd()
4438 
    if result.ex is not None:
4439 
      raise result.ex
4440 
    return
4441 
 
4258 rajveer 4442 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4443 
    """
4258 rajveer 4444 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4445 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4446 
 
4447 
    Parameters:
4258 rajveer 4448 
     - transactionId
4247 rajveer 4449 
    """
4258 rajveer 4450 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4451 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4452 
 
4258 rajveer 4453 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4454 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4455 
    args = markTransactionAsPaymentFlagRemoved_args()
4456 
    args.transactionId = transactionId
4247 rajveer 4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4258 rajveer 4461 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4258 rajveer 4468 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.ex is not None:
4472 
      raise result.ex
4473 
    return
4474 
 
4259 anupam.sin 4475 
  def refundTransaction(self, transactionId, refundedBy, reason):
4476 
    """
4477 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4478 
    need to be cancelled
4247 rajveer 4479 
 
4259 anupam.sin 4480 
    Parameters:
4481 
     - transactionId
4482 
     - refundedBy
4483 
     - reason
4484 
    """
4485 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4486 
    self.recv_refundTransaction()
4487 
 
4488 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4489 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4490 
    args = refundTransaction_args()
4491 
    args.transactionId = transactionId
4492 
    args.refundedBy = refundedBy
4493 
    args.reason = reason
4494 
    args.write(self._oprot)
4495 
    self._oprot.writeMessageEnd()
4496 
    self._oprot.trans.flush()
4497 
 
4498 
  def recv_refundTransaction(self, ):
4499 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4500 
    if mtype == TMessageType.EXCEPTION:
4501 
      x = TApplicationException()
4502 
      x.read(self._iprot)
4503 
      self._iprot.readMessageEnd()
4504 
      raise x
4505 
    result = refundTransaction_result()
4506 
    result.read(self._iprot)
4507 
    self._iprot.readMessageEnd()
4508 
    if result.ex is not None:
4509 
      raise result.ex
4510 
    return
4511 
 
4324 mandeep.dh 4512 
  def updateShipmentAddress(self, orderId, addressId):
4513 
    """
4514 
    Updates shipment address of an order. Delivery and shipping date estimates
4515 
    etc. are also updated here.
4516 
 
4517 
    Throws TransactionServiceException in case address change is not
4518 
    possible due to certain reasons such as new pincode in address is
4519 
    not serviceable etc.
4520 
 
4521 
    Parameters:
4522 
     - orderId
4523 
     - addressId
4524 
    """
4525 
    self.send_updateShipmentAddress(orderId, addressId)
4526 
    self.recv_updateShipmentAddress()
4527 
 
4528 
  def send_updateShipmentAddress(self, orderId, addressId):
4529 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4530 
    args = updateShipmentAddress_args()
4531 
    args.orderId = orderId
4532 
    args.addressId = addressId
4533 
    args.write(self._oprot)
4534 
    self._oprot.writeMessageEnd()
4535 
    self._oprot.trans.flush()
4536 
 
4537 
  def recv_updateShipmentAddress(self, ):
4538 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4539 
    if mtype == TMessageType.EXCEPTION:
4540 
      x = TApplicationException()
4541 
      x.read(self._iprot)
4542 
      self._iprot.readMessageEnd()
4543 
      raise x
4544 
    result = updateShipmentAddress_result()
4545 
    result.read(self._iprot)
4546 
    self._iprot.readMessageEnd()
4547 
    if result.ex is not None:
4548 
      raise result.ex
4549 
    return
4550 
 
4285 rajveer 4551 
  def acceptOrdersForItemId(self, itemId, inventory):
4552 
    """
4553 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4554 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4555 
 
4285 rajveer 4556 
    Parameters:
4557 
     - itemId
4558 
     - inventory
4559 
    """
4560 
    self.send_acceptOrdersForItemId(itemId, inventory)
4561 
    return self.recv_acceptOrdersForItemId()
4562 
 
4563 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4564 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4565 
    args = acceptOrdersForItemId_args()
4566 
    args.itemId = itemId
4567 
    args.inventory = inventory
4568 
    args.write(self._oprot)
4569 
    self._oprot.writeMessageEnd()
4570 
    self._oprot.trans.flush()
4571 
 
4572 
  def recv_acceptOrdersForItemId(self, ):
4573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4574 
    if mtype == TMessageType.EXCEPTION:
4575 
      x = TApplicationException()
4576 
      x.read(self._iprot)
4577 
      self._iprot.readMessageEnd()
4578 
      raise x
4579 
    result = acceptOrdersForItemId_result()
4580 
    result.read(self._iprot)
4581 
    self._iprot.readMessageEnd()
4582 
    if result.success is not None:
4583 
      return result.success
4584 
    if result.ex is not None:
4585 
      raise result.ex
4586 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4587 
 
4369 rajveer 4588 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4589 
    """
4590 
    Parameters:
4591 
     - vendorId
4592 
     - itemId
4593 
     - quantity
4594 
     - estimate
4369 rajveer 4595 
     - isReminder
4303 rajveer 4596 
    """
4369 rajveer 4597 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4598 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4599 
 
4369 rajveer 4600 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4601 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4602 
    args = markOrdersAsPORaised_args()
4603 
    args.vendorId = vendorId
4604 
    args.itemId = itemId
4605 
    args.quantity = quantity
4606 
    args.estimate = estimate
4369 rajveer 4607 
    args.isReminder = isReminder
4303 rajveer 4608 
    args.write(self._oprot)
4609 
    self._oprot.writeMessageEnd()
4610 
    self._oprot.trans.flush()
4611 
 
4612 
  def recv_markOrdersAsPORaised(self, ):
4613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4614 
    if mtype == TMessageType.EXCEPTION:
4615 
      x = TApplicationException()
4616 
      x.read(self._iprot)
4617 
      self._iprot.readMessageEnd()
4618 
      raise x
4619 
    result = markOrdersAsPORaised_result()
4620 
    result.read(self._iprot)
4621 
    self._iprot.readMessageEnd()
4622 
    if result.ex is not None:
4623 
      raise result.ex
4624 
    return
4625 
 
4369 rajveer 4626 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4627 
    """
4628 
    Parameters:
4629 
     - vendorId
4630 
     - itemId
4631 
     - quantity
4632 
     - estimate
4369 rajveer 4633 
     - isReminder
4303 rajveer 4634 
    """
4369 rajveer 4635 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4636 
    self.recv_markOrdersAsReversalInitiated()
4637 
 
4369 rajveer 4638 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4639 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4640 
    args = markOrdersAsReversalInitiated_args()
4641 
    args.vendorId = vendorId
4642 
    args.itemId = itemId
4643 
    args.quantity = quantity
4644 
    args.estimate = estimate
4369 rajveer 4645 
    args.isReminder = isReminder
4303 rajveer 4646 
    args.write(self._oprot)
4647 
    self._oprot.writeMessageEnd()
4648 
    self._oprot.trans.flush()
4649 
 
4650 
  def recv_markOrdersAsReversalInitiated(self, ):
4651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4652 
    if mtype == TMessageType.EXCEPTION:
4653 
      x = TApplicationException()
4654 
      x.read(self._iprot)
4655 
      self._iprot.readMessageEnd()
4656 
      raise x
4657 
    result = markOrdersAsReversalInitiated_result()
4658 
    result.read(self._iprot)
4659 
    self._iprot.readMessageEnd()
4660 
    if result.ex is not None:
4661 
      raise result.ex
4662 
    return
4663 
 
4369 rajveer 4664 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4665 
    """
4666 
    Parameters:
4667 
     - vendorId
4668 
     - itemId
4669 
     - quantity
4670 
     - estimate
4369 rajveer 4671 
     - isReminder
4303 rajveer 4672 
    """
4369 rajveer 4673 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4674 
    self.recv_markOrdersAsNotAvailabke()
4675 
 
4369 rajveer 4676 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4677 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4678 
    args = markOrdersAsNotAvailabke_args()
4679 
    args.vendorId = vendorId
4680 
    args.itemId = itemId
4681 
    args.quantity = quantity
4682 
    args.estimate = estimate
4369 rajveer 4683 
    args.isReminder = isReminder
4303 rajveer 4684 
    args.write(self._oprot)
4685 
    self._oprot.writeMessageEnd()
4686 
    self._oprot.trans.flush()
4687 
 
4688 
  def recv_markOrdersAsNotAvailabke(self, ):
4689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4690 
    if mtype == TMessageType.EXCEPTION:
4691 
      x = TApplicationException()
4692 
      x.read(self._iprot)
4693 
      self._iprot.readMessageEnd()
4694 
      raise x
4695 
    result = markOrdersAsNotAvailabke_result()
4696 
    result.read(self._iprot)
4697 
    self._iprot.readMessageEnd()
4698 
    if result.ex is not None:
4699 
      raise result.ex
4700 
    return
4701 
 
4369 rajveer 4702 
  def markOrdersAsTimeout(self, vendorId):
4703 
    """
4704 
    Parameters:
4705 
     - vendorId
4706 
    """
4707 
    self.send_markOrdersAsTimeout(vendorId)
4708 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4709 
 
4369 rajveer 4710 
  def send_markOrdersAsTimeout(self, vendorId):
4711 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4712 
    args = markOrdersAsTimeout_args()
4713 
    args.vendorId = vendorId
4714 
    args.write(self._oprot)
4715 
    self._oprot.writeMessageEnd()
4716 
    self._oprot.trans.flush()
4717 
 
4718 
  def recv_markOrdersAsTimeout(self, ):
4719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4720 
    if mtype == TMessageType.EXCEPTION:
4721 
      x = TApplicationException()
4722 
      x.read(self._iprot)
4723 
      self._iprot.readMessageEnd()
4724 
      raise x
4725 
    result = markOrdersAsTimeout_result()
4726 
    result.read(self._iprot)
4727 
    self._iprot.readMessageEnd()
4728 
    if result.success is not None:
4729 
      return result.success
4730 
    if result.ex is not None:
4731 
      raise result.ex
4732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4733 
 
4662 rajveer 4734 
  def markOrderAsLostInTransit(self, orderId):
4735 
    """
4736 
    Mark order as LOST_IN_TRANSIT
4737 
 
4738 
    Parameters:
4739 
     - orderId
4740 
    """
4741 
    self.send_markOrderAsLostInTransit(orderId)
4742 
    return self.recv_markOrderAsLostInTransit()
4743 
 
4744 
  def send_markOrderAsLostInTransit(self, orderId):
4745 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4746 
    args = markOrderAsLostInTransit_args()
4747 
    args.orderId = orderId
4748 
    args.write(self._oprot)
4749 
    self._oprot.writeMessageEnd()
4750 
    self._oprot.trans.flush()
4751 
 
4752 
  def recv_markOrderAsLostInTransit(self, ):
4753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4754 
    if mtype == TMessageType.EXCEPTION:
4755 
      x = TApplicationException()
4756 
      x.read(self._iprot)
4757 
      self._iprot.readMessageEnd()
4758 
      raise x
4759 
    result = markOrderAsLostInTransit_result()
4760 
    result.read(self._iprot)
4761 
    self._iprot.readMessageEnd()
4762 
    if result.success is not None:
4763 
      return result.success
4764 
    if result.ex is not None:
4765 
      raise result.ex
4766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4767 
 
4386 anupam.sin 4768 
  def getOrderForAwb(self, awb):
4769 
    """
4770 
    Returns the order corresponding to an AWB number
4369 rajveer 4771 
 
4386 anupam.sin 4772 
    Parameters:
4773 
     - awb
4774 
    """
4775 
    self.send_getOrderForAwb(awb)
4776 
    return self.recv_getOrderForAwb()
4777 
 
4778 
  def send_getOrderForAwb(self, awb):
4779 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4780 
    args = getOrderForAwb_args()
4781 
    args.awb = awb
4782 
    args.write(self._oprot)
4783 
    self._oprot.writeMessageEnd()
4784 
    self._oprot.trans.flush()
4785 
 
4786 
  def recv_getOrderForAwb(self, ):
4787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4788 
    if mtype == TMessageType.EXCEPTION:
4789 
      x = TApplicationException()
4790 
      x.read(self._iprot)
4791 
      self._iprot.readMessageEnd()
4792 
      raise x
4793 
    result = getOrderForAwb_result()
4794 
    result.read(self._iprot)
4795 
    self._iprot.readMessageEnd()
4796 
    if result.success is not None:
4797 
      return result.success
4798 
    if result.ex is not None:
4799 
      raise result.ex
4800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4801 
 
4910 phani.kuma 4802 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4803 
    """
4910 phani.kuma 4804 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4805 
 
4506 phani.kuma 4806 
    Parameters:
4807 
     - logistics_provider_id
4910 phani.kuma 4808 
     - order_status_list
4506 phani.kuma 4809 
    """
4910 phani.kuma 4810 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4811 
    return self.recv_getOrdersForProviderForStatus()
4812 
 
4910 phani.kuma 4813 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4814 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4815 
    args = getOrdersForProviderForStatus_args()
4816 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4817 
    args.order_status_list = order_status_list
4506 phani.kuma 4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_getOrdersForProviderForStatus(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = getOrdersForProviderForStatus_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.success is not None:
4833 
      return result.success
4834 
    if result.ex is not None:
4835 
      raise result.ex
4836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4837 
 
4600 varun.gupt 4838 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4839 
    """
4840 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4841 
 
4600 varun.gupt 4842 
    Parameters:
4843 
     - vendorId
4844 
     - billingDateFrom
4845 
     - billingDateTo
4846 
    """
4847 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4848 
    return self.recv_getBilledOrdersForVendor()
4849 
 
4850 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4851 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4852 
    args = getBilledOrdersForVendor_args()
4853 
    args.vendorId = vendorId
4854 
    args.billingDateFrom = billingDateFrom
4855 
    args.billingDateTo = billingDateTo
4856 
    args.write(self._oprot)
4857 
    self._oprot.writeMessageEnd()
4858 
    self._oprot.trans.flush()
4859 
 
4860 
  def recv_getBilledOrdersForVendor(self, ):
4861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4862 
    if mtype == TMessageType.EXCEPTION:
4863 
      x = TApplicationException()
4864 
      x.read(self._iprot)
4865 
      self._iprot.readMessageEnd()
4866 
      raise x
4867 
    result = getBilledOrdersForVendor_result()
4868 
    result.read(self._iprot)
4869 
    self._iprot.readMessageEnd()
4870 
    if result.success is not None:
4871 
      return result.success
4872 
    if result.ex is not None:
4873 
      raise result.ex
4874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4875 
 
4607 rajveer 4876 
  def getSlippedSippingDateOrders(self, ):
4877 
    self.send_getSlippedSippingDateOrders()
4878 
    return self.recv_getSlippedSippingDateOrders()
4879 
 
4880 
  def send_getSlippedSippingDateOrders(self, ):
4881 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4882 
    args = getSlippedSippingDateOrders_args()
4883 
    args.write(self._oprot)
4884 
    self._oprot.writeMessageEnd()
4885 
    self._oprot.trans.flush()
4886 
 
4887 
  def recv_getSlippedSippingDateOrders(self, ):
4888 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4889 
    if mtype == TMessageType.EXCEPTION:
4890 
      x = TApplicationException()
4891 
      x.read(self._iprot)
4892 
      self._iprot.readMessageEnd()
4893 
      raise x
4894 
    result = getSlippedSippingDateOrders_result()
4895 
    result.read(self._iprot)
4896 
    self._iprot.readMessageEnd()
4897 
    if result.success is not None:
4898 
      return result.success
4899 
    if result.ex is not None:
4900 
      raise result.ex
4901 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4902 
 
4709 rajveer 4903 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4904 
    """
4905 
    Parameters:
4906 
     - cancelDateFrom
4907 
     - cancelDateTo
4908 
    """
4909 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4910 
    return self.recv_getCancelledOrders()
4911 
 
4912 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4913 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4914 
    args = getCancelledOrders_args()
4915 
    args.cancelDateFrom = cancelDateFrom
4916 
    args.cancelDateTo = cancelDateTo
4917 
    args.write(self._oprot)
4918 
    self._oprot.writeMessageEnd()
4919 
    self._oprot.trans.flush()
4920 
 
4921 
  def recv_getCancelledOrders(self, ):
4922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4923 
    if mtype == TMessageType.EXCEPTION:
4924 
      x = TApplicationException()
4925 
      x.read(self._iprot)
4926 
      self._iprot.readMessageEnd()
4927 
      raise x
4928 
    result = getCancelledOrders_result()
4929 
    result.read(self._iprot)
4930 
    self._iprot.readMessageEnd()
4931 
    if result.success is not None:
4932 
      return result.success
4933 
    if result.ex is not None:
4934 
      raise result.ex
4935 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4936 
 
4600 varun.gupt 4937 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4938 
    """
4939 
    Parameters:
4940 
     - mapAWBAndAmount
4941 
    """
4942 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4943 
    self.recv_saveBluedartSettlements()
4944 
 
4945 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4946 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4947 
    args = saveBluedartSettlements_args()
4948 
    args.mapAWBAndAmount = mapAWBAndAmount
4949 
    args.write(self._oprot)
4950 
    self._oprot.writeMessageEnd()
4951 
    self._oprot.trans.flush()
4952 
 
4953 
  def recv_saveBluedartSettlements(self, ):
4954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4955 
    if mtype == TMessageType.EXCEPTION:
4956 
      x = TApplicationException()
4957 
      x.read(self._iprot)
4958 
      self._iprot.readMessageEnd()
4959 
      raise x
4960 
    result = saveBluedartSettlements_result()
4961 
    result.read(self._iprot)
4962 
    self._iprot.readMessageEnd()
4963 
    if result.ex is not None:
4964 
      raise result.ex
4965 
    return
4966 
 
4905 varun.gupt 4967 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4968 
    """
4969 
    Parameters:
4970 
     - settlementDate
4971 
     - paymentGatewayId
4905 varun.gupt 4972 
     - referenceId
4600 varun.gupt 4973 
     - serviceTax
4974 
     - otherCharges
4975 
     - netCollection
4976 
    """
4905 varun.gupt 4977 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4978 
    self.recv_savePaymentSettlements()
4979 
 
4905 varun.gupt 4980 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4981 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4982 
    args = savePaymentSettlements_args()
4983 
    args.settlementDate = settlementDate
4984 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4985 
    args.referenceId = referenceId
4600 varun.gupt 4986 
    args.serviceTax = serviceTax
4987 
    args.otherCharges = otherCharges
4988 
    args.netCollection = netCollection
4989 
    args.write(self._oprot)
4990 
    self._oprot.writeMessageEnd()
4991 
    self._oprot.trans.flush()
4992 
 
4993 
  def recv_savePaymentSettlements(self, ):
4994 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4995 
    if mtype == TMessageType.EXCEPTION:
4996 
      x = TApplicationException()
4997 
      x.read(self._iprot)
4998 
      self._iprot.readMessageEnd()
4999 
      raise x
5000 
    result = savePaymentSettlements_result()
5001 
    result.read(self._iprot)
5002 
    self._iprot.readMessageEnd()
5003 
    if result.ex is not None:
5004 
      raise result.ex
5005 
    return
5006 
 
5007 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5008 
    """
5009 
    Parameters:
5010 
     - settlementId
5011 
     - settlementDate
5012 
     - transactionDateFrom
5013 
     - transactionDateTo
5014 
     - amount
5015 
    """
5016 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5017 
    self.recv_saveEBSSettlementSummary()
5018 
 
5019 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5020 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5021 
    args = saveEBSSettlementSummary_args()
5022 
    args.settlementId = settlementId
5023 
    args.settlementDate = settlementDate
5024 
    args.transactionDateFrom = transactionDateFrom
5025 
    args.transactionDateTo = transactionDateTo
5026 
    args.amount = amount
5027 
    args.write(self._oprot)
5028 
    self._oprot.writeMessageEnd()
5029 
    self._oprot.trans.flush()
5030 
 
5031 
  def recv_saveEBSSettlementSummary(self, ):
5032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5033 
    if mtype == TMessageType.EXCEPTION:
5034 
      x = TApplicationException()
5035 
      x.read(self._iprot)
5036 
      self._iprot.readMessageEnd()
5037 
      raise x
5038 
    result = saveEBSSettlementSummary_result()
5039 
    result.read(self._iprot)
5040 
    self._iprot.readMessageEnd()
5041 
    if result.ex is not None:
5042 
      raise result.ex
5043 
    return
5044 
 
5386 phani.kuma 5045 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5046 
    """
5047 
    Parameters:
5189 varun.gupt 5048 
     - referenceId
5049 
     - isRefund
4600 varun.gupt 5050 
    """
5386 phani.kuma 5051 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5052 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5053 
 
5386 phani.kuma 5054 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5055 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5056 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5057 
    args.referenceId = referenceId
5058 
    args.isRefund = isRefund
4600 varun.gupt 5059 
    args.write(self._oprot)
5060 
    self._oprot.writeMessageEnd()
5061 
    self._oprot.trans.flush()
5062 
 
5386 phani.kuma 5063 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5065 
    if mtype == TMessageType.EXCEPTION:
5066 
      x = TApplicationException()
5067 
      x.read(self._iprot)
5068 
      self._iprot.readMessageEnd()
5069 
      raise x
5386 phani.kuma 5070 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5071 
    result.read(self._iprot)
5072 
    self._iprot.readMessageEnd()
5073 
    if result.success is not None:
5074 
      return result.success
5075 
    if result.ex is not None:
5076 
      raise result.ex
5386 phani.kuma 5077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5078 
 
5386 phani.kuma 5079 
  def getSettlementForCod(self, orderId, isRefund):
5080 
    """
5081 
    Parameters:
5082 
     - orderId
5083 
     - isRefund
5084 
    """
5085 
    self.send_getSettlementForCod(orderId, isRefund)
5086 
    return self.recv_getSettlementForCod()
5087 
 
5088 
  def send_getSettlementForCod(self, orderId, isRefund):
5089 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5090 
    args = getSettlementForCod_args()
5091 
    args.orderId = orderId
5092 
    args.isRefund = isRefund
5093 
    args.write(self._oprot)
5094 
    self._oprot.writeMessageEnd()
5095 
    self._oprot.trans.flush()
5096 
 
5097 
  def recv_getSettlementForCod(self, ):
5098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5099 
    if mtype == TMessageType.EXCEPTION:
5100 
      x = TApplicationException()
5101 
      x.read(self._iprot)
5102 
      self._iprot.readMessageEnd()
5103 
      raise x
5104 
    result = getSettlementForCod_result()
5105 
    result.read(self._iprot)
5106 
    self._iprot.readMessageEnd()
5107 
    if result.success is not None:
5108 
      return result.success
5109 
    if result.ex is not None:
5110 
      raise result.ex
5111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5112 
 
4600 varun.gupt 5113 
  def getEBSSettlementSummaries(self, ):
5114 
    self.send_getEBSSettlementSummaries()
5115 
    return self.recv_getEBSSettlementSummaries()
5116 
 
5117 
  def send_getEBSSettlementSummaries(self, ):
5118 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5119 
    args = getEBSSettlementSummaries_args()
5120 
    args.write(self._oprot)
5121 
    self._oprot.writeMessageEnd()
5122 
    self._oprot.trans.flush()
5123 
 
5124 
  def recv_getEBSSettlementSummaries(self, ):
5125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5126 
    if mtype == TMessageType.EXCEPTION:
5127 
      x = TApplicationException()
5128 
      x.read(self._iprot)
5129 
      self._iprot.readMessageEnd()
5130 
      raise x
5131 
    result = getEBSSettlementSummaries_result()
5132 
    result.read(self._iprot)
5133 
    self._iprot.readMessageEnd()
5134 
    if result.success is not None:
5135 
      return result.success
5136 
    if result.ex is not None:
5137 
      raise result.ex
5138 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5139 
 
5140 
  def markEBSSettlementUploaded(self, settlementId):
5141 
    """
5142 
    Parameters:
5143 
     - settlementId
5144 
    """
5145 
    self.send_markEBSSettlementUploaded(settlementId)
5146 
    self.recv_markEBSSettlementUploaded()
5147 
 
5148 
  def send_markEBSSettlementUploaded(self, settlementId):
5149 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5150 
    args = markEBSSettlementUploaded_args()
5151 
    args.settlementId = settlementId
5152 
    args.write(self._oprot)
5153 
    self._oprot.writeMessageEnd()
5154 
    self._oprot.trans.flush()
5155 
 
5156 
  def recv_markEBSSettlementUploaded(self, ):
5157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5158 
    if mtype == TMessageType.EXCEPTION:
5159 
      x = TApplicationException()
5160 
      x.read(self._iprot)
5161 
      self._iprot.readMessageEnd()
5162 
      raise x
5163 
    result = markEBSSettlementUploaded_result()
5164 
    result.read(self._iprot)
5165 
    self._iprot.readMessageEnd()
5166 
    if result.ex is not None:
5167 
      raise result.ex
5168 
    return
5169 
 
5170 
  def getEBSSettlementDate(self, settlementId):
5171 
    """
5172 
    Parameters:
5173 
     - settlementId
5174 
    """
5175 
    self.send_getEBSSettlementDate(settlementId)
5176 
    return self.recv_getEBSSettlementDate()
5177 
 
5178 
  def send_getEBSSettlementDate(self, settlementId):
5179 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5180 
    args = getEBSSettlementDate_args()
5181 
    args.settlementId = settlementId
5182 
    args.write(self._oprot)
5183 
    self._oprot.writeMessageEnd()
5184 
    self._oprot.trans.flush()
5185 
 
5186 
  def recv_getEBSSettlementDate(self, ):
5187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5188 
    if mtype == TMessageType.EXCEPTION:
5189 
      x = TApplicationException()
5190 
      x.read(self._iprot)
5191 
      self._iprot.readMessageEnd()
5192 
      raise x
5193 
    result = getEBSSettlementDate_result()
5194 
    result.read(self._iprot)
5195 
    self._iprot.readMessageEnd()
5196 
    if result.success is not None:
5197 
      return result.success
5198 
    if result.ex is not None:
5199 
      raise result.ex
5200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5201 
 
4715 varun.gupt 5202 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5203 
    """
5204 
    Parameters:
5205 
     - settlementDateFrom
5206 
     - settlementDateTo
5207 
     - isRefund
5208 
    """
5209 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5210 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5211 
 
4715 varun.gupt 5212 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5213 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5214 
    args = getSettlementsByDate_args()
5215 
    args.settlementDateFrom = settlementDateFrom
5216 
    args.settlementDateTo = settlementDateTo
5217 
    args.isRefund = isRefund
5218 
    args.write(self._oprot)
5219 
    self._oprot.writeMessageEnd()
5220 
    self._oprot.trans.flush()
5221 
 
5222 
  def recv_getSettlementsByDate(self, ):
5223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5224 
    if mtype == TMessageType.EXCEPTION:
5225 
      x = TApplicationException()
5226 
      x.read(self._iprot)
5227 
      self._iprot.readMessageEnd()
5228 
      raise x
5229 
    result = getSettlementsByDate_result()
5230 
    result.read(self._iprot)
5231 
    self._iprot.readMessageEnd()
5232 
    if result.success is not None:
5233 
      return result.success
5234 
    if result.ex is not None:
5235 
      raise result.ex
5236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5237 
 
5238 
  def getReshippedOrderIds(self, orderIds):
5239 
    """
5240 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5241 
 
5242 
    Parameters:
5243 
     - orderIds
5244 
    """
5245 
    self.send_getReshippedOrderIds(orderIds)
5246 
    return self.recv_getReshippedOrderIds()
5247 
 
5248 
  def send_getReshippedOrderIds(self, orderIds):
5249 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5250 
    args = getReshippedOrderIds_args()
5251 
    args.orderIds = orderIds
5252 
    args.write(self._oprot)
5253 
    self._oprot.writeMessageEnd()
5254 
    self._oprot.trans.flush()
5255 
 
5256 
  def recv_getReshippedOrderIds(self, ):
5257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5258 
    if mtype == TMessageType.EXCEPTION:
5259 
      x = TApplicationException()
5260 
      x.read(self._iprot)
5261 
      self._iprot.readMessageEnd()
5262 
      raise x
5263 
    result = getReshippedOrderIds_result()
5264 
    result.read(self._iprot)
5265 
    self._iprot.readMessageEnd()
5266 
    if result.success is not None:
5267 
      return result.success
5268 
    if result.ex is not None:
5269 
      raise result.ex
5270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5271 
 
5481 phani.kuma 5272 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5273 
    """
5274 
    Parameters:
5275 
     - vendorId
5481 phani.kuma 5276 
     - onlyVendorNotPaid
5277 
     - billingDateFrom
5278 
     - billingDateTo
4875 varun.gupt 5279 
    """
5481 phani.kuma 5280 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5281 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5282 
 
5481 phani.kuma 5283 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5284 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5285 
    args = getBilledOrders_args()
4875 varun.gupt 5286 
    args.vendorId = vendorId
5481 phani.kuma 5287 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5288 
    args.billingDateFrom = billingDateFrom
5289 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5290 
    args.write(self._oprot)
5291 
    self._oprot.writeMessageEnd()
5292 
    self._oprot.trans.flush()
5293 
 
5481 phani.kuma 5294 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5296 
    if mtype == TMessageType.EXCEPTION:
5297 
      x = TApplicationException()
5298 
      x.read(self._iprot)
5299 
      self._iprot.readMessageEnd()
5300 
      raise x
5481 phani.kuma 5301 
    result = getBilledOrders_result()
4875 varun.gupt 5302 
    result.read(self._iprot)
5303 
    self._iprot.readMessageEnd()
5304 
    if result.success is not None:
5305 
      return result.success
5306 
    if result.ex is not None:
5307 
      raise result.ex
5481 phani.kuma 5308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5309 
 
5031 varun.gupt 5310 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5311 
    """
5312 
    Parameters:
5313 
     - startDate
5314 
     - endDate
5315 
    """
5316 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5317 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5318 
 
5031 varun.gupt 5319 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5320 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5321 
    args = getStatusDistributionOfOrders_args()
5322 
    args.startDate = startDate
5323 
    args.endDate = endDate
5324 
    args.write(self._oprot)
5325 
    self._oprot.writeMessageEnd()
5326 
    self._oprot.trans.flush()
5327 
 
5328 
  def recv_getStatusDistributionOfOrders(self, ):
5329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5330 
    if mtype == TMessageType.EXCEPTION:
5331 
      x = TApplicationException()
5332 
      x.read(self._iprot)
5333 
      self._iprot.readMessageEnd()
5334 
      raise x
5335 
    result = getStatusDistributionOfOrders_result()
5336 
    result.read(self._iprot)
5337 
    self._iprot.readMessageEnd()
5338 
    if result.success is not None:
5339 
      return result.success
5340 
    if result.ex is not None:
5341 
      raise result.ex
5342 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5343 
 
5067 varun.gupt 5344 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5345 
    """
5346 
    Parameters:
5347 
     - status
5348 
     - startDatetime
5349 
     - endDatetime
5350 
    """
5351 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5352 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5353 
 
5067 varun.gupt 5354 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5355 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5356 
    args = getOrderIdsForStatus_args()
5357 
    args.status = status
5358 
    args.startDatetime = startDatetime
5359 
    args.endDatetime = endDatetime
5360 
    args.write(self._oprot)
5361 
    self._oprot.writeMessageEnd()
5362 
    self._oprot.trans.flush()
5363 
 
5364 
  def recv_getOrderIdsForStatus(self, ):
5365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5366 
    if mtype == TMessageType.EXCEPTION:
5367 
      x = TApplicationException()
5368 
      x.read(self._iprot)
5369 
      self._iprot.readMessageEnd()
5370 
      raise x
5371 
    result = getOrderIdsForStatus_result()
5372 
    result.read(self._iprot)
5373 
    self._iprot.readMessageEnd()
5374 
    if result.success is not None:
5375 
      return result.success
5376 
    if result.ex is not None:
5377 
      raise result.ex
5378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5379 
 
5348 anupam.sin 5380 
  def updateCODAgent(self, agent, orderId):
5381 
    """
5382 
    Updates the agent who handled the COD verification call
5383 
 
5384 
    Parameters:
5385 
     - agent
5386 
     - orderId
5387 
    """
5388 
    self.send_updateCODAgent(agent, orderId)
5389 
    self.recv_updateCODAgent()
5390 
 
5391 
  def send_updateCODAgent(self, agent, orderId):
5392 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5393 
    args = updateCODAgent_args()
5394 
    args.agent = agent
5395 
    args.orderId = orderId
5396 
    args.write(self._oprot)
5397 
    self._oprot.writeMessageEnd()
5398 
    self._oprot.trans.flush()
5399 
 
5400 
  def recv_updateCODAgent(self, ):
5401 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5402 
    if mtype == TMessageType.EXCEPTION:
5403 
      x = TApplicationException()
5404 
      x.read(self._iprot)
5405 
      self._iprot.readMessageEnd()
5406 
      raise x
5407 
    result = updateCODAgent_result()
5408 
    result.read(self._iprot)
5409 
    self._iprot.readMessageEnd()
5410 
    if result.ex is not None:
5411 
      raise result.ex
5412 
    return
5413 
 
5099 varun.gupt 5414 
  def updateOrderAsPaidToVendor(self, orderId):
5415 
    """
5416 
    Parameters:
5417 
     - orderId
5418 
    """
5419 
    self.send_updateOrderAsPaidToVendor(orderId)
5420 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5421 
 
5099 varun.gupt 5422 
  def send_updateOrderAsPaidToVendor(self, orderId):
5423 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5424 
    args = updateOrderAsPaidToVendor_args()
5425 
    args.orderId = orderId
5426 
    args.write(self._oprot)
5427 
    self._oprot.writeMessageEnd()
5428 
    self._oprot.trans.flush()
5429 
 
5430 
  def recv_updateOrderAsPaidToVendor(self, ):
5431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5432 
    if mtype == TMessageType.EXCEPTION:
5433 
      x = TApplicationException()
5434 
      x.read(self._iprot)
5435 
      self._iprot.readMessageEnd()
5436 
      raise x
5437 
    result = updateOrderAsPaidToVendor_result()
5438 
    result.read(self._iprot)
5439 
    self._iprot.readMessageEnd()
5440 
    if result.ex is not None:
5441 
      raise result.ex
5442 
    return
5443 
 
5386 phani.kuma 5444 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5445 
    """
5446 
    Parameters:
5447 
     - orderId
5448 
    """
5449 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5450 
    self.recv_updateOrderOnlyAsPaidToVendor()
5451 
 
5452 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5453 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5454 
    args = updateOrderOnlyAsPaidToVendor_args()
5455 
    args.orderId = orderId
5456 
    args.write(self._oprot)
5457 
    self._oprot.writeMessageEnd()
5458 
    self._oprot.trans.flush()
5459 
 
5460 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5462 
    if mtype == TMessageType.EXCEPTION:
5463 
      x = TApplicationException()
5464 
      x.read(self._iprot)
5465 
      self._iprot.readMessageEnd()
5466 
      raise x
5467 
    result = updateOrderOnlyAsPaidToVendor_result()
5468 
    result.read(self._iprot)
5469 
    self._iprot.readMessageEnd()
5470 
    if result.ex is not None:
5471 
      raise result.ex
5472 
    return
5473 
 
5208 varun.gupt 5474 
  def getRefundedOrdersMarkedPaid(self, ):
5475 
    self.send_getRefundedOrdersMarkedPaid()
5476 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5477 
 
5208 varun.gupt 5478 
  def send_getRefundedOrdersMarkedPaid(self, ):
5479 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5480 
    args = getRefundedOrdersMarkedPaid_args()
5481 
    args.write(self._oprot)
5482 
    self._oprot.writeMessageEnd()
5483 
    self._oprot.trans.flush()
5484 
 
5485 
  def recv_getRefundedOrdersMarkedPaid(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 = getRefundedOrdersMarkedPaid_result()
5493 
    result.read(self._iprot)
5494 
    self._iprot.readMessageEnd()
5495 
    if result.success is not None:
5496 
      return result.success
5497 
    if result.ex is not None:
5498 
      raise result.ex
5499 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5500 
 
5447 anupam.sin 5501 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5502 
    """
5503 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5504 
 
5447 anupam.sin 5505 
 
5506 
    Parameters:
5507 
     - minOrderId
5508 
     - maxOrderId
5509 
    """
5510 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5511 
    return self.recv_getAllVerificationAgents()
5512 
 
5513 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5514 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5515 
    args = getAllVerificationAgents_args()
5516 
    args.minOrderId = minOrderId
5517 
    args.maxOrderId = maxOrderId
5518 
    args.write(self._oprot)
5519 
    self._oprot.writeMessageEnd()
5520 
    self._oprot.trans.flush()
5521 
 
5522 
  def recv_getAllVerificationAgents(self, ):
5523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5524 
    if mtype == TMessageType.EXCEPTION:
5525 
      x = TApplicationException()
5526 
      x.read(self._iprot)
5527 
      self._iprot.readMessageEnd()
5528 
      raise x
5529 
    result = getAllVerificationAgents_result()
5530 
    result.read(self._iprot)
5531 
    self._iprot.readMessageEnd()
5532 
    if result.success is not None:
5533 
      return result.success
5534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5535 
 
5527 anupam.sin 5536 
  def getAllAttributesForOrderId(self, orderId):
5537 
    """
5538 
    gets all attributes for a given orderId
5447 anupam.sin 5539 
 
5527 anupam.sin 5540 
    Parameters:
5541 
     - orderId
5542 
    """
5543 
    self.send_getAllAttributesForOrderId(orderId)
5544 
    return self.recv_getAllAttributesForOrderId()
5545 
 
5546 
  def send_getAllAttributesForOrderId(self, orderId):
5547 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5548 
    args = getAllAttributesForOrderId_args()
5549 
    args.orderId = orderId
5550 
    args.write(self._oprot)
5551 
    self._oprot.writeMessageEnd()
5552 
    self._oprot.trans.flush()
5553 
 
5554 
  def recv_getAllAttributesForOrderId(self, ):
5555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5556 
    if mtype == TMessageType.EXCEPTION:
5557 
      x = TApplicationException()
5558 
      x.read(self._iprot)
5559 
      self._iprot.readMessageEnd()
5560 
      raise x
5561 
    result = getAllAttributesForOrderId_result()
5562 
    result.read(self._iprot)
5563 
    self._iprot.readMessageEnd()
5564 
    if result.success is not None:
5565 
      return result.success
5566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5567 
 
5676 rajveer 5568 
  def setOrderAttributes(self, orderId, attributes):
5569 
    """
5570 
    sets attributes for an order
5571 
 
5572 
    Parameters:
5573 
     - orderId
5574 
     - attributes
5575 
    """
5576 
    self.send_setOrderAttributes(orderId, attributes)
5577 
    self.recv_setOrderAttributes()
5578 
 
5579 
  def send_setOrderAttributes(self, orderId, attributes):
5580 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5581 
    args = setOrderAttributes_args()
5582 
    args.orderId = orderId
5583 
    args.attributes = attributes
5584 
    args.write(self._oprot)
5585 
    self._oprot.writeMessageEnd()
5586 
    self._oprot.trans.flush()
5587 
 
5588 
  def recv_setOrderAttributes(self, ):
5589 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5590 
    if mtype == TMessageType.EXCEPTION:
5591 
      x = TApplicationException()
5592 
      x.read(self._iprot)
5593 
      self._iprot.readMessageEnd()
5594 
      raise x
5595 
    result = setOrderAttributes_result()
5596 
    result.read(self._iprot)
5597 
    self._iprot.readMessageEnd()
5598 
    return
5599 
 
5527 anupam.sin 5600 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5601 
    """
5602 
    sets attributes for all orders in a transaction
5603 
 
5604 
    Parameters:
5605 
     - transactionId
5606 
     - attribute
5607 
    """
5608 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5609 
    self.recv_setOrderAttributeForTransaction()
5610 
 
5611 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5612 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5613 
    args = setOrderAttributeForTransaction_args()
5614 
    args.transactionId = transactionId
5615 
    args.attribute = attribute
5616 
    args.write(self._oprot)
5617 
    self._oprot.writeMessageEnd()
5618 
    self._oprot.trans.flush()
5619 
 
5620 
  def recv_setOrderAttributeForTransaction(self, ):
5621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5622 
    if mtype == TMessageType.EXCEPTION:
5623 
      x = TApplicationException()
5624 
      x.read(self._iprot)
5625 
      self._iprot.readMessageEnd()
5626 
      raise x
5627 
    result = setOrderAttributeForTransaction_result()
5628 
    result.read(self._iprot)
5629 
    self._iprot.readMessageEnd()
5630 
    return
5631 
 
5553 rajveer 5632 
  def getReceivePendingOrders(self, storeId):
5633 
    """
5634 
    Parameters:
5635 
     - storeId
5636 
    """
5637 
    self.send_getReceivePendingOrders(storeId)
5638 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5639 
 
5553 rajveer 5640 
  def send_getReceivePendingOrders(self, storeId):
5641 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5642 
    args = getReceivePendingOrders_args()
5643 
    args.storeId = storeId
5644 
    args.write(self._oprot)
5645 
    self._oprot.writeMessageEnd()
5646 
    self._oprot.trans.flush()
5647 
 
5648 
  def recv_getReceivePendingOrders(self, ):
5649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5650 
    if mtype == TMessageType.EXCEPTION:
5651 
      x = TApplicationException()
5652 
      x.read(self._iprot)
5653 
      self._iprot.readMessageEnd()
5654 
      raise x
5655 
    result = getReceivePendingOrders_result()
5656 
    result.read(self._iprot)
5657 
    self._iprot.readMessageEnd()
5658 
    if result.success is not None:
5659 
      return result.success
5660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5661 
 
5662 
  def getReceivedAtStoreOrders(self, storeId):
5663 
    """
5664 
    Parameters:
5665 
     - storeId
5666 
    """
5667 
    self.send_getReceivedAtStoreOrders(storeId)
5668 
    return self.recv_getReceivedAtStoreOrders()
5669 
 
5670 
  def send_getReceivedAtStoreOrders(self, storeId):
5671 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5672 
    args = getReceivedAtStoreOrders_args()
5673 
    args.storeId = storeId
5674 
    args.write(self._oprot)
5675 
    self._oprot.writeMessageEnd()
5676 
    self._oprot.trans.flush()
5677 
 
5678 
  def recv_getReceivedAtStoreOrders(self, ):
5679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5680 
    if mtype == TMessageType.EXCEPTION:
5681 
      x = TApplicationException()
5682 
      x.read(self._iprot)
5683 
      self._iprot.readMessageEnd()
5684 
      raise x
5685 
    result = getReceivedAtStoreOrders_result()
5686 
    result.read(self._iprot)
5687 
    self._iprot.readMessageEnd()
5688 
    if result.success is not None:
5689 
      return result.success
5690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5691 
 
5713 rajveer 5692 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5693 
    """
5694 
    Parameters:
5695 
     - storeId
5696 
     - fromDate
5697 
     - toDate
5698 
     - onlyCod
5699 
    """
5700 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5701 
    return self.recv_getOrdersCollectionAtStore()
5702 
 
5703 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5704 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5705 
    args = getOrdersCollectionAtStore_args()
5706 
    args.storeId = storeId
5707 
    args.fromDate = fromDate
5708 
    args.toDate = toDate
5709 
    args.onlyCod = onlyCod
5710 
    args.write(self._oprot)
5711 
    self._oprot.writeMessageEnd()
5712 
    self._oprot.trans.flush()
5713 
 
5714 
  def recv_getOrdersCollectionAtStore(self, ):
5715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5716 
    if mtype == TMessageType.EXCEPTION:
5717 
      x = TApplicationException()
5718 
      x.read(self._iprot)
5719 
      self._iprot.readMessageEnd()
5720 
      raise x
5721 
    result = getOrdersCollectionAtStore_result()
5722 
    result.read(self._iprot)
5723 
    self._iprot.readMessageEnd()
5724 
    if result.success is not None:
5725 
      return result.success
5726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5727 
 
5833 rajveer 5728 
  def getOrderAttributeValue(self, orderId, attributeName):
5729 
    """
5730 
    Parameters:
5731 
     - orderId
5732 
     - attributeName
5733 
    """
5734 
    self.send_getOrderAttributeValue(orderId, attributeName)
5735 
    return self.recv_getOrderAttributeValue()
5736 
 
5737 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5738 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5739 
    args = getOrderAttributeValue_args()
5740 
    args.orderId = orderId
5741 
    args.attributeName = attributeName
5742 
    args.write(self._oprot)
5743 
    self._oprot.writeMessageEnd()
5744 
    self._oprot.trans.flush()
5745 
 
5746 
  def recv_getOrderAttributeValue(self, ):
5747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5748 
    if mtype == TMessageType.EXCEPTION:
5749 
      x = TApplicationException()
5750 
      x.read(self._iprot)
5751 
      self._iprot.readMessageEnd()
5752 
      raise x
5753 
    result = getOrderAttributeValue_result()
5754 
    result.read(self._iprot)
5755 
    self._iprot.readMessageEnd()
5756 
    if result.success is not None:
5757 
      return result.success
5758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5759 
 
6019 rajveer 5760 
  def changeJacketNumber(self, orderId, jacketNumber):
5761 
    """
5762 
    Parameters:
5763 
     - orderId
5764 
     - jacketNumber
5765 
    """
5766 
    self.send_changeJacketNumber(orderId, jacketNumber)
5767 
    return self.recv_changeJacketNumber()
5768 
 
5769 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5770 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5771 
    args = changeJacketNumber_args()
5772 
    args.orderId = orderId
5773 
    args.jacketNumber = jacketNumber
5774 
    args.write(self._oprot)
5775 
    self._oprot.writeMessageEnd()
5776 
    self._oprot.trans.flush()
5777 
 
5778 
  def recv_changeJacketNumber(self, ):
5779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5780 
    if mtype == TMessageType.EXCEPTION:
5781 
      x = TApplicationException()
5782 
      x.read(self._iprot)
5783 
      self._iprot.readMessageEnd()
5784 
      raise x
5785 
    result = changeJacketNumber_result()
5786 
    result.read(self._iprot)
5787 
    self._iprot.readMessageEnd()
5788 
    if result.success is not None:
5789 
      return result.success
5790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5791 
 
5792 
  def markOrderAsRtoInTransit(self, orderId):
5793 
    """
5794 
    Parameters:
5795 
     - orderId
5796 
    """
5797 
    self.send_markOrderAsRtoInTransit(orderId)
5798 
    return self.recv_markOrderAsRtoInTransit()
5799 
 
5800 
  def send_markOrderAsRtoInTransit(self, orderId):
5801 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5802 
    args = markOrderAsRtoInTransit_args()
5803 
    args.orderId = orderId
5804 
    args.write(self._oprot)
5805 
    self._oprot.writeMessageEnd()
5806 
    self._oprot.trans.flush()
5807 
 
5808 
  def recv_markOrderAsRtoInTransit(self, ):
5809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5810 
    if mtype == TMessageType.EXCEPTION:
5811 
      x = TApplicationException()
5812 
      x.read(self._iprot)
5813 
      self._iprot.readMessageEnd()
5814 
      raise x
5815 
    result = markOrderAsRtoInTransit_result()
5816 
    result.read(self._iprot)
5817 
    self._iprot.readMessageEnd()
5818 
    if result.success is not None:
5819 
      return result.success
5820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5821 
 
5593 mandeep.dh 5822 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5823 
    """
5824 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5825 
    invoked while scanning IN of items.
5553 rajveer 5826 
 
5593 mandeep.dh 5827 
    Parameters:
5828 
     - itemId
5829 
     - quantity
5830 
     - fulfilmentWarehouseId
5831 
     - billingWarehouseId
5832 
    """
5833 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5834 
    self.recv_acceptOrderForItem()
5835 
 
5836 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5837 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5838 
    args = acceptOrderForItem_args()
5839 
    args.itemId = itemId
5840 
    args.quantity = quantity
5841 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5842 
    args.billingWarehouseId = billingWarehouseId
5843 
    args.write(self._oprot)
5844 
    self._oprot.writeMessageEnd()
5845 
    self._oprot.trans.flush()
5846 
 
5847 
  def recv_acceptOrderForItem(self, ):
5848 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5849 
    if mtype == TMessageType.EXCEPTION:
5850 
      x = TApplicationException()
5851 
      x.read(self._iprot)
5852 
      self._iprot.readMessageEnd()
5853 
      raise x
5854 
    result = acceptOrderForItem_result()
5855 
    result.read(self._iprot)
5856 
    self._iprot.readMessageEnd()
5857 
    return
5858 
 
6000 mandeep.dh 5859 
  def createRechargeOrder(self, rechargeOrder):
5860 
    """
5861 
    Parameters:
5862 
     - rechargeOrder
5863 
    """
5864 
    self.send_createRechargeOrder(rechargeOrder)
5865 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5866 
 
6000 mandeep.dh 5867 
  def send_createRechargeOrder(self, rechargeOrder):
5868 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5869 
    args = createRechargeOrder_args()
5870 
    args.rechargeOrder = rechargeOrder
5871 
    args.write(self._oprot)
5872 
    self._oprot.writeMessageEnd()
5873 
    self._oprot.trans.flush()
5874 
 
5875 
  def recv_createRechargeOrder(self, ):
5876 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5877 
    if mtype == TMessageType.EXCEPTION:
5878 
      x = TApplicationException()
5879 
      x.read(self._iprot)
5880 
      self._iprot.readMessageEnd()
5881 
      raise x
5882 
    result = createRechargeOrder_result()
5883 
    result.read(self._iprot)
5884 
    self._iprot.readMessageEnd()
5885 
    if result.success is not None:
5886 
      return result.success
5887 
    if result.ex is not None:
5888 
      raise result.ex
5889 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5890 
 
6031 rajveer 5891 
  def getRechargeOrder(self, rechargeRrderId):
5892 
    """
5893 
    Parameters:
5894 
     - rechargeRrderId
5895 
    """
5896 
    self.send_getRechargeOrder(rechargeRrderId)
5897 
    return self.recv_getRechargeOrder()
5898 
 
5899 
  def send_getRechargeOrder(self, rechargeRrderId):
5900 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5901 
    args = getRechargeOrder_args()
5902 
    args.rechargeRrderId = rechargeRrderId
5903 
    args.write(self._oprot)
5904 
    self._oprot.writeMessageEnd()
5905 
    self._oprot.trans.flush()
5906 
 
5907 
  def recv_getRechargeOrder(self, ):
5908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5909 
    if mtype == TMessageType.EXCEPTION:
5910 
      x = TApplicationException()
5911 
      x.read(self._iprot)
5912 
      self._iprot.readMessageEnd()
5913 
      raise x
5914 
    result = getRechargeOrder_result()
5915 
    result.read(self._iprot)
5916 
    self._iprot.readMessageEnd()
5917 
    if result.success is not None:
5918 
      return result.success
5919 
    if result.ex is not None:
5920 
      raise result.ex
5921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5922 
 
5923 
  def getRechargeOrders(self, userId):
5924 
    """
5925 
    Parameters:
5926 
     - userId
5927 
    """
5928 
    self.send_getRechargeOrders(userId)
5929 
    return self.recv_getRechargeOrders()
5930 
 
5931 
  def send_getRechargeOrders(self, userId):
5932 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5933 
    args = getRechargeOrders_args()
5934 
    args.userId = userId
5935 
    args.write(self._oprot)
5936 
    self._oprot.writeMessageEnd()
5937 
    self._oprot.trans.flush()
5938 
 
5939 
  def recv_getRechargeOrders(self, ):
5940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5941 
    if mtype == TMessageType.EXCEPTION:
5942 
      x = TApplicationException()
5943 
      x.read(self._iprot)
5944 
      self._iprot.readMessageEnd()
5945 
      raise x
5946 
    result = getRechargeOrders_result()
5947 
    result.read(self._iprot)
5948 
    self._iprot.readMessageEnd()
5949 
    if result.success is not None:
5950 
      return result.success
5951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5952 
 
6000 mandeep.dh 5953 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5954 
    """
5955 
    Parameters:
5956 
     - rechargeOrderId
5957 
     - rechargeOrderStatus
5958 
    """
5959 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5960 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5961 
 
5962 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5963 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5964 
    args = updateRechargeOrderStatus_args()
5965 
    args.rechargeOrderId = rechargeOrderId
5966 
    args.rechargeOrderStatus = rechargeOrderStatus
5967 
    args.write(self._oprot)
5968 
    self._oprot.writeMessageEnd()
5969 
    self._oprot.trans.flush()
5970 
 
5971 
  def recv_updateRechargeOrderStatus(self, ):
5972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5973 
    if mtype == TMessageType.EXCEPTION:
5974 
      x = TApplicationException()
5975 
      x.read(self._iprot)
5976 
      self._iprot.readMessageEnd()
5977 
      raise x
5978 
    result = updateRechargeOrderStatus_result()
5979 
    result.read(self._iprot)
5980 
    self._iprot.readMessageEnd()
6031 rajveer 5981 
    if result.success is not None:
5982 
      return result.success
6000 mandeep.dh 5983 
    if result.ex is not None:
5984 
      raise result.ex
6031 rajveer 5985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5986 
 
6031 rajveer 5987 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5988 
    """
5989 
    Parameters:
6031 rajveer 5990 
     - rechargeOrderId
6000 mandeep.dh 5991 
    """
6031 rajveer 5992 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5993 
    return self.recv_activateRechargeTxn()
5994 
 
6031 rajveer 5995 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5996 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5997 
    args = activateRechargeTxn_args()
6031 rajveer 5998 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5999 
    args.write(self._oprot)
6000 
    self._oprot.writeMessageEnd()
6001 
    self._oprot.trans.flush()
6002 
 
6003 
  def recv_activateRechargeTxn(self, ):
6004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6005 
    if mtype == TMessageType.EXCEPTION:
6006 
      x = TApplicationException()
6007 
      x.read(self._iprot)
6008 
      self._iprot.readMessageEnd()
6009 
      raise x
6010 
    result = activateRechargeTxn_result()
6011 
    result.read(self._iprot)
6012 
    self._iprot.readMessageEnd()
6013 
    if result.success is not None:
6014 
      return result.success
6015 
    if result.ex is not None:
6016 
      raise result.ex
6017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6018 
 
6031 rajveer 6019 
  def getUserWallet(self, userId):
6000 mandeep.dh 6020 
    """
6021 
    Parameters:
6031 rajveer 6022 
     - userId
6000 mandeep.dh 6023 
    """
6031 rajveer 6024 
    self.send_getUserWallet(userId)
6025 
    return self.recv_getUserWallet()
6000 mandeep.dh 6026 
 
6031 rajveer 6027 
  def send_getUserWallet(self, userId):
6028 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6029 
    args = getUserWallet_args()
6030 
    args.userId = userId
6000 mandeep.dh 6031 
    args.write(self._oprot)
6032 
    self._oprot.writeMessageEnd()
6033 
    self._oprot.trans.flush()
6034 
 
6031 rajveer 6035 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6037 
    if mtype == TMessageType.EXCEPTION:
6038 
      x = TApplicationException()
6039 
      x.read(self._iprot)
6040 
      self._iprot.readMessageEnd()
6041 
      raise x
6031 rajveer 6042 
    result = getUserWallet_result()
6000 mandeep.dh 6043 
    result.read(self._iprot)
6044 
    self._iprot.readMessageEnd()
6045 
    if result.success is not None:
6046 
      return result.success
6031 rajveer 6047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6048 
 
6031 rajveer 6049 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6050 
    """
6051 
    Parameters:
6031 rajveer 6052 
     - userId
6000 mandeep.dh 6053 
    """
6031 rajveer 6054 
    self.send_getUserWalletHistory(userId)
6055 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6056 
 
6031 rajveer 6057 
  def send_getUserWalletHistory(self, userId):
6058 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6059 
    args = getUserWalletHistory_args()
6060 
    args.userId = userId
6000 mandeep.dh 6061 
    args.write(self._oprot)
6062 
    self._oprot.writeMessageEnd()
6063 
    self._oprot.trans.flush()
6064 
 
6031 rajveer 6065 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6067 
    if mtype == TMessageType.EXCEPTION:
6068 
      x = TApplicationException()
6069 
      x.read(self._iprot)
6070 
      self._iprot.readMessageEnd()
6071 
      raise x
6031 rajveer 6072 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6073 
    result.read(self._iprot)
6074 
    self._iprot.readMessageEnd()
6075 
    if result.success is not None:
6076 
      return result.success
6031 rajveer 6077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6078 
 
6050 anupam.sin 6079 
  def getRechargeOrdersForTransaction(self, txnId):
6080 
    """
6081 
    Returns a recharge order for a given transactionId
6082 
 
6083 
    Parameters:
6084 
     - txnId
6085 
    """
6086 
    self.send_getRechargeOrdersForTransaction(txnId)
6087 
    return self.recv_getRechargeOrdersForTransaction()
6088 
 
6089 
  def send_getRechargeOrdersForTransaction(self, txnId):
6090 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6091 
    args = getRechargeOrdersForTransaction_args()
6092 
    args.txnId = txnId
6093 
    args.write(self._oprot)
6094 
    self._oprot.writeMessageEnd()
6095 
    self._oprot.trans.flush()
6096 
 
6097 
  def recv_getRechargeOrdersForTransaction(self, ):
6098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6099 
    if mtype == TMessageType.EXCEPTION:
6100 
      x = TApplicationException()
6101 
      x.read(self._iprot)
6102 
      self._iprot.readMessageEnd()
6103 
      raise x
6104 
    result = getRechargeOrdersForTransaction_result()
6105 
    result.read(self._iprot)
6106 
    self._iprot.readMessageEnd()
6107 
    if result.success is not None:
6108 
      return result.success
6109 
    if result.ex is not None:
6110 
      raise result.ex
6111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6112 
 
6206 rajveer 6113 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6114 
    """
6115 
    Parameters:
6116 
     - rechargeType
6206 rajveer 6117 
     - onlyActive
6048 rajveer 6118 
    """
6206 rajveer 6119 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6120 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6121 
 
6206 rajveer 6122 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6123 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6124 
    args = getServiceProviders_args()
6125 
    args.rechargeType = rechargeType
6206 rajveer 6126 
    args.onlyActive = onlyActive
6048 rajveer 6127 
    args.write(self._oprot)
6128 
    self._oprot.writeMessageEnd()
6129 
    self._oprot.trans.flush()
6130 
 
6131 
  def recv_getServiceProviders(self, ):
6132 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6133 
    if mtype == TMessageType.EXCEPTION:
6134 
      x = TApplicationException()
6135 
      x.read(self._iprot)
6136 
      self._iprot.readMessageEnd()
6137 
      raise x
6138 
    result = getServiceProviders_result()
6139 
    result.read(self._iprot)
6140 
    self._iprot.readMessageEnd()
6141 
    if result.success is not None:
6142 
      return result.success
6143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6144 
 
6049 rajveer 6145 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6146 
    """
6147 
    Parameters:
6049 rajveer 6148 
     - rechargeType
6048 rajveer 6149 
     - deviceNumber
6150 
    """
6049 rajveer 6151 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6152 
    return self.recv_getServiceProviderForDevice()
6153 
 
6049 rajveer 6154 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6155 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6156 
    args = getServiceProviderForDevice_args()
6049 rajveer 6157 
    args.rechargeType = rechargeType
6048 rajveer 6158 
    args.deviceNumber = deviceNumber
6159 
    args.write(self._oprot)
6160 
    self._oprot.writeMessageEnd()
6161 
    self._oprot.trans.flush()
6162 
 
6163 
  def recv_getServiceProviderForDevice(self, ):
6164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6165 
    if mtype == TMessageType.EXCEPTION:
6166 
      x = TApplicationException()
6167 
      x.read(self._iprot)
6168 
      self._iprot.readMessageEnd()
6169 
      raise x
6170 
    result = getServiceProviderForDevice_result()
6171 
    result.read(self._iprot)
6172 
    self._iprot.readMessageEnd()
6173 
    if result.success is not None:
6174 
      return result.success
6175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6176 
 
6307 anupam.sin 6177 
  def validateRecharge(self, rechargeType, deviceNumber, circleCode, userSelectedProviderId):
6269 rajveer 6178 
    """
6179 
    Parameters:
6180 
     - rechargeType
6181 
     - deviceNumber
6307 anupam.sin 6182 
     - circleCode
6183 
     - userSelectedProviderId
6269 rajveer 6184 
    """
6307 anupam.sin 6185 
    self.send_validateRecharge(rechargeType, deviceNumber, circleCode, userSelectedProviderId)
6269 rajveer 6186 
    return self.recv_validateRecharge()
6187 
 
6307 anupam.sin 6188 
  def send_validateRecharge(self, rechargeType, deviceNumber, circleCode, userSelectedProviderId):
6269 rajveer 6189 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6190 
    args = validateRecharge_args()
6191 
    args.rechargeType = rechargeType
6192 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6193 
    args.circleCode = circleCode
6194 
    args.userSelectedProviderId = userSelectedProviderId
6269 rajveer 6195 
    args.write(self._oprot)
6196 
    self._oprot.writeMessageEnd()
6197 
    self._oprot.trans.flush()
6198 
 
6199 
  def recv_validateRecharge(self, ):
6200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6201 
    if mtype == TMessageType.EXCEPTION:
6202 
      x = TApplicationException()
6203 
      x.read(self._iprot)
6204 
      self._iprot.readMessageEnd()
6205 
      raise x
6206 
    result = validateRecharge_result()
6207 
    result.read(self._iprot)
6208 
    self._iprot.readMessageEnd()
6209 
    if result.success is not None:
6210 
      return result.success
6211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6212 
 
6094 rajveer 6213 
  def getRechargeOrdersForDevice(self, deviceNumber):
6214 
    """
6215 
    Parameters:
6216 
     - deviceNumber
6217 
    """
6218 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6219 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6220 
 
6094 rajveer 6221 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6222 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6223 
    args = getRechargeOrdersForDevice_args()
6224 
    args.deviceNumber = deviceNumber
6225 
    args.write(self._oprot)
6226 
    self._oprot.writeMessageEnd()
6227 
    self._oprot.trans.flush()
6228 
 
6229 
  def recv_getRechargeOrdersForDevice(self, ):
6230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6231 
    if mtype == TMessageType.EXCEPTION:
6232 
      x = TApplicationException()
6233 
      x.read(self._iprot)
6234 
      self._iprot.readMessageEnd()
6235 
      raise x
6236 
    result = getRechargeOrdersForDevice_result()
6237 
    result.read(self._iprot)
6238 
    self._iprot.readMessageEnd()
6239 
    if result.success is not None:
6240 
      return result.success
6241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6242 
 
6243 
  def addAmountToWallet(self, userId, orderId, amount):
6244 
    """
6245 
    Parameters:
6246 
     - userId
6247 
     - orderId
6248 
     - amount
6249 
    """
6250 
    self.send_addAmountToWallet(userId, orderId, amount)
6251 
    self.recv_addAmountToWallet()
6252 
 
6253 
  def send_addAmountToWallet(self, userId, orderId, amount):
6254 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6255 
    args = addAmountToWallet_args()
6256 
    args.userId = userId
6257 
    args.orderId = orderId
6258 
    args.amount = amount
6259 
    args.write(self._oprot)
6260 
    self._oprot.writeMessageEnd()
6261 
    self._oprot.trans.flush()
6262 
 
6263 
  def recv_addAmountToWallet(self, ):
6264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6265 
    if mtype == TMessageType.EXCEPTION:
6266 
      x = TApplicationException()
6267 
      x.read(self._iprot)
6268 
      self._iprot.readMessageEnd()
6269 
      raise x
6270 
    result = addAmountToWallet_result()
6271 
    result.read(self._iprot)
6272 
    self._iprot.readMessageEnd()
6273 
    return
6274 
 
6188 rajveer 6275 
  def getRechargeStatistics(self, ):
6276 
    self.send_getRechargeStatistics()
6277 
    return self.recv_getRechargeStatistics()
6278 
 
6279 
  def send_getRechargeStatistics(self, ):
6280 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6281 
    args = getRechargeStatistics_args()
6282 
    args.write(self._oprot)
6283 
    self._oprot.writeMessageEnd()
6284 
    self._oprot.trans.flush()
6285 
 
6286 
  def recv_getRechargeStatistics(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 = getRechargeStatistics_result()
6294 
    result.read(self._iprot)
6295 
    self._iprot.readMessageEnd()
6296 
    if result.success is not None:
6297 
      return result.success
6298 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6299 
 
6154 rajveer 6300 
  def getRechargeOrdersForStatus(self, status):
6301 
    """
6302 
    Parameters:
6303 
     - status
6304 
    """
6305 
    self.send_getRechargeOrdersForStatus(status)
6306 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6307 
 
6154 rajveer 6308 
  def send_getRechargeOrdersForStatus(self, status):
6309 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6310 
    args = getRechargeOrdersForStatus_args()
6311 
    args.status = status
6312 
    args.write(self._oprot)
6313 
    self._oprot.writeMessageEnd()
6314 
    self._oprot.trans.flush()
6315 
 
6316 
  def recv_getRechargeOrdersForStatus(self, ):
6317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6318 
    if mtype == TMessageType.EXCEPTION:
6319 
      x = TApplicationException()
6320 
      x.read(self._iprot)
6321 
      self._iprot.readMessageEnd()
6322 
      raise x
6323 
    result = getRechargeOrdersForStatus_result()
6324 
    result.read(self._iprot)
6325 
    self._iprot.readMessageEnd()
6326 
    if result.success is not None:
6327 
      return result.success
6328 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6329 
 
6159 rajveer 6330 
  def getPlansForOperator(self, operatorId):
6331 
    """
6332 
    Parameters:
6333 
     - operatorId
6334 
    """
6335 
    self.send_getPlansForOperator(operatorId)
6336 
    return self.recv_getPlansForOperator()
6154 rajveer 6337 
 
6159 rajveer 6338 
  def send_getPlansForOperator(self, operatorId):
6339 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6340 
    args = getPlansForOperator_args()
6341 
    args.operatorId = operatorId
6342 
    args.write(self._oprot)
6343 
    self._oprot.writeMessageEnd()
6344 
    self._oprot.trans.flush()
6345 
 
6346 
  def recv_getPlansForOperator(self, ):
6347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6348 
    if mtype == TMessageType.EXCEPTION:
6349 
      x = TApplicationException()
6350 
      x.read(self._iprot)
6351 
      self._iprot.readMessageEnd()
6352 
      raise x
6353 
    result = getPlansForOperator_result()
6354 
    result.read(self._iprot)
6355 
    self._iprot.readMessageEnd()
6356 
    if result.success is not None:
6357 
      return result.success
6358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6359 
 
6307 anupam.sin 6360 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6361 
    """
6362 
    Returns denominations for a given operator and circle
6159 rajveer 6363 
 
6289 anupam.sin 6364 
    Parameters:
6365 
     - operatorId
6307 anupam.sin 6366 
     - circleCode
6289 anupam.sin 6367 
     - denominationType
6368 
    """
6307 anupam.sin 6369 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6370 
    return self.recv_getRechargeDenominations()
6371 
 
6307 anupam.sin 6372 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6373 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6374 
    args = getRechargeDenominations_args()
6375 
    args.operatorId = operatorId
6307 anupam.sin 6376 
    args.circleCode = circleCode
6289 anupam.sin 6377 
    args.denominationType = denominationType
6378 
    args.write(self._oprot)
6379 
    self._oprot.writeMessageEnd()
6380 
    self._oprot.trans.flush()
6381 
 
6382 
  def recv_getRechargeDenominations(self, ):
6383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6384 
    if mtype == TMessageType.EXCEPTION:
6385 
      x = TApplicationException()
6386 
      x.read(self._iprot)
6387 
      self._iprot.readMessageEnd()
6388 
      raise x
6389 
    result = getRechargeDenominations_result()
6390 
    result.read(self._iprot)
6391 
    self._iprot.readMessageEnd()
6392 
    if result.success is not None:
6393 
      return result.success
6394 
    if result.ex is not None:
6395 
      raise result.ex
6396 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6397 
 
6398 
 
3376 rajveer 6399 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6400 
  def __init__(self, handler):
3376 rajveer 6401 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6402 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6403 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6404 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6405 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6406 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6407 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6408 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6409 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6410 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6411 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6412 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6413 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6414 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6415 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6416 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6417 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6418 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6419 
    self._processMap["createOrder"] = Processor.process_createOrder
6420 
    self._processMap["getOrder"] = Processor.process_getOrder
6421 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6422 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6423 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6424 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6425 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6426 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6427 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6428 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6429 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6430 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6431 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6432 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6433 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6434 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6435 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6436 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6437 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6438 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6439 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6440 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6441 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6442 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6443 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6444 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6445 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6446 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6447 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6448 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6449 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6450 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6451 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6452 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6453 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6454 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6455 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6456 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6457 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6458 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6459 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6460 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6461 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6462 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6463 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6464 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6465 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6466 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6467 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6468 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6469 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6470 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6471 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6472 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6473 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6474 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6475 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6476 
    self._processMap["changeItem"] = Processor.process_changeItem
6477 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6478 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6479 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6480 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6481 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6482 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6483 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6484 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6485 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6486 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6487 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6488 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6489 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6490 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6491 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6492 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6493 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6494 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6495 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6496 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6497 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6498 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6499 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6500 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6501 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6502 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6503 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6504 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6505 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6506 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6507 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6508 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6509 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6510 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6511 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6512 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6513 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6514 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6515 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6516 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6517 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6518 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6519 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6520 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6521 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6522 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6523 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6524 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6525 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6526 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6527 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6528 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6529 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6530 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6531 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6532 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6533 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6534 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6535 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6536 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6537 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6538 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6539 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6540 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6541 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6542 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6543 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6544 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6545 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
94 ashish 6546 
 
6547 
  def process(self, iprot, oprot):
6548 
    (name, type, seqid) = iprot.readMessageBegin()
6549 
    if name not in self._processMap:
6550 
      iprot.skip(TType.STRUCT)
6551 
      iprot.readMessageEnd()
6552 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6553 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6554 
      x.write(oprot)
6555 
      oprot.writeMessageEnd()
6556 
      oprot.trans.flush()
6557 
      return
6558 
    else:
6559 
      self._processMap[name](self, seqid, iprot, oprot)
6560 
    return True
6561 
 
6562 
  def process_createTransaction(self, seqid, iprot, oprot):
6563 
    args = createTransaction_args()
6564 
    args.read(iprot)
6565 
    iprot.readMessageEnd()
6566 
    result = createTransaction_result()
6567 
    try:
132 ashish 6568 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6569 
    except TransactionServiceException, ex:
6570 
      result.ex = ex
6571 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6572 
    result.write(oprot)
6573 
    oprot.writeMessageEnd()
6574 
    oprot.trans.flush()
6575 
 
6576 
  def process_getTransaction(self, seqid, iprot, oprot):
6577 
    args = getTransaction_args()
6578 
    args.read(iprot)
6579 
    iprot.readMessageEnd()
6580 
    result = getTransaction_result()
6581 
    try:
6582 
      result.success = self._handler.getTransaction(args.id)
6583 
    except TransactionServiceException, ex:
6584 
      result.ex = ex
6585 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6586 
    result.write(oprot)
6587 
    oprot.writeMessageEnd()
6588 
    oprot.trans.flush()
6589 
 
6590 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6591 
    args = getTransactionsForCustomer_args()
6592 
    args.read(iprot)
6593 
    iprot.readMessageEnd()
6594 
    result = getTransactionsForCustomer_result()
6595 
    try:
6596 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6597 
    except TransactionServiceException, ex:
6598 
      result.ex = ex
6599 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6600 
    result.write(oprot)
6601 
    oprot.writeMessageEnd()
6602 
    oprot.trans.flush()
6603 
 
132 ashish 6604 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6605 
    args = getTransactionsForShoppingCartId_args()
6606 
    args.read(iprot)
6607 
    iprot.readMessageEnd()
6608 
    result = getTransactionsForShoppingCartId_result()
6609 
    try:
6610 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6611 
    except TransactionServiceException, ex:
6612 
      result.ex = ex
6613 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6614 
    result.write(oprot)
6615 
    oprot.writeMessageEnd()
6616 
    oprot.trans.flush()
6617 
 
94 ashish 6618 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6619 
    args = getTransactionStatus_args()
6620 
    args.read(iprot)
6621 
    iprot.readMessageEnd()
6622 
    result = getTransactionStatus_result()
6623 
    try:
6624 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6625 
    except TransactionServiceException, ex:
6626 
      result.ex = ex
6627 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6628 
    result.write(oprot)
6629 
    oprot.writeMessageEnd()
6630 
    oprot.trans.flush()
6631 
 
6632 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6633 
    args = changeTransactionStatus_args()
6634 
    args.read(iprot)
6635 
    iprot.readMessageEnd()
6636 
    result = changeTransactionStatus_result()
6637 
    try:
5527 anupam.sin 6638 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6639 
    except TransactionServiceException, ex:
6640 
      result.ex = ex
6641 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6642 
    result.write(oprot)
6643 
    oprot.writeMessageEnd()
6644 
    oprot.trans.flush()
6645 
 
1398 varun.gupt 6646 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6647 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6648 
    args.read(iprot)
6649 
    iprot.readMessageEnd()
1398 varun.gupt 6650 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6651 
    try:
1398 varun.gupt 6652 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6653 
    except TransactionServiceException, ex:
6654 
      result.ex = ex
1398 varun.gupt 6655 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6656 
    result.write(oprot)
6657 
    oprot.writeMessageEnd()
6658 
    oprot.trans.flush()
6659 
 
483 rajveer 6660 
  def process_getAllOrders(self, seqid, iprot, oprot):
6661 
    args = getAllOrders_args()
94 ashish 6662 
    args.read(iprot)
6663 
    iprot.readMessageEnd()
483 rajveer 6664 
    result = getAllOrders_result()
94 ashish 6665 
    try:
4801 anupam.sin 6666 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6667 
    except TransactionServiceException, ex:
6668 
      result.ex = ex
483 rajveer 6669 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6670 
    result.write(oprot)
6671 
    oprot.writeMessageEnd()
6672 
    oprot.trans.flush()
6673 
 
4133 chandransh 6674 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6675 
    args = getOrdersInBatch_args()
6676 
    args.read(iprot)
6677 
    iprot.readMessageEnd()
6678 
    result = getOrdersInBatch_result()
6679 
    try:
6680 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6681 
    except TransactionServiceException, ex:
6682 
      result.ex = ex
6683 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6684 
    result.write(oprot)
6685 
    oprot.writeMessageEnd()
6686 
    oprot.trans.flush()
6687 
 
6688 
  def process_getOrderCount(self, seqid, iprot, oprot):
6689 
    args = getOrderCount_args()
6690 
    args.read(iprot)
6691 
    iprot.readMessageEnd()
6692 
    result = getOrderCount_result()
6693 
    try:
6694 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6695 
    except TransactionServiceException, ex:
6696 
      result.ex = ex
6697 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6698 
    result.write(oprot)
6699 
    oprot.writeMessageEnd()
6700 
    oprot.trans.flush()
6701 
 
999 varun.gupt 6702 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6703 
    args = getOrdersByBillingDate_args()
6704 
    args.read(iprot)
6705 
    iprot.readMessageEnd()
6706 
    result = getOrdersByBillingDate_result()
6707 
    try:
6708 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6709 
    except TransactionServiceException, ex:
6710 
      result.ex = ex
6711 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6712 
    result.write(oprot)
6713 
    oprot.writeMessageEnd()
6714 
    oprot.trans.flush()
6715 
 
3427 chandransh 6716 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6717 
    args = getOrdersByShippingDate_args()
6718 
    args.read(iprot)
6719 
    iprot.readMessageEnd()
6720 
    result = getOrdersByShippingDate_result()
6721 
    try:
3451 chandransh 6722 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6723 
    except TransactionServiceException, ex:
6724 
      result.ex = ex
6725 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6726 
    result.write(oprot)
6727 
    oprot.writeMessageEnd()
6728 
    oprot.trans.flush()
6729 
 
1382 varun.gupt 6730 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6731 
    args = getReturnableOrdersForCustomer_args()
6732 
    args.read(iprot)
6733 
    iprot.readMessageEnd()
6734 
    result = getReturnableOrdersForCustomer_result()
6735 
    try:
6736 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6737 
    except TransactionServiceException, ex:
6738 
      result.ex = ex
6739 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6740 
    result.write(oprot)
6741 
    oprot.writeMessageEnd()
6742 
    oprot.trans.flush()
6743 
 
6744 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6745 
    args = getCancellableOrdersForCustomer_args()
6746 
    args.read(iprot)
6747 
    iprot.readMessageEnd()
6748 
    result = getCancellableOrdersForCustomer_result()
6749 
    try:
6750 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6751 
    except TransactionServiceException, ex:
6752 
      result.ex = ex
6753 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6754 
    result.write(oprot)
6755 
    oprot.writeMessageEnd()
6756 
    oprot.trans.flush()
6757 
 
483 rajveer 6758 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6759 
    args = changeOrderStatus_args()
94 ashish 6760 
    args.read(iprot)
6761 
    iprot.readMessageEnd()
483 rajveer 6762 
    result = changeOrderStatus_result()
94 ashish 6763 
    try:
483 rajveer 6764 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6765 
    except TransactionServiceException, ex:
6766 
      result.ex = ex
483 rajveer 6767 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6768 
    result.write(oprot)
6769 
    oprot.writeMessageEnd()
6770 
    oprot.trans.flush()
6771 
 
483 rajveer 6772 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6773 
    args = getOrdersForTransaction_args()
94 ashish 6774 
    args.read(iprot)
6775 
    iprot.readMessageEnd()
483 rajveer 6776 
    result = getOrdersForTransaction_result()
94 ashish 6777 
    try:
1528 ankur.sing 6778 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6779 
    except TransactionServiceException, ex:
6780 
      result.ex = ex
483 rajveer 6781 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6782 
    result.write(oprot)
6783 
    oprot.writeMessageEnd()
6784 
    oprot.trans.flush()
6785 
 
483 rajveer 6786 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6787 
    args = getOrdersForCustomer_args()
94 ashish 6788 
    args.read(iprot)
6789 
    iprot.readMessageEnd()
483 rajveer 6790 
    result = getOrdersForCustomer_result()
94 ashish 6791 
    try:
3014 chandransh 6792 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6793 
    except TransactionServiceException, ex:
6794 
      result.ex = ex
483 rajveer 6795 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6796 
    result.write(oprot)
6797 
    oprot.writeMessageEnd()
6798 
    oprot.trans.flush()
6799 
 
483 rajveer 6800 
  def process_createOrder(self, seqid, iprot, oprot):
6801 
    args = createOrder_args()
94 ashish 6802 
    args.read(iprot)
6803 
    iprot.readMessageEnd()
483 rajveer 6804 
    result = createOrder_result()
94 ashish 6805 
    try:
483 rajveer 6806 
      result.success = self._handler.createOrder(args.order)
94 ashish 6807 
    except TransactionServiceException, ex:
6808 
      result.ex = ex
483 rajveer 6809 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6810 
    result.write(oprot)
6811 
    oprot.writeMessageEnd()
6812 
    oprot.trans.flush()
6813 
 
483 rajveer 6814 
  def process_getOrder(self, seqid, iprot, oprot):
6815 
    args = getOrder_args()
94 ashish 6816 
    args.read(iprot)
6817 
    iprot.readMessageEnd()
483 rajveer 6818 
    result = getOrder_result()
94 ashish 6819 
    try:
483 rajveer 6820 
      result.success = self._handler.getOrder(args.id)
94 ashish 6821 
    except TransactionServiceException, ex:
6822 
      result.ex = ex
483 rajveer 6823 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6824 
    result.write(oprot)
6825 
    oprot.writeMessageEnd()
6826 
    oprot.trans.flush()
6827 
 
483 rajveer 6828 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6829 
    args = getLineItemsForOrder_args()
94 ashish 6830 
    args.read(iprot)
6831 
    iprot.readMessageEnd()
483 rajveer 6832 
    result = getLineItemsForOrder_result()
94 ashish 6833 
    try:
483 rajveer 6834 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6835 
    except TransactionServiceException, ex:
6836 
      result.ex = ex
483 rajveer 6837 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6838 
    result.write(oprot)
6839 
    oprot.writeMessageEnd()
6840 
    oprot.trans.flush()
6841 
 
4999 phani.kuma 6842 
  def process_getOrderList(self, seqid, iprot, oprot):
6843 
    args = getOrderList_args()
6844 
    args.read(iprot)
6845 
    iprot.readMessageEnd()
6846 
    result = getOrderList_result()
6847 
    result.success = self._handler.getOrderList(args.order_ids)
6848 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6849 
    result.write(oprot)
6850 
    oprot.writeMessageEnd()
6851 
    oprot.trans.flush()
6852 
 
5386 phani.kuma 6853 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6854 
    args = getOrderListForVendor_args()
6855 
    args.read(iprot)
6856 
    iprot.readMessageEnd()
6857 
    result = getOrderListForVendor_result()
6858 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6859 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6860 
    result.write(oprot)
6861 
    oprot.writeMessageEnd()
6862 
    oprot.trans.flush()
6863 
 
1528 ankur.sing 6864 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6865 
    args = getOrderForCustomer_args()
6866 
    args.read(iprot)
6867 
    iprot.readMessageEnd()
6868 
    result = getOrderForCustomer_result()
6869 
    try:
6870 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6871 
    except TransactionServiceException, ex:
6872 
      result.ex = ex
6873 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6874 
    result.write(oprot)
6875 
    oprot.writeMessageEnd()
6876 
    oprot.trans.flush()
6877 
 
3064 chandransh 6878 
  def process_getAlerts(self, seqid, iprot, oprot):
6879 
    args = getAlerts_args()
6880 
    args.read(iprot)
6881 
    iprot.readMessageEnd()
6882 
    result = getAlerts_result()
4444 rajveer 6883 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6884 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6885 
    result.write(oprot)
6886 
    oprot.writeMessageEnd()
6887 
    oprot.trans.flush()
6888 
 
4394 rajveer 6889 
  def process_addAlert(self, seqid, iprot, oprot):
6890 
    args = addAlert_args()
3064 chandransh 6891 
    args.read(iprot)
6892 
    iprot.readMessageEnd()
4394 rajveer 6893 
    result = addAlert_result()
4444 rajveer 6894 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6895 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6896 
    result.write(oprot)
6897 
    oprot.writeMessageEnd()
6898 
    oprot.trans.flush()
6899 
 
4444 rajveer 6900 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6901 
    args = markAlertsAsSeen_args()
6902 
    args.read(iprot)
6903 
    iprot.readMessageEnd()
6904 
    result = markAlertsAsSeen_result()
6905 
    self._handler.markAlertsAsSeen(args.warehouseId)
6906 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6907 
    result.write(oprot)
6908 
    oprot.writeMessageEnd()
6909 
    oprot.trans.flush()
6910 
 
3064 chandransh 6911 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6912 
    args = getValidOrderCount_args()
6913 
    args.read(iprot)
6914 
    iprot.readMessageEnd()
6915 
    result = getValidOrderCount_result()
6916 
    result.success = self._handler.getValidOrderCount()
6917 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6918 
    result.write(oprot)
6919 
    oprot.writeMessageEnd()
6920 
    oprot.trans.flush()
6921 
 
6922 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6923 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6924 
    args.read(iprot)
6925 
    iprot.readMessageEnd()
6926 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6927 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6928 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6929 
    result.write(oprot)
6930 
    oprot.writeMessageEnd()
6931 
    oprot.trans.flush()
6932 
 
6933 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6934 
    args = getValidOrdersAmountRange_args()
6935 
    args.read(iprot)
6936 
    iprot.readMessageEnd()
6937 
    result = getValidOrdersAmountRange_result()
6938 
    result.success = self._handler.getValidOrdersAmountRange()
6939 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6940 
    result.write(oprot)
6941 
    oprot.writeMessageEnd()
6942 
    oprot.trans.flush()
6943 
 
6944 
  def process_getValidOrders(self, seqid, iprot, oprot):
6945 
    args = getValidOrders_args()
6946 
    args.read(iprot)
6947 
    iprot.readMessageEnd()
6948 
    result = getValidOrders_result()
5874 rajveer 6949 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6950 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
1220 chandransh 6955 
  def process_batchOrders(self, seqid, iprot, oprot):
6956 
    args = batchOrders_args()
6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
6959 
    result = batchOrders_result()
6960 
    try:
6961 
      result.success = self._handler.batchOrders(args.warehouseId)
6962 
    except TransactionServiceException, ex:
6963 
      result.ex = ex
6964 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
6968 
 
1208 chandransh 6969 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6970 
    args = markOrderAsOutOfStock_args()
6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
6973 
    result = markOrderAsOutOfStock_result()
6974 
    try:
6975 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
6978 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
3064 chandransh 6983 
  def process_verifyOrder(self, seqid, iprot, oprot):
6984 
    args = verifyOrder_args()
759 chandransh 6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
3064 chandransh 6987 
    result = verifyOrder_result()
759 chandransh 6988 
    try:
3064 chandransh 6989 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
3064 chandransh 6992 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
3064 chandransh 6997 
  def process_acceptOrder(self, seqid, iprot, oprot):
6998 
    args = acceptOrder_args()
1113 chandransh 6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
3064 chandransh 7001 
    result = acceptOrder_result()
1113 chandransh 7002 
    try:
3064 chandransh 7003 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7004 
    except TransactionServiceException, ex:
7005 
      result.ex = ex
3064 chandransh 7006 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7007 
    result.write(oprot)
7008 
    oprot.writeMessageEnd()
7009 
    oprot.trans.flush()
7010 
 
3064 chandransh 7011 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7012 
    args = addBillingDetails_args()
1135 chandransh 7013 
    args.read(iprot)
7014 
    iprot.readMessageEnd()
3064 chandransh 7015 
    result = addBillingDetails_result()
1135 chandransh 7016 
    try:
5110 mandeep.dh 7017 
      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 7018 
    except TransactionServiceException, ex:
7019 
      result.ex = ex
3064 chandransh 7020 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7021 
    result.write(oprot)
7022 
    oprot.writeMessageEnd()
7023 
    oprot.trans.flush()
7024 
 
4579 rajveer 7025 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7026 
    args = addInvoiceNumber_args()
7027 
    args.read(iprot)
7028 
    iprot.readMessageEnd()
7029 
    result = addInvoiceNumber_result()
7030 
    try:
4763 rajveer 7031 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7032 
    except TransactionServiceException, ex:
7033 
      result.ex = ex
7034 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7035 
    result.write(oprot)
7036 
    oprot.writeMessageEnd()
7037 
    oprot.trans.flush()
7038 
 
4410 rajveer 7039 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7040 
    args = markOrdersAsShippedFromWarehouse_args()
7041 
    args.read(iprot)
7042 
    iprot.readMessageEnd()
7043 
    result = markOrdersAsShippedFromWarehouse_result()
7044 
    try:
4789 rajveer 7045 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7046 
    except TransactionServiceException, ex:
7047 
      result.ex = ex
7048 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7049 
    result.write(oprot)
7050 
    oprot.writeMessageEnd()
7051 
    oprot.trans.flush()
7052 
 
5676 rajveer 7053 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7054 
    args = markOrdersAsReturnedFromStore_args()
7055 
    args.read(iprot)
7056 
    iprot.readMessageEnd()
7057 
    result = markOrdersAsReturnedFromStore_result()
7058 
    try:
5713 rajveer 7059 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7060 
    except TransactionServiceException, ex:
7061 
      result.ex = ex
7062 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7063 
    result.write(oprot)
7064 
    oprot.writeMessageEnd()
7065 
    oprot.trans.flush()
7066 
 
3064 chandransh 7067 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7068 
    args = markOrdersAsPickedUp_args()
304 ashish 7069 
    args.read(iprot)
7070 
    iprot.readMessageEnd()
3064 chandransh 7071 
    result = markOrdersAsPickedUp_result()
7072 
    try:
4910 phani.kuma 7073 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7074 
    except TransactionServiceException, ex:
7075 
      result.ex = ex
7076 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7077 
    result.write(oprot)
7078 
    oprot.writeMessageEnd()
7079 
    oprot.trans.flush()
94 ashish 7080 
 
4910 phani.kuma 7081 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7082 
    args = getOrdersNotPickedUp_args()
7083 
    args.read(iprot)
7084 
    iprot.readMessageEnd()
7085 
    result = getOrdersNotPickedUp_result()
7086 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7087 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7088 
    result.write(oprot)
7089 
    oprot.writeMessageEnd()
7090 
    oprot.trans.flush()
7091 
 
3064 chandransh 7092 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7093 
    args = markOrdersAsDelivered_args()
304 ashish 7094 
    args.read(iprot)
7095 
    iprot.readMessageEnd()
3064 chandransh 7096 
    result = markOrdersAsDelivered_result()
7097 
    try:
7098 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7099 
    except TransactionServiceException, ex:
7100 
      result.ex = ex
7101 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7102 
    result.write(oprot)
7103 
    oprot.writeMessageEnd()
7104 
    oprot.trans.flush()
7105 
 
4910 phani.kuma 7106 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7107 
    args = markAsRTOrders_args()
1596 ankur.sing 7108 
    args.read(iprot)
7109 
    iprot.readMessageEnd()
4910 phani.kuma 7110 
    result = markAsRTOrders_result()
3064 chandransh 7111 
    try:
4910 phani.kuma 7112 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7113 
    except TransactionServiceException, ex:
7114 
      result.ex = ex
4910 phani.kuma 7115 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7116 
    result.write(oprot)
7117 
    oprot.writeMessageEnd()
7118 
    oprot.trans.flush()
304 ashish 7119 
 
4910 phani.kuma 7120 
  def process_getRTOrders(self, seqid, iprot, oprot):
7121 
    args = getRTOrders_args()
7122 
    args.read(iprot)
7123 
    iprot.readMessageEnd()
7124 
    result = getRTOrders_result()
7125 
    result.success = self._handler.getRTOrders(args.providerId)
7126 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7127 
    result.write(oprot)
7128 
    oprot.writeMessageEnd()
7129 
    oprot.trans.flush()
7130 
 
3064 chandransh 7131 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7132 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7133 
    args.read(iprot)
7134 
    iprot.readMessageEnd()
3064 chandransh 7135 
    result = updateNonDeliveryReason_result()
7136 
    try:
4910 phani.kuma 7137 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7138 
    except TransactionServiceException, ex:
7139 
      result.ex = ex
7140 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7141 
    result.write(oprot)
7142 
    oprot.writeMessageEnd()
7143 
    oprot.trans.flush()
1596 ankur.sing 7144 
 
4910 phani.kuma 7145 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7146 
    args = getNonDeliveredOrdersbyCourier_args()
7147 
    args.read(iprot)
7148 
    iprot.readMessageEnd()
7149 
    result = getNonDeliveredOrdersbyCourier_result()
7150 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7151 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7152 
    result.write(oprot)
7153 
    oprot.writeMessageEnd()
7154 
    oprot.trans.flush()
7155 
 
7156 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7157 
    args = markOrdersAsLocalConnected_args()
7158 
    args.read(iprot)
7159 
    iprot.readMessageEnd()
7160 
    result = markOrdersAsLocalConnected_result()
7161 
    try:
7162 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7163 
    except TransactionServiceException, ex:
7164 
      result.ex = ex
7165 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7166 
    result.write(oprot)
7167 
    oprot.writeMessageEnd()
7168 
    oprot.trans.flush()
7169 
 
7170 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7171 
    args = getOrdersNotLocalConnected_args()
7172 
    args.read(iprot)
7173 
    iprot.readMessageEnd()
7174 
    result = getOrdersNotLocalConnected_result()
7175 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7176 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7177 
    result.write(oprot)
7178 
    oprot.writeMessageEnd()
7179 
    oprot.trans.flush()
7180 
 
7181 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7182 
    args = markOrdersAsDestinationCityReached_args()
7183 
    args.read(iprot)
7184 
    iprot.readMessageEnd()
7185 
    result = markOrdersAsDestinationCityReached_result()
7186 
    try:
7187 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7188 
    except TransactionServiceException, ex:
7189 
      result.ex = ex
7190 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7191 
    result.write(oprot)
7192 
    oprot.writeMessageEnd()
7193 
    oprot.trans.flush()
7194 
 
7195 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7196 
    args = markOrdersAsFirstDeliveryAttempted_args()
7197 
    args.read(iprot)
7198 
    iprot.readMessageEnd()
7199 
    result = markOrdersAsFirstDeliveryAttempted_result()
7200 
    try:
7201 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7202 
    except TransactionServiceException, ex:
7203 
      result.ex = ex
7204 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7205 
    result.write(oprot)
7206 
    oprot.writeMessageEnd()
7207 
    oprot.trans.flush()
7208 
 
3064 chandransh 7209 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7210 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7211 
    args.read(iprot)
7212 
    iprot.readMessageEnd()
3064 chandransh 7213 
    result = getUndeliveredOrders_result()
7214 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7215 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
7219 
 
4783 phani.kuma 7220 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7221 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
7224 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7225 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7226 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7227 
    result.write(oprot)
7228 
    oprot.writeMessageEnd()
7229 
    oprot.trans.flush()
7230 
 
2536 chandransh 7231 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7232 
    args = toggleDOAFlag_args()
7233 
    args.read(iprot)
7234 
    iprot.readMessageEnd()
7235 
    result = toggleDOAFlag_result()
7236 
    try:
7237 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7238 
    except TransactionServiceException, ex:
7239 
      result.ex = ex
7240 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7241 
    result.write(oprot)
7242 
    oprot.writeMessageEnd()
7243 
    oprot.trans.flush()
1886 ankur.sing 7244 
 
4712 rajveer 7245 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7246 
    args = markOrderAsDelivered_args()
7247 
    args.read(iprot)
7248 
    iprot.readMessageEnd()
7249 
    result = markOrderAsDelivered_result()
7250 
    try:
7251 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7252 
    except TransactionServiceException, ex:
7253 
      result.ex = ex
7254 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7255 
    result.write(oprot)
7256 
    oprot.writeMessageEnd()
7257 
    oprot.trans.flush()
7258 
 
5553 rajveer 7259 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7260 
    args = markOrderAsReceivedAtStore_args()
7261 
    args.read(iprot)
7262 
    iprot.readMessageEnd()
7263 
    result = markOrderAsReceivedAtStore_result()
7264 
    try:
7265 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7266 
    except TransactionServiceException, ex:
7267 
      result.ex = ex
7268 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7269 
    result.write(oprot)
7270 
    oprot.writeMessageEnd()
7271 
    oprot.trans.flush()
7272 
 
4454 rajveer 7273 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7274 
    args = markOrderDoaRequestReceived_args()
7275 
    args.read(iprot)
7276 
    iprot.readMessageEnd()
7277 
    result = markOrderDoaRequestReceived_result()
7278 
    try:
7279 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7280 
    except TransactionServiceException, ex:
7281 
      result.ex = ex
7282 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7283 
    result.write(oprot)
7284 
    oprot.writeMessageEnd()
7285 
    oprot.trans.flush()
7286 
 
7287 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7288 
    args = markOrderDoaRequestAuthorized_args()
7289 
    args.read(iprot)
7290 
    iprot.readMessageEnd()
7291 
    result = markOrderDoaRequestAuthorized_result()
7292 
    try:
7293 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7294 
    except TransactionServiceException, ex:
7295 
      result.ex = ex
7296 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7297 
    result.write(oprot)
7298 
    oprot.writeMessageEnd()
7299 
    oprot.trans.flush()
7300 
 
4488 rajveer 7301 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7302 
    args = markOrderReturnRequestReceived_args()
7303 
    args.read(iprot)
7304 
    iprot.readMessageEnd()
7305 
    result = markOrderReturnRequestReceived_result()
7306 
    try:
7307 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7308 
    except TransactionServiceException, ex:
7309 
      result.ex = ex
7310 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
7315 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7316 
    args = markOrderReturnRequestAuthorized_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = markOrderReturnRequestAuthorized_result()
7320 
    try:
7321 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7322 
    except TransactionServiceException, ex:
7323 
      result.ex = ex
7324 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
2536 chandransh 7329 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7330 
    args = requestPickupNumber_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = requestPickupNumber_result()
7334 
    try:
4579 rajveer 7335 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7336 
    except TransactionServiceException, ex:
7337 
      result.ex = ex
7338 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7339 
    result.write(oprot)
7340 
    oprot.writeMessageEnd()
7341 
    oprot.trans.flush()
7342 
 
7343 
  def process_authorizePickup(self, seqid, iprot, oprot):
7344 
    args = authorizePickup_args()
7345 
    args.read(iprot)
7346 
    iprot.readMessageEnd()
7347 
    result = authorizePickup_result()
7348 
    try:
4602 rajveer 7349 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7350 
    except TransactionServiceException, ex:
7351 
      result.ex = ex
7352 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
7356 
 
2764 chandransh 7357 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7358 
    args = markDoasAsPickedUp_args()
7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
7361 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7362 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7363 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
7367 
 
4910 phani.kuma 7368 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7369 
    args = getDoasNotPickedUp_args()
7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
7372 
    result = getDoasNotPickedUp_result()
7373 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7374 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7375 
    result.write(oprot)
7376 
    oprot.writeMessageEnd()
7377 
    oprot.trans.flush()
7378 
 
4741 phani.kuma 7379 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7380 
    args = markReturnOrdersAsPickedUp_args()
7381 
    args.read(iprot)
7382 
    iprot.readMessageEnd()
7383 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7384 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7385 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7386 
    result.write(oprot)
7387 
    oprot.writeMessageEnd()
7388 
    oprot.trans.flush()
7389 
 
4910 phani.kuma 7390 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7391 
    args = getReturnOrdersNotPickedUp_args()
7392 
    args.read(iprot)
7393 
    iprot.readMessageEnd()
7394 
    result = getReturnOrdersNotPickedUp_result()
7395 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7396 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7397 
    result.write(oprot)
7398 
    oprot.writeMessageEnd()
7399 
    oprot.trans.flush()
7400 
 
2616 chandransh 7401 
  def process_receiveReturn(self, seqid, iprot, oprot):
7402 
    args = receiveReturn_args()
2591 chandransh 7403 
    args.read(iprot)
7404 
    iprot.readMessageEnd()
2616 chandransh 7405 
    result = receiveReturn_result()
2591 chandransh 7406 
    try:
4479 rajveer 7407 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7408 
    except TransactionServiceException, ex:
7409 
      result.ex = ex
2616 chandransh 7410 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7411 
    result.write(oprot)
7412 
    oprot.writeMessageEnd()
7413 
    oprot.trans.flush()
2536 chandransh 7414 
 
2591 chandransh 7415 
  def process_validateDoa(self, seqid, iprot, oprot):
7416 
    args = validateDoa_args()
7417 
    args.read(iprot)
7418 
    iprot.readMessageEnd()
7419 
    result = validateDoa_result()
7420 
    try:
7421 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7422 
    except TransactionServiceException, ex:
7423 
      result.ex = ex
7424 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7425 
    result.write(oprot)
7426 
    oprot.writeMessageEnd()
7427 
    oprot.trans.flush()
7428 
 
4495 rajveer 7429 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7430 
    args = validateReturnProduct_args()
7431 
    args.read(iprot)
7432 
    iprot.readMessageEnd()
7433 
    result = validateReturnProduct_result()
7434 
    try:
7435 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7436 
    except TransactionServiceException, ex:
7437 
      result.ex = ex
7438 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7439 
    result.write(oprot)
7440 
    oprot.writeMessageEnd()
7441 
    oprot.trans.flush()
7442 
 
2616 chandransh 7443 
  def process_reshipOrder(self, seqid, iprot, oprot):
7444 
    args = reshipOrder_args()
7445 
    args.read(iprot)
7446 
    iprot.readMessageEnd()
7447 
    result = reshipOrder_result()
7448 
    try:
7449 
      result.success = self._handler.reshipOrder(args.orderId)
7450 
    except TransactionServiceException, ex:
7451 
      result.ex = ex
7452 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
2591 chandransh 7456 
 
2616 chandransh 7457 
  def process_refundOrder(self, seqid, iprot, oprot):
7458 
    args = refundOrder_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = refundOrder_result()
7462 
    try:
3226 chandransh 7463 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7464 
    except TransactionServiceException, ex:
7465 
      result.ex = ex
7466 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7467 
    result.write(oprot)
7468 
    oprot.writeMessageEnd()
7469 
    oprot.trans.flush()
7470 
 
2690 chandransh 7471 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7472 
    args = getReturnOrders_args()
7473 
    args.read(iprot)
7474 
    iprot.readMessageEnd()
7475 
    result = getReturnOrders_result()
7476 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7477 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7478 
    result.write(oprot)
7479 
    oprot.writeMessageEnd()
7480 
    oprot.trans.flush()
2616 chandransh 7481 
 
5481 phani.kuma 7482 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7483 
    args = getAllReturnOrders_args()
7484 
    args.read(iprot)
7485 
    iprot.readMessageEnd()
7486 
    result = getAllReturnOrders_result()
7487 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7488 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7489 
    result.write(oprot)
7490 
    oprot.writeMessageEnd()
7491 
    oprot.trans.flush()
7492 
 
2700 chandransh 7493 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7494 
    args = getReturnOrder_args()
7495 
    args.read(iprot)
7496 
    iprot.readMessageEnd()
7497 
    result = getReturnOrder_result()
7498 
    try:
7499 
      result.success = self._handler.getReturnOrder(args.id)
7500 
    except TransactionServiceException, ex:
7501 
      result.ex = ex
7502 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7503 
    result.write(oprot)
7504 
    oprot.writeMessageEnd()
7505 
    oprot.trans.flush()
7506 
 
2690 chandransh 7507 
  def process_processReturn(self, seqid, iprot, oprot):
7508 
    args = processReturn_args()
7509 
    args.read(iprot)
7510 
    iprot.readMessageEnd()
7511 
    result = processReturn_result()
7512 
    try:
7513 
      self._handler.processReturn(args.returnOrderId)
7514 
    except TransactionServiceException, ex:
7515 
      result.ex = ex
7516 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
7520 
 
3451 chandransh 7521 
  def process_updateWeight(self, seqid, iprot, oprot):
7522 
    args = updateWeight_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = updateWeight_result()
7526 
    try:
7527 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
7530 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
2819 chandransh 7534 
 
3469 chandransh 7535 
  def process_changeItem(self, seqid, iprot, oprot):
7536 
    args = changeItem_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = changeItem_result()
7540 
    try:
7541 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
3451 chandransh 7548 
 
3469 chandransh 7549 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7550 
    args = shiftToWarehouse_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = shiftToWarehouse_result()
7554 
    try:
7555 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
3553 chandransh 7563 
  def process_addDelayReason(self, seqid, iprot, oprot):
7564 
    args = addDelayReason_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = addDelayReason_result()
7568 
    try:
4647 rajveer 7569 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
3469 chandransh 7576 
 
3956 chandransh 7577 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7578 
    args = reconcileCodCollection_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = reconcileCodCollection_result()
7582 
    try:
7583 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7584 
    except TransactionServiceException, ex:
7585 
      result.ex = ex
7586 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
3553 chandransh 7590 
 
4008 mandeep.dh 7591 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7592 
    args = getTransactionsRequiringExtraProcessing_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = getTransactionsRequiringExtraProcessing_result()
7596 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7597 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
3956 chandransh 7601 
 
4008 mandeep.dh 7602 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7603 
    args = markTransactionAsProcessed_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = markTransactionAsProcessed_result()
7607 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7608 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7609 
    result.write(oprot)
7610 
    oprot.writeMessageEnd()
7611 
    oprot.trans.flush()
7612 
 
4018 chandransh 7613 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7614 
    args = getItemWiseRiskyOrdersCount_args()
7615 
    args.read(iprot)
7616 
    iprot.readMessageEnd()
7617 
    result = getItemWiseRiskyOrdersCount_result()
7618 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7619 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7620 
    result.write(oprot)
7621 
    oprot.writeMessageEnd()
7622 
    oprot.trans.flush()
4008 mandeep.dh 7623 
 
4295 varun.gupt 7624 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7625 
    args = getOrdersForItemIds_args()
7626 
    args.read(iprot)
7627 
    iprot.readMessageEnd()
7628 
    result = getOrdersForItemIds_result()
7629 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7630 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7631 
    result.write(oprot)
7632 
    oprot.writeMessageEnd()
7633 
    oprot.trans.flush()
7634 
 
4247 rajveer 7635 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7636 
    args = markOrderCancellationRequestReceived_args()
7637 
    args.read(iprot)
7638 
    iprot.readMessageEnd()
7639 
    result = markOrderCancellationRequestReceived_result()
7640 
    try:
7641 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7642 
    except TransactionServiceException, ex:
7643 
      result.ex = ex
7644 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7645 
    result.write(oprot)
7646 
    oprot.writeMessageEnd()
7647 
    oprot.trans.flush()
4018 chandransh 7648 
 
4247 rajveer 7649 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7650 
    args = markOrderCancellationRequestConfirmed_args()
7651 
    args.read(iprot)
7652 
    iprot.readMessageEnd()
7653 
    result = markOrderCancellationRequestConfirmed_result()
7654 
    try:
7655 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7656 
    except TransactionServiceException, ex:
7657 
      result.ex = ex
7658 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7659 
    result.write(oprot)
7660 
    oprot.writeMessageEnd()
7661 
    oprot.trans.flush()
7662 
 
7663 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7664 
    args = markOrderCancellationRequestDenied_args()
7665 
    args.read(iprot)
7666 
    iprot.readMessageEnd()
7667 
    result = markOrderCancellationRequestDenied_result()
7668 
    try:
7669 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7670 
    except TransactionServiceException, ex:
7671 
      result.ex = ex
7672 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7673 
    result.write(oprot)
7674 
    oprot.writeMessageEnd()
7675 
    oprot.trans.flush()
7676 
 
4258 rajveer 7677 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7678 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7679 
    args.read(iprot)
7680 
    iprot.readMessageEnd()
4258 rajveer 7681 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7682 
    try:
4258 rajveer 7683 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7684 
    except TransactionServiceException, ex:
7685 
      result.ex = ex
4258 rajveer 7686 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7687 
    result.write(oprot)
7688 
    oprot.writeMessageEnd()
7689 
    oprot.trans.flush()
7690 
 
4259 anupam.sin 7691 
  def process_refundTransaction(self, seqid, iprot, oprot):
7692 
    args = refundTransaction_args()
7693 
    args.read(iprot)
7694 
    iprot.readMessageEnd()
7695 
    result = refundTransaction_result()
7696 
    try:
7697 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7698 
    except TransactionServiceException, ex:
7699 
      result.ex = ex
7700 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
4247 rajveer 7704 
 
4324 mandeep.dh 7705 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7706 
    args = updateShipmentAddress_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = updateShipmentAddress_result()
7710 
    try:
7711 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7712 
    except TransactionServiceException, ex:
7713 
      result.ex = ex
7714 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
4285 rajveer 7719 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7720 
    args = acceptOrdersForItemId_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = acceptOrdersForItemId_result()
7724 
    try:
7725 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7726 
    except TransactionServiceException, ex:
7727 
      result.ex = ex
7728 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7729 
    result.write(oprot)
7730 
    oprot.writeMessageEnd()
7731 
    oprot.trans.flush()
4259 anupam.sin 7732 
 
4303 rajveer 7733 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7734 
    args = markOrdersAsPORaised_args()
7735 
    args.read(iprot)
7736 
    iprot.readMessageEnd()
7737 
    result = markOrdersAsPORaised_result()
7738 
    try:
4369 rajveer 7739 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7740 
    except TransactionServiceException, ex:
7741 
      result.ex = ex
7742 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
4285 rajveer 7746 
 
4303 rajveer 7747 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7748 
    args = markOrdersAsReversalInitiated_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = markOrdersAsReversalInitiated_result()
7752 
    try:
4369 rajveer 7753 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7754 
    except TransactionServiceException, ex:
7755 
      result.ex = ex
7756 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7757 
    result.write(oprot)
7758 
    oprot.writeMessageEnd()
7759 
    oprot.trans.flush()
7760 
 
7761 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7762 
    args = markOrdersAsNotAvailabke_args()
7763 
    args.read(iprot)
7764 
    iprot.readMessageEnd()
7765 
    result = markOrdersAsNotAvailabke_result()
7766 
    try:
4369 rajveer 7767 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7768 
    except TransactionServiceException, ex:
7769 
      result.ex = ex
7770 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
7774 
 
4369 rajveer 7775 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7776 
    args = markOrdersAsTimeout_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = markOrdersAsTimeout_result()
7780 
    try:
7781 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7782 
    except TransactionServiceException, ex:
7783 
      result.ex = ex
7784 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
4303 rajveer 7788 
 
4662 rajveer 7789 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7790 
    args = markOrderAsLostInTransit_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = markOrderAsLostInTransit_result()
7794 
    try:
7795 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7796 
    except TransactionServiceException, ex:
7797 
      result.ex = ex
7798 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7799 
    result.write(oprot)
7800 
    oprot.writeMessageEnd()
7801 
    oprot.trans.flush()
7802 
 
4386 anupam.sin 7803 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7804 
    args = getOrderForAwb_args()
7805 
    args.read(iprot)
7806 
    iprot.readMessageEnd()
7807 
    result = getOrderForAwb_result()
7808 
    try:
7809 
      result.success = self._handler.getOrderForAwb(args.awb)
7810 
    except TransactionServiceException, ex:
7811 
      result.ex = ex
7812 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7813 
    result.write(oprot)
7814 
    oprot.writeMessageEnd()
7815 
    oprot.trans.flush()
4369 rajveer 7816 
 
4506 phani.kuma 7817 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7818 
    args = getOrdersForProviderForStatus_args()
7819 
    args.read(iprot)
7820 
    iprot.readMessageEnd()
7821 
    result = getOrdersForProviderForStatus_result()
7822 
    try:
4910 phani.kuma 7823 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7824 
    except TransactionServiceException, ex:
7825 
      result.ex = ex
7826 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7827 
    result.write(oprot)
7828 
    oprot.writeMessageEnd()
7829 
    oprot.trans.flush()
4386 anupam.sin 7830 
 
4600 varun.gupt 7831 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7832 
    args = getBilledOrdersForVendor_args()
7833 
    args.read(iprot)
7834 
    iprot.readMessageEnd()
7835 
    result = getBilledOrdersForVendor_result()
7836 
    try:
7837 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7838 
    except TransactionServiceException, ex:
7839 
      result.ex = ex
7840 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
4506 phani.kuma 7844 
 
4607 rajveer 7845 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7846 
    args = getSlippedSippingDateOrders_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = getSlippedSippingDateOrders_result()
7850 
    try:
7851 
      result.success = self._handler.getSlippedSippingDateOrders()
7852 
    except TransactionServiceException, ex:
7853 
      result.ex = ex
7854 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
4709 rajveer 7859 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7860 
    args = getCancelledOrders_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = getCancelledOrders_result()
7864 
    try:
7865 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7866 
    except TransactionServiceException, ex:
7867 
      result.ex = ex
7868 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
4600 varun.gupt 7873 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7874 
    args = saveBluedartSettlements_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = saveBluedartSettlements_result()
7878 
    try:
7879 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7880 
    except TransactionServiceException, ex:
7881 
      result.ex = ex
7882 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
7887 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7888 
    args = savePaymentSettlements_args()
7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
7891 
    result = savePaymentSettlements_result()
7892 
    try:
4905 varun.gupt 7893 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
7896 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
7900 
 
7901 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7902 
    args = saveEBSSettlementSummary_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = saveEBSSettlementSummary_result()
7906 
    try:
7907 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
7914 
 
5386 phani.kuma 7915 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7916 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
5386 phani.kuma 7919 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7920 
    try:
5386 phani.kuma 7921 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7922 
    except TransactionServiceException, ex:
7923 
      result.ex = ex
5386 phani.kuma 7924 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
5386 phani.kuma 7929 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7930 
    args = getSettlementForCod_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = getSettlementForCod_result()
7934 
    try:
7935 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
7942 
 
4600 varun.gupt 7943 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7944 
    args = getEBSSettlementSummaries_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = getEBSSettlementSummaries_result()
7948 
    try:
7949 
      result.success = self._handler.getEBSSettlementSummaries()
7950 
    except TransactionServiceException, ex:
7951 
      result.ex = ex
7952 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7953 
    result.write(oprot)
7954 
    oprot.writeMessageEnd()
7955 
    oprot.trans.flush()
7956 
 
7957 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7958 
    args = markEBSSettlementUploaded_args()
7959 
    args.read(iprot)
7960 
    iprot.readMessageEnd()
7961 
    result = markEBSSettlementUploaded_result()
7962 
    try:
7963 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7964 
    except TransactionServiceException, ex:
7965 
      result.ex = ex
7966 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7967 
    result.write(oprot)
7968 
    oprot.writeMessageEnd()
7969 
    oprot.trans.flush()
7970 
 
7971 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7972 
    args = getEBSSettlementDate_args()
7973 
    args.read(iprot)
7974 
    iprot.readMessageEnd()
7975 
    result = getEBSSettlementDate_result()
7976 
    try:
7977 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7978 
    except TransactionServiceException, ex:
7979 
      result.ex = ex
7980 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7981 
    result.write(oprot)
7982 
    oprot.writeMessageEnd()
7983 
    oprot.trans.flush()
7984 
 
4715 varun.gupt 7985 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7986 
    args = getSettlementsByDate_args()
7987 
    args.read(iprot)
7988 
    iprot.readMessageEnd()
7989 
    result = getSettlementsByDate_result()
7990 
    try:
7991 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7992 
    except TransactionServiceException, ex:
7993 
      result.ex = ex
7994 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7995 
    result.write(oprot)
7996 
    oprot.writeMessageEnd()
7997 
    oprot.trans.flush()
4600 varun.gupt 7998 
 
4715 varun.gupt 7999 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8000 
    args = getReshippedOrderIds_args()
8001 
    args.read(iprot)
8002 
    iprot.readMessageEnd()
8003 
    result = getReshippedOrderIds_result()
8004 
    try:
8005 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8006 
    except TransactionServiceException, ex:
8007 
      result.ex = ex
8008 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8009 
    result.write(oprot)
8010 
    oprot.writeMessageEnd()
8011 
    oprot.trans.flush()
8012 
 
5481 phani.kuma 8013 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8014 
    args = getBilledOrders_args()
4875 varun.gupt 8015 
    args.read(iprot)
8016 
    iprot.readMessageEnd()
5481 phani.kuma 8017 
    result = getBilledOrders_result()
4875 varun.gupt 8018 
    try:
5481 phani.kuma 8019 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8020 
    except TransactionServiceException, ex:
8021 
      result.ex = ex
5481 phani.kuma 8022 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8023 
    result.write(oprot)
8024 
    oprot.writeMessageEnd()
8025 
    oprot.trans.flush()
4757 mandeep.dh 8026 
 
5031 varun.gupt 8027 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8028 
    args = getStatusDistributionOfOrders_args()
8029 
    args.read(iprot)
8030 
    iprot.readMessageEnd()
8031 
    result = getStatusDistributionOfOrders_result()
8032 
    try:
8033 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8034 
    except TransactionServiceException, ex:
8035 
      result.ex = ex
8036 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8037 
    result.write(oprot)
8038 
    oprot.writeMessageEnd()
8039 
    oprot.trans.flush()
4875 varun.gupt 8040 
 
5067 varun.gupt 8041 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8042 
    args = getOrderIdsForStatus_args()
8043 
    args.read(iprot)
8044 
    iprot.readMessageEnd()
8045 
    result = getOrderIdsForStatus_result()
8046 
    try:
8047 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8048 
    except TransactionServiceException, ex:
8049 
      result.ex = ex
8050 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8051 
    result.write(oprot)
8052 
    oprot.writeMessageEnd()
8053 
    oprot.trans.flush()
5031 varun.gupt 8054 
 
5348 anupam.sin 8055 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8056 
    args = updateCODAgent_args()
8057 
    args.read(iprot)
8058 
    iprot.readMessageEnd()
8059 
    result = updateCODAgent_result()
8060 
    try:
8061 
      self._handler.updateCODAgent(args.agent, args.orderId)
8062 
    except TransactionServiceException, ex:
8063 
      result.ex = ex
8064 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8065 
    result.write(oprot)
8066 
    oprot.writeMessageEnd()
8067 
    oprot.trans.flush()
8068 
 
5099 varun.gupt 8069 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8070 
    args = updateOrderAsPaidToVendor_args()
8071 
    args.read(iprot)
8072 
    iprot.readMessageEnd()
8073 
    result = updateOrderAsPaidToVendor_result()
8074 
    try:
8075 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8076 
    except TransactionServiceException, ex:
8077 
      result.ex = ex
8078 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8079 
    result.write(oprot)
8080 
    oprot.writeMessageEnd()
8081 
    oprot.trans.flush()
5067 varun.gupt 8082 
 
5386 phani.kuma 8083 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8084 
    args = updateOrderOnlyAsPaidToVendor_args()
8085 
    args.read(iprot)
8086 
    iprot.readMessageEnd()
8087 
    result = updateOrderOnlyAsPaidToVendor_result()
8088 
    try:
8089 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8090 
    except TransactionServiceException, ex:
8091 
      result.ex = ex
8092 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8093 
    result.write(oprot)
8094 
    oprot.writeMessageEnd()
8095 
    oprot.trans.flush()
8096 
 
5208 varun.gupt 8097 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8098 
    args = getRefundedOrdersMarkedPaid_args()
8099 
    args.read(iprot)
8100 
    iprot.readMessageEnd()
8101 
    result = getRefundedOrdersMarkedPaid_result()
8102 
    try:
8103 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8104 
    except TransactionServiceException, ex:
8105 
      result.ex = ex
8106 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8107 
    result.write(oprot)
8108 
    oprot.writeMessageEnd()
8109 
    oprot.trans.flush()
5099 varun.gupt 8110 
 
5447 anupam.sin 8111 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8112 
    args = getAllVerificationAgents_args()
8113 
    args.read(iprot)
8114 
    iprot.readMessageEnd()
8115 
    result = getAllVerificationAgents_result()
8116 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8117 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8118 
    result.write(oprot)
8119 
    oprot.writeMessageEnd()
8120 
    oprot.trans.flush()
5208 varun.gupt 8121 
 
5527 anupam.sin 8122 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8123 
    args = getAllAttributesForOrderId_args()
8124 
    args.read(iprot)
8125 
    iprot.readMessageEnd()
8126 
    result = getAllAttributesForOrderId_result()
8127 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8128 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8129 
    result.write(oprot)
8130 
    oprot.writeMessageEnd()
8131 
    oprot.trans.flush()
5447 anupam.sin 8132 
 
5676 rajveer 8133 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8134 
    args = setOrderAttributes_args()
8135 
    args.read(iprot)
8136 
    iprot.readMessageEnd()
8137 
    result = setOrderAttributes_result()
8138 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8139 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8140 
    result.write(oprot)
8141 
    oprot.writeMessageEnd()
8142 
    oprot.trans.flush()
8143 
 
5527 anupam.sin 8144 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8145 
    args = setOrderAttributeForTransaction_args()
8146 
    args.read(iprot)
8147 
    iprot.readMessageEnd()
8148 
    result = setOrderAttributeForTransaction_result()
8149 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8150 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8151 
    result.write(oprot)
8152 
    oprot.writeMessageEnd()
8153 
    oprot.trans.flush()
8154 
 
5553 rajveer 8155 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8156 
    args = getReceivePendingOrders_args()
8157 
    args.read(iprot)
8158 
    iprot.readMessageEnd()
8159 
    result = getReceivePendingOrders_result()
8160 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8161 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8162 
    result.write(oprot)
8163 
    oprot.writeMessageEnd()
8164 
    oprot.trans.flush()
5527 anupam.sin 8165 
 
5553 rajveer 8166 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8167 
    args = getReceivedAtStoreOrders_args()
8168 
    args.read(iprot)
8169 
    iprot.readMessageEnd()
8170 
    result = getReceivedAtStoreOrders_result()
8171 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8172 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8173 
    result.write(oprot)
8174 
    oprot.writeMessageEnd()
8175 
    oprot.trans.flush()
8176 
 
5713 rajveer 8177 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8178 
    args = getOrdersCollectionAtStore_args()
8179 
    args.read(iprot)
8180 
    iprot.readMessageEnd()
8181 
    result = getOrdersCollectionAtStore_result()
8182 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8183 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8184 
    result.write(oprot)
8185 
    oprot.writeMessageEnd()
8186 
    oprot.trans.flush()
8187 
 
5833 rajveer 8188 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8189 
    args = getOrderAttributeValue_args()
8190 
    args.read(iprot)
8191 
    iprot.readMessageEnd()
8192 
    result = getOrderAttributeValue_result()
8193 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8194 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8195 
    result.write(oprot)
8196 
    oprot.writeMessageEnd()
8197 
    oprot.trans.flush()
8198 
 
6019 rajveer 8199 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8200 
    args = changeJacketNumber_args()
8201 
    args.read(iprot)
8202 
    iprot.readMessageEnd()
8203 
    result = changeJacketNumber_result()
8204 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8205 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8206 
    result.write(oprot)
8207 
    oprot.writeMessageEnd()
8208 
    oprot.trans.flush()
8209 
 
8210 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8211 
    args = markOrderAsRtoInTransit_args()
8212 
    args.read(iprot)
8213 
    iprot.readMessageEnd()
8214 
    result = markOrderAsRtoInTransit_result()
8215 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8216 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8217 
    result.write(oprot)
8218 
    oprot.writeMessageEnd()
8219 
    oprot.trans.flush()
8220 
 
5593 mandeep.dh 8221 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8222 
    args = acceptOrderForItem_args()
8223 
    args.read(iprot)
8224 
    iprot.readMessageEnd()
8225 
    result = acceptOrderForItem_result()
8226 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8227 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8228 
    result.write(oprot)
8229 
    oprot.writeMessageEnd()
8230 
    oprot.trans.flush()
5553 rajveer 8231 
 
6000 mandeep.dh 8232 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8233 
    args = createRechargeOrder_args()
8234 
    args.read(iprot)
8235 
    iprot.readMessageEnd()
8236 
    result = createRechargeOrder_result()
8237 
    try:
8238 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8239 
    except TransactionServiceException, ex:
8240 
      result.ex = ex
8241 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8242 
    result.write(oprot)
8243 
    oprot.writeMessageEnd()
8244 
    oprot.trans.flush()
5593 mandeep.dh 8245 
 
6031 rajveer 8246 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8247 
    args = getRechargeOrder_args()
8248 
    args.read(iprot)
8249 
    iprot.readMessageEnd()
8250 
    result = getRechargeOrder_result()
8251 
    try:
8252 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8253 
    except TransactionServiceException, ex:
8254 
      result.ex = ex
8255 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8256 
    result.write(oprot)
8257 
    oprot.writeMessageEnd()
8258 
    oprot.trans.flush()
8259 
 
8260 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8261 
    args = getRechargeOrders_args()
8262 
    args.read(iprot)
8263 
    iprot.readMessageEnd()
8264 
    result = getRechargeOrders_result()
8265 
    result.success = self._handler.getRechargeOrders(args.userId)
8266 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8267 
    result.write(oprot)
8268 
    oprot.writeMessageEnd()
8269 
    oprot.trans.flush()
8270 
 
6000 mandeep.dh 8271 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8272 
    args = updateRechargeOrderStatus_args()
8273 
    args.read(iprot)
8274 
    iprot.readMessageEnd()
8275 
    result = updateRechargeOrderStatus_result()
8276 
    try:
6031 rajveer 8277 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8278 
    except TransactionServiceException, ex:
8279 
      result.ex = ex
8280 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8281 
    result.write(oprot)
8282 
    oprot.writeMessageEnd()
8283 
    oprot.trans.flush()
8284 
 
8285 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8286 
    args = activateRechargeTxn_args()
8287 
    args.read(iprot)
8288 
    iprot.readMessageEnd()
8289 
    result = activateRechargeTxn_result()
8290 
    try:
6031 rajveer 8291 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8292 
    except TransactionServiceException, ex:
8293 
      result.ex = ex
8294 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8295 
    result.write(oprot)
8296 
    oprot.writeMessageEnd()
8297 
    oprot.trans.flush()
8298 
 
6031 rajveer 8299 
  def process_getUserWallet(self, seqid, iprot, oprot):
8300 
    args = getUserWallet_args()
6000 mandeep.dh 8301 
    args.read(iprot)
8302 
    iprot.readMessageEnd()
6031 rajveer 8303 
    result = getUserWallet_result()
8304 
    result.success = self._handler.getUserWallet(args.userId)
8305 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8306 
    result.write(oprot)
8307 
    oprot.writeMessageEnd()
8308 
    oprot.trans.flush()
8309 
 
6031 rajveer 8310 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8311 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8312 
    args.read(iprot)
8313 
    iprot.readMessageEnd()
6031 rajveer 8314 
    result = getUserWalletHistory_result()
8315 
    result.success = self._handler.getUserWalletHistory(args.userId)
8316 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8317 
    result.write(oprot)
8318 
    oprot.writeMessageEnd()
8319 
    oprot.trans.flush()
8320 
 
6050 anupam.sin 8321 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8322 
    args = getRechargeOrdersForTransaction_args()
8323 
    args.read(iprot)
8324 
    iprot.readMessageEnd()
8325 
    result = getRechargeOrdersForTransaction_result()
8326 
    try:
8327 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8328 
    except TransactionServiceException, ex:
8329 
      result.ex = ex
8330 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8331 
    result.write(oprot)
8332 
    oprot.writeMessageEnd()
8333 
    oprot.trans.flush()
8334 
 
6048 rajveer 8335 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8336 
    args = getServiceProviders_args()
8337 
    args.read(iprot)
8338 
    iprot.readMessageEnd()
8339 
    result = getServiceProviders_result()
6206 rajveer 8340 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8341 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8342 
    result.write(oprot)
8343 
    oprot.writeMessageEnd()
8344 
    oprot.trans.flush()
6000 mandeep.dh 8345 
 
6048 rajveer 8346 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8347 
    args = getServiceProviderForDevice_args()
8348 
    args.read(iprot)
8349 
    iprot.readMessageEnd()
8350 
    result = getServiceProviderForDevice_result()
6049 rajveer 8351 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8352 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8353 
    result.write(oprot)
8354 
    oprot.writeMessageEnd()
8355 
    oprot.trans.flush()
8356 
 
6269 rajveer 8357 
  def process_validateRecharge(self, seqid, iprot, oprot):
8358 
    args = validateRecharge_args()
8359 
    args.read(iprot)
8360 
    iprot.readMessageEnd()
8361 
    result = validateRecharge_result()
6307 anupam.sin 8362 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.circleCode, args.userSelectedProviderId)
6269 rajveer 8363 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8364 
    result.write(oprot)
8365 
    oprot.writeMessageEnd()
8366 
    oprot.trans.flush()
8367 
 
6094 rajveer 8368 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8369 
    args = getRechargeOrdersForDevice_args()
8370 
    args.read(iprot)
8371 
    iprot.readMessageEnd()
8372 
    result = getRechargeOrdersForDevice_result()
8373 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8374 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8375 
    result.write(oprot)
8376 
    oprot.writeMessageEnd()
8377 
    oprot.trans.flush()
6048 rajveer 8378 
 
6094 rajveer 8379 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8380 
    args = addAmountToWallet_args()
8381 
    args.read(iprot)
8382 
    iprot.readMessageEnd()
8383 
    result = addAmountToWallet_result()
8384 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8385 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8386 
    result.write(oprot)
8387 
    oprot.writeMessageEnd()
8388 
    oprot.trans.flush()
8389 
 
6188 rajveer 8390 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8391 
    args = getRechargeStatistics_args()
8392 
    args.read(iprot)
8393 
    iprot.readMessageEnd()
8394 
    result = getRechargeStatistics_result()
8395 
    result.success = self._handler.getRechargeStatistics()
8396 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8397 
    result.write(oprot)
8398 
    oprot.writeMessageEnd()
8399 
    oprot.trans.flush()
8400 
 
6154 rajveer 8401 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8402 
    args = getRechargeOrdersForStatus_args()
8403 
    args.read(iprot)
8404 
    iprot.readMessageEnd()
8405 
    result = getRechargeOrdersForStatus_result()
8406 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8407 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8408 
    result.write(oprot)
8409 
    oprot.writeMessageEnd()
8410 
    oprot.trans.flush()
6094 rajveer 8411 
 
6159 rajveer 8412 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8413 
    args = getPlansForOperator_args()
8414 
    args.read(iprot)
8415 
    iprot.readMessageEnd()
8416 
    result = getPlansForOperator_result()
8417 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8418 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8419 
    result.write(oprot)
8420 
    oprot.writeMessageEnd()
8421 
    oprot.trans.flush()
6154 rajveer 8422 
 
6289 anupam.sin 8423 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8424 
    args = getRechargeDenominations_args()
8425 
    args.read(iprot)
8426 
    iprot.readMessageEnd()
8427 
    result = getRechargeDenominations_result()
8428 
    try:
6307 anupam.sin 8429 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8430 
    except TransactionServiceException, ex:
8431 
      result.ex = ex
8432 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8433 
    result.write(oprot)
8434 
    oprot.writeMessageEnd()
8435 
    oprot.trans.flush()
6159 rajveer 8436 
 
6289 anupam.sin 8437 
 
94 ashish 8438 
# HELPER FUNCTIONS AND STRUCTURES
8439 
 
8440 
class createTransaction_args:
8441 
  """
8442 
  Attributes:
8443 
   - transaction
8444 
  """
8445 
 
8446 
  thrift_spec = (
8447 
    None, # 0
8448 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8449 
  )
8450 
 
8451 
  def __init__(self, transaction=None,):
8452 
    self.transaction = transaction
8453 
 
8454 
  def read(self, iprot):
8455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8457 
      return
8458 
    iprot.readStructBegin()
8459 
    while True:
8460 
      (fname, ftype, fid) = iprot.readFieldBegin()
8461 
      if ftype == TType.STOP:
8462 
        break
8463 
      if fid == 1:
8464 
        if ftype == TType.STRUCT:
8465 
          self.transaction = Transaction()
8466 
          self.transaction.read(iprot)
8467 
        else:
8468 
          iprot.skip(ftype)
8469 
      else:
8470 
        iprot.skip(ftype)
8471 
      iprot.readFieldEnd()
8472 
    iprot.readStructEnd()
8473 
 
8474 
  def write(self, oprot):
8475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8477 
      return
8478 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8479 
    if self.transaction is not None:
94 ashish 8480 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8481 
      self.transaction.write(oprot)
8482 
      oprot.writeFieldEnd()
8483 
    oprot.writeFieldStop()
8484 
    oprot.writeStructEnd()
8485 
 
3431 rajveer 8486 
  def validate(self):
8487 
    return
8488 
 
8489 
 
94 ashish 8490 
  def __repr__(self):
8491 
    L = ['%s=%r' % (key, value)
8492 
      for key, value in self.__dict__.iteritems()]
8493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8494 
 
8495 
  def __eq__(self, other):
8496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8497 
 
8498 
  def __ne__(self, other):
8499 
    return not (self == other)
8500 
 
8501 
class createTransaction_result:
8502 
  """
8503 
  Attributes:
132 ashish 8504 
   - success
94 ashish 8505 
   - ex
8506 
  """
8507 
 
8508 
  thrift_spec = (
132 ashish 8509 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8510 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8511 
  )
8512 
 
132 ashish 8513 
  def __init__(self, success=None, ex=None,):
8514 
    self.success = success
94 ashish 8515 
    self.ex = ex
8516 
 
8517 
  def read(self, iprot):
8518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8520 
      return
8521 
    iprot.readStructBegin()
8522 
    while True:
8523 
      (fname, ftype, fid) = iprot.readFieldBegin()
8524 
      if ftype == TType.STOP:
8525 
        break
132 ashish 8526 
      if fid == 0:
8527 
        if ftype == TType.I64:
8528 
          self.success = iprot.readI64();
8529 
        else:
8530 
          iprot.skip(ftype)
8531 
      elif fid == 1:
94 ashish 8532 
        if ftype == TType.STRUCT:
8533 
          self.ex = TransactionServiceException()
8534 
          self.ex.read(iprot)
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      else:
8538 
        iprot.skip(ftype)
8539 
      iprot.readFieldEnd()
8540 
    iprot.readStructEnd()
8541 
 
8542 
  def write(self, oprot):
8543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8545 
      return
8546 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8547 
    if self.success is not None:
132 ashish 8548 
      oprot.writeFieldBegin('success', TType.I64, 0)
8549 
      oprot.writeI64(self.success)
8550 
      oprot.writeFieldEnd()
3431 rajveer 8551 
    if self.ex is not None:
94 ashish 8552 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8553 
      self.ex.write(oprot)
8554 
      oprot.writeFieldEnd()
8555 
    oprot.writeFieldStop()
8556 
    oprot.writeStructEnd()
8557 
 
3431 rajveer 8558 
  def validate(self):
8559 
    return
8560 
 
8561 
 
94 ashish 8562 
  def __repr__(self):
8563 
    L = ['%s=%r' % (key, value)
8564 
      for key, value in self.__dict__.iteritems()]
8565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8566 
 
8567 
  def __eq__(self, other):
8568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8569 
 
8570 
  def __ne__(self, other):
8571 
    return not (self == other)
8572 
 
8573 
class getTransaction_args:
8574 
  """
8575 
  Attributes:
8576 
   - id
8577 
  """
8578 
 
8579 
  thrift_spec = (
8580 
    None, # 0
8581 
    (1, TType.I64, 'id', None, None, ), # 1
8582 
  )
8583 
 
8584 
  def __init__(self, id=None,):
8585 
    self.id = id
8586 
 
8587 
  def read(self, iprot):
8588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8590 
      return
8591 
    iprot.readStructBegin()
8592 
    while True:
8593 
      (fname, ftype, fid) = iprot.readFieldBegin()
8594 
      if ftype == TType.STOP:
8595 
        break
8596 
      if fid == 1:
8597 
        if ftype == TType.I64:
8598 
          self.id = iprot.readI64();
8599 
        else:
8600 
          iprot.skip(ftype)
8601 
      else:
8602 
        iprot.skip(ftype)
8603 
      iprot.readFieldEnd()
8604 
    iprot.readStructEnd()
8605 
 
8606 
  def write(self, oprot):
8607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8609 
      return
8610 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8611 
    if self.id is not None:
94 ashish 8612 
      oprot.writeFieldBegin('id', TType.I64, 1)
8613 
      oprot.writeI64(self.id)
8614 
      oprot.writeFieldEnd()
8615 
    oprot.writeFieldStop()
8616 
    oprot.writeStructEnd()
8617 
 
3431 rajveer 8618 
  def validate(self):
8619 
    return
8620 
 
8621 
 
94 ashish 8622 
  def __repr__(self):
8623 
    L = ['%s=%r' % (key, value)
8624 
      for key, value in self.__dict__.iteritems()]
8625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8626 
 
8627 
  def __eq__(self, other):
8628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8629 
 
8630 
  def __ne__(self, other):
8631 
    return not (self == other)
8632 
 
8633 
class getTransaction_result:
8634 
  """
8635 
  Attributes:
8636 
   - success
8637 
   - ex
8638 
  """
8639 
 
8640 
  thrift_spec = (
8641 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8642 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8643 
  )
8644 
 
8645 
  def __init__(self, success=None, ex=None,):
8646 
    self.success = success
8647 
    self.ex = ex
8648 
 
8649 
  def read(self, iprot):
8650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8652 
      return
8653 
    iprot.readStructBegin()
8654 
    while True:
8655 
      (fname, ftype, fid) = iprot.readFieldBegin()
8656 
      if ftype == TType.STOP:
8657 
        break
8658 
      if fid == 0:
8659 
        if ftype == TType.STRUCT:
8660 
          self.success = Transaction()
8661 
          self.success.read(iprot)
8662 
        else:
8663 
          iprot.skip(ftype)
8664 
      elif fid == 1:
8665 
        if ftype == TType.STRUCT:
8666 
          self.ex = TransactionServiceException()
8667 
          self.ex.read(iprot)
8668 
        else:
8669 
          iprot.skip(ftype)
8670 
      else:
8671 
        iprot.skip(ftype)
8672 
      iprot.readFieldEnd()
8673 
    iprot.readStructEnd()
8674 
 
8675 
  def write(self, oprot):
8676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8678 
      return
8679 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8680 
    if self.success is not None:
94 ashish 8681 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8682 
      self.success.write(oprot)
8683 
      oprot.writeFieldEnd()
3431 rajveer 8684 
    if self.ex is not None:
94 ashish 8685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8686 
      self.ex.write(oprot)
8687 
      oprot.writeFieldEnd()
8688 
    oprot.writeFieldStop()
8689 
    oprot.writeStructEnd()
8690 
 
3431 rajveer 8691 
  def validate(self):
8692 
    return
8693 
 
8694 
 
94 ashish 8695 
  def __repr__(self):
8696 
    L = ['%s=%r' % (key, value)
8697 
      for key, value in self.__dict__.iteritems()]
8698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8699 
 
8700 
  def __eq__(self, other):
8701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8702 
 
8703 
  def __ne__(self, other):
8704 
    return not (self == other)
8705 
 
8706 
class getTransactionsForCustomer_args:
8707 
  """
8708 
  Attributes:
8709 
   - customerId
8710 
   - from_date
8711 
   - to_date
8712 
   - status
8713 
  """
8714 
 
8715 
  thrift_spec = (
8716 
    None, # 0
8717 
    (1, TType.I64, 'customerId', None, None, ), # 1
8718 
    (2, TType.I64, 'from_date', None, None, ), # 2
8719 
    (3, TType.I64, 'to_date', None, None, ), # 3
8720 
    (4, TType.I32, 'status', None, None, ), # 4
8721 
  )
8722 
 
8723 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8724 
    self.customerId = customerId
8725 
    self.from_date = from_date
8726 
    self.to_date = to_date
8727 
    self.status = status
8728 
 
8729 
  def read(self, iprot):
8730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8732 
      return
8733 
    iprot.readStructBegin()
8734 
    while True:
8735 
      (fname, ftype, fid) = iprot.readFieldBegin()
8736 
      if ftype == TType.STOP:
8737 
        break
8738 
      if fid == 1:
8739 
        if ftype == TType.I64:
8740 
          self.customerId = iprot.readI64();
8741 
        else:
8742 
          iprot.skip(ftype)
8743 
      elif fid == 2:
8744 
        if ftype == TType.I64:
8745 
          self.from_date = iprot.readI64();
8746 
        else:
8747 
          iprot.skip(ftype)
8748 
      elif fid == 3:
8749 
        if ftype == TType.I64:
8750 
          self.to_date = iprot.readI64();
8751 
        else:
8752 
          iprot.skip(ftype)
8753 
      elif fid == 4:
8754 
        if ftype == TType.I32:
8755 
          self.status = iprot.readI32();
8756 
        else:
8757 
          iprot.skip(ftype)
8758 
      else:
8759 
        iprot.skip(ftype)
8760 
      iprot.readFieldEnd()
8761 
    iprot.readStructEnd()
8762 
 
8763 
  def write(self, oprot):
8764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8766 
      return
8767 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8768 
    if self.customerId is not None:
94 ashish 8769 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8770 
      oprot.writeI64(self.customerId)
8771 
      oprot.writeFieldEnd()
3431 rajveer 8772 
    if self.from_date is not None:
94 ashish 8773 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8774 
      oprot.writeI64(self.from_date)
8775 
      oprot.writeFieldEnd()
3431 rajveer 8776 
    if self.to_date is not None:
94 ashish 8777 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8778 
      oprot.writeI64(self.to_date)
8779 
      oprot.writeFieldEnd()
3431 rajveer 8780 
    if self.status is not None:
94 ashish 8781 
      oprot.writeFieldBegin('status', TType.I32, 4)
8782 
      oprot.writeI32(self.status)
8783 
      oprot.writeFieldEnd()
8784 
    oprot.writeFieldStop()
8785 
    oprot.writeStructEnd()
8786 
 
3431 rajveer 8787 
  def validate(self):
8788 
    return
8789 
 
8790 
 
94 ashish 8791 
  def __repr__(self):
8792 
    L = ['%s=%r' % (key, value)
8793 
      for key, value in self.__dict__.iteritems()]
8794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8795 
 
8796 
  def __eq__(self, other):
8797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8798 
 
8799 
  def __ne__(self, other):
8800 
    return not (self == other)
8801 
 
8802 
class getTransactionsForCustomer_result:
8803 
  """
8804 
  Attributes:
8805 
   - success
8806 
   - ex
8807 
  """
8808 
 
8809 
  thrift_spec = (
8810 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8811 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8812 
  )
8813 
 
8814 
  def __init__(self, success=None, ex=None,):
8815 
    self.success = success
8816 
    self.ex = ex
8817 
 
8818 
  def read(self, iprot):
8819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8821 
      return
8822 
    iprot.readStructBegin()
8823 
    while True:
8824 
      (fname, ftype, fid) = iprot.readFieldBegin()
8825 
      if ftype == TType.STOP:
8826 
        break
8827 
      if fid == 0:
8828 
        if ftype == TType.LIST:
8829 
          self.success = []
6188 rajveer 8830 
          (_etype109, _size106) = iprot.readListBegin()
8831 
          for _i110 in xrange(_size106):
8832 
            _elem111 = Transaction()
8833 
            _elem111.read(iprot)
8834 
            self.success.append(_elem111)
94 ashish 8835 
          iprot.readListEnd()
8836 
        else:
8837 
          iprot.skip(ftype)
8838 
      elif fid == 1:
8839 
        if ftype == TType.STRUCT:
8840 
          self.ex = TransactionServiceException()
8841 
          self.ex.read(iprot)
8842 
        else:
8843 
          iprot.skip(ftype)
8844 
      else:
8845 
        iprot.skip(ftype)
8846 
      iprot.readFieldEnd()
8847 
    iprot.readStructEnd()
8848 
 
8849 
  def write(self, oprot):
8850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8852 
      return
8853 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8854 
    if self.success is not None:
94 ashish 8855 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8856 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8857 
      for iter112 in self.success:
8858 
        iter112.write(oprot)
94 ashish 8859 
      oprot.writeListEnd()
8860 
      oprot.writeFieldEnd()
3431 rajveer 8861 
    if self.ex is not None:
94 ashish 8862 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8863 
      self.ex.write(oprot)
8864 
      oprot.writeFieldEnd()
8865 
    oprot.writeFieldStop()
8866 
    oprot.writeStructEnd()
8867 
 
3431 rajveer 8868 
  def validate(self):
8869 
    return
8870 
 
8871 
 
94 ashish 8872 
  def __repr__(self):
8873 
    L = ['%s=%r' % (key, value)
8874 
      for key, value in self.__dict__.iteritems()]
8875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8876 
 
8877 
  def __eq__(self, other):
8878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8879 
 
8880 
  def __ne__(self, other):
8881 
    return not (self == other)
8882 
 
132 ashish 8883 
class getTransactionsForShoppingCartId_args:
8884 
  """
8885 
  Attributes:
8886 
   - shoppingCartId
8887 
  """
8888 
 
8889 
  thrift_spec = (
8890 
    None, # 0
8891 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8892 
  )
8893 
 
8894 
  def __init__(self, shoppingCartId=None,):
8895 
    self.shoppingCartId = shoppingCartId
8896 
 
8897 
  def read(self, iprot):
8898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8900 
      return
8901 
    iprot.readStructBegin()
8902 
    while True:
8903 
      (fname, ftype, fid) = iprot.readFieldBegin()
8904 
      if ftype == TType.STOP:
8905 
        break
8906 
      if fid == 1:
8907 
        if ftype == TType.I64:
8908 
          self.shoppingCartId = iprot.readI64();
8909 
        else:
8910 
          iprot.skip(ftype)
8911 
      else:
8912 
        iprot.skip(ftype)
8913 
      iprot.readFieldEnd()
8914 
    iprot.readStructEnd()
8915 
 
8916 
  def write(self, oprot):
8917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8919 
      return
8920 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8921 
    if self.shoppingCartId is not None:
132 ashish 8922 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8923 
      oprot.writeI64(self.shoppingCartId)
8924 
      oprot.writeFieldEnd()
8925 
    oprot.writeFieldStop()
8926 
    oprot.writeStructEnd()
8927 
 
3431 rajveer 8928 
  def validate(self):
8929 
    return
8930 
 
8931 
 
132 ashish 8932 
  def __repr__(self):
8933 
    L = ['%s=%r' % (key, value)
8934 
      for key, value in self.__dict__.iteritems()]
8935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8936 
 
8937 
  def __eq__(self, other):
8938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8939 
 
8940 
  def __ne__(self, other):
8941 
    return not (self == other)
8942 
 
8943 
class getTransactionsForShoppingCartId_result:
8944 
  """
8945 
  Attributes:
8946 
   - success
8947 
   - ex
8948 
  """
8949 
 
8950 
  thrift_spec = (
8951 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8952 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8953 
  )
8954 
 
8955 
  def __init__(self, success=None, ex=None,):
8956 
    self.success = success
8957 
    self.ex = ex
8958 
 
8959 
  def read(self, iprot):
8960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8962 
      return
8963 
    iprot.readStructBegin()
8964 
    while True:
8965 
      (fname, ftype, fid) = iprot.readFieldBegin()
8966 
      if ftype == TType.STOP:
8967 
        break
8968 
      if fid == 0:
8969 
        if ftype == TType.LIST:
8970 
          self.success = []
6188 rajveer 8971 
          (_etype116, _size113) = iprot.readListBegin()
8972 
          for _i117 in xrange(_size113):
8973 
            _elem118 = Transaction()
8974 
            _elem118.read(iprot)
8975 
            self.success.append(_elem118)
132 ashish 8976 
          iprot.readListEnd()
8977 
        else:
8978 
          iprot.skip(ftype)
8979 
      elif fid == 1:
8980 
        if ftype == TType.STRUCT:
8981 
          self.ex = TransactionServiceException()
8982 
          self.ex.read(iprot)
8983 
        else:
8984 
          iprot.skip(ftype)
8985 
      else:
8986 
        iprot.skip(ftype)
8987 
      iprot.readFieldEnd()
8988 
    iprot.readStructEnd()
8989 
 
8990 
  def write(self, oprot):
8991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8993 
      return
8994 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8995 
    if self.success is not None:
132 ashish 8996 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8997 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8998 
      for iter119 in self.success:
8999 
        iter119.write(oprot)
132 ashish 9000 
      oprot.writeListEnd()
9001 
      oprot.writeFieldEnd()
3431 rajveer 9002 
    if self.ex is not None:
132 ashish 9003 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9004 
      self.ex.write(oprot)
9005 
      oprot.writeFieldEnd()
9006 
    oprot.writeFieldStop()
9007 
    oprot.writeStructEnd()
9008 
 
3431 rajveer 9009 
  def validate(self):
9010 
    return
9011 
 
9012 
 
132 ashish 9013 
  def __repr__(self):
9014 
    L = ['%s=%r' % (key, value)
9015 
      for key, value in self.__dict__.iteritems()]
9016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9017 
 
9018 
  def __eq__(self, other):
9019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9020 
 
9021 
  def __ne__(self, other):
9022 
    return not (self == other)
9023 
 
94 ashish 9024 
class getTransactionStatus_args:
9025 
  """
9026 
  Attributes:
9027 
   - transactionId
9028 
  """
9029 
 
9030 
  thrift_spec = (
9031 
    None, # 0
9032 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9033 
  )
9034 
 
9035 
  def __init__(self, transactionId=None,):
9036 
    self.transactionId = transactionId
9037 
 
9038 
  def read(self, iprot):
9039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9041 
      return
9042 
    iprot.readStructBegin()
9043 
    while True:
9044 
      (fname, ftype, fid) = iprot.readFieldBegin()
9045 
      if ftype == TType.STOP:
9046 
        break
9047 
      if fid == 1:
9048 
        if ftype == TType.I64:
9049 
          self.transactionId = iprot.readI64();
9050 
        else:
9051 
          iprot.skip(ftype)
9052 
      else:
9053 
        iprot.skip(ftype)
9054 
      iprot.readFieldEnd()
9055 
    iprot.readStructEnd()
9056 
 
9057 
  def write(self, oprot):
9058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9060 
      return
9061 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9062 
    if self.transactionId is not None:
94 ashish 9063 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9064 
      oprot.writeI64(self.transactionId)
9065 
      oprot.writeFieldEnd()
9066 
    oprot.writeFieldStop()
9067 
    oprot.writeStructEnd()
9068 
 
3431 rajveer 9069 
  def validate(self):
9070 
    return
9071 
 
9072 
 
94 ashish 9073 
  def __repr__(self):
9074 
    L = ['%s=%r' % (key, value)
9075 
      for key, value in self.__dict__.iteritems()]
9076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9077 
 
9078 
  def __eq__(self, other):
9079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9080 
 
9081 
  def __ne__(self, other):
9082 
    return not (self == other)
9083 
 
9084 
class getTransactionStatus_result:
9085 
  """
9086 
  Attributes:
9087 
   - success
9088 
   - ex
9089 
  """
9090 
 
9091 
  thrift_spec = (
9092 
    (0, TType.I32, 'success', None, None, ), # 0
9093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9094 
  )
9095 
 
9096 
  def __init__(self, success=None, ex=None,):
9097 
    self.success = success
9098 
    self.ex = ex
9099 
 
9100 
  def read(self, iprot):
9101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9103 
      return
9104 
    iprot.readStructBegin()
9105 
    while True:
9106 
      (fname, ftype, fid) = iprot.readFieldBegin()
9107 
      if ftype == TType.STOP:
9108 
        break
9109 
      if fid == 0:
9110 
        if ftype == TType.I32:
9111 
          self.success = iprot.readI32();
9112 
        else:
9113 
          iprot.skip(ftype)
9114 
      elif fid == 1:
9115 
        if ftype == TType.STRUCT:
9116 
          self.ex = TransactionServiceException()
9117 
          self.ex.read(iprot)
9118 
        else:
9119 
          iprot.skip(ftype)
9120 
      else:
9121 
        iprot.skip(ftype)
9122 
      iprot.readFieldEnd()
9123 
    iprot.readStructEnd()
9124 
 
9125 
  def write(self, oprot):
9126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9128 
      return
9129 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9130 
    if self.success is not None:
94 ashish 9131 
      oprot.writeFieldBegin('success', TType.I32, 0)
9132 
      oprot.writeI32(self.success)
9133 
      oprot.writeFieldEnd()
3431 rajveer 9134 
    if self.ex is not None:
94 ashish 9135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9136 
      self.ex.write(oprot)
9137 
      oprot.writeFieldEnd()
9138 
    oprot.writeFieldStop()
9139 
    oprot.writeStructEnd()
9140 
 
3431 rajveer 9141 
  def validate(self):
9142 
    return
9143 
 
9144 
 
94 ashish 9145 
  def __repr__(self):
9146 
    L = ['%s=%r' % (key, value)
9147 
      for key, value in self.__dict__.iteritems()]
9148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9149 
 
9150 
  def __eq__(self, other):
9151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9152 
 
9153 
  def __ne__(self, other):
9154 
    return not (self == other)
9155 
 
9156 
class changeTransactionStatus_args:
9157 
  """
9158 
  Attributes:
9159 
   - transactionId
9160 
   - status
9161 
   - description
5527 anupam.sin 9162 
   - pickUp
9163 
   - orderType
94 ashish 9164 
  """
9165 
 
9166 
  thrift_spec = (
9167 
    None, # 0
9168 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9169 
    (2, TType.I32, 'status', None, None, ), # 2
9170 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9171 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9172 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9173 
  )
9174 
 
5527 anupam.sin 9175 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9176 
    self.transactionId = transactionId
9177 
    self.status = status
9178 
    self.description = description
5527 anupam.sin 9179 
    self.pickUp = pickUp
9180 
    self.orderType = orderType
94 ashish 9181 
 
9182 
  def read(self, iprot):
9183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9185 
      return
9186 
    iprot.readStructBegin()
9187 
    while True:
9188 
      (fname, ftype, fid) = iprot.readFieldBegin()
9189 
      if ftype == TType.STOP:
9190 
        break
9191 
      if fid == 1:
9192 
        if ftype == TType.I64:
9193 
          self.transactionId = iprot.readI64();
9194 
        else:
9195 
          iprot.skip(ftype)
9196 
      elif fid == 2:
9197 
        if ftype == TType.I32:
9198 
          self.status = iprot.readI32();
9199 
        else:
9200 
          iprot.skip(ftype)
9201 
      elif fid == 3:
9202 
        if ftype == TType.STRING:
9203 
          self.description = iprot.readString();
9204 
        else:
9205 
          iprot.skip(ftype)
5387 rajveer 9206 
      elif fid == 4:
5527 anupam.sin 9207 
        if ftype == TType.I64:
9208 
          self.pickUp = iprot.readI64();
5387 rajveer 9209 
        else:
9210 
          iprot.skip(ftype)
5527 anupam.sin 9211 
      elif fid == 5:
9212 
        if ftype == TType.I32:
9213 
          self.orderType = iprot.readI32();
9214 
        else:
9215 
          iprot.skip(ftype)
94 ashish 9216 
      else:
9217 
        iprot.skip(ftype)
9218 
      iprot.readFieldEnd()
9219 
    iprot.readStructEnd()
9220 
 
9221 
  def write(self, oprot):
9222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9224 
      return
9225 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9226 
    if self.transactionId is not None:
94 ashish 9227 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9228 
      oprot.writeI64(self.transactionId)
9229 
      oprot.writeFieldEnd()
3431 rajveer 9230 
    if self.status is not None:
94 ashish 9231 
      oprot.writeFieldBegin('status', TType.I32, 2)
9232 
      oprot.writeI32(self.status)
9233 
      oprot.writeFieldEnd()
3431 rajveer 9234 
    if self.description is not None:
94 ashish 9235 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9236 
      oprot.writeString(self.description)
9237 
      oprot.writeFieldEnd()
5527 anupam.sin 9238 
    if self.pickUp is not None:
9239 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9240 
      oprot.writeI64(self.pickUp)
5387 rajveer 9241 
      oprot.writeFieldEnd()
5527 anupam.sin 9242 
    if self.orderType is not None:
9243 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9244 
      oprot.writeI32(self.orderType)
9245 
      oprot.writeFieldEnd()
94 ashish 9246 
    oprot.writeFieldStop()
9247 
    oprot.writeStructEnd()
9248 
 
3431 rajveer 9249 
  def validate(self):
9250 
    return
9251 
 
9252 
 
94 ashish 9253 
  def __repr__(self):
9254 
    L = ['%s=%r' % (key, value)
9255 
      for key, value in self.__dict__.iteritems()]
9256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9257 
 
9258 
  def __eq__(self, other):
9259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9260 
 
9261 
  def __ne__(self, other):
9262 
    return not (self == other)
9263 
 
9264 
class changeTransactionStatus_result:
9265 
  """
9266 
  Attributes:
9267 
   - success
9268 
   - ex
9269 
  """
9270 
 
9271 
  thrift_spec = (
9272 
    (0, TType.BOOL, 'success', None, None, ), # 0
9273 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9274 
  )
9275 
 
9276 
  def __init__(self, success=None, ex=None,):
9277 
    self.success = success
9278 
    self.ex = ex
9279 
 
9280 
  def read(self, iprot):
9281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9283 
      return
9284 
    iprot.readStructBegin()
9285 
    while True:
9286 
      (fname, ftype, fid) = iprot.readFieldBegin()
9287 
      if ftype == TType.STOP:
9288 
        break
9289 
      if fid == 0:
9290 
        if ftype == TType.BOOL:
9291 
          self.success = iprot.readBool();
9292 
        else:
9293 
          iprot.skip(ftype)
9294 
      elif fid == 1:
9295 
        if ftype == TType.STRUCT:
9296 
          self.ex = TransactionServiceException()
9297 
          self.ex.read(iprot)
9298 
        else:
9299 
          iprot.skip(ftype)
9300 
      else:
9301 
        iprot.skip(ftype)
9302 
      iprot.readFieldEnd()
9303 
    iprot.readStructEnd()
9304 
 
9305 
  def write(self, oprot):
9306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9308 
      return
9309 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9310 
    if self.success is not None:
94 ashish 9311 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9312 
      oprot.writeBool(self.success)
9313 
      oprot.writeFieldEnd()
3431 rajveer 9314 
    if self.ex is not None:
94 ashish 9315 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9316 
      self.ex.write(oprot)
9317 
      oprot.writeFieldEnd()
9318 
    oprot.writeFieldStop()
9319 
    oprot.writeStructEnd()
9320 
 
3431 rajveer 9321 
  def validate(self):
9322 
    return
9323 
 
9324 
 
94 ashish 9325 
  def __repr__(self):
9326 
    L = ['%s=%r' % (key, value)
9327 
      for key, value in self.__dict__.iteritems()]
9328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9329 
 
9330 
  def __eq__(self, other):
9331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9332 
 
9333 
  def __ne__(self, other):
9334 
    return not (self == other)
9335 
 
1398 varun.gupt 9336 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9337 
  """
9338 
  Attributes:
9339 
   - transactionId
9340 
  """
9341 
 
9342 
  thrift_spec = (
9343 
    None, # 0
9344 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9345 
  )
9346 
 
9347 
  def __init__(self, transactionId=None,):
9348 
    self.transactionId = transactionId
9349 
 
9350 
  def read(self, iprot):
9351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9353 
      return
9354 
    iprot.readStructBegin()
9355 
    while True:
9356 
      (fname, ftype, fid) = iprot.readFieldBegin()
9357 
      if ftype == TType.STOP:
9358 
        break
9359 
      if fid == 1:
9360 
        if ftype == TType.I64:
9361 
          self.transactionId = iprot.readI64();
9362 
        else:
9363 
          iprot.skip(ftype)
9364 
      else:
9365 
        iprot.skip(ftype)
9366 
      iprot.readFieldEnd()
9367 
    iprot.readStructEnd()
9368 
 
9369 
  def write(self, oprot):
9370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9372 
      return
1398 varun.gupt 9373 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9374 
    if self.transactionId is not None:
1382 varun.gupt 9375 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9376 
      oprot.writeI64(self.transactionId)
9377 
      oprot.writeFieldEnd()
9378 
    oprot.writeFieldStop()
9379 
    oprot.writeStructEnd()
9380 
 
3431 rajveer 9381 
  def validate(self):
9382 
    return
9383 
 
9384 
 
1382 varun.gupt 9385 
  def __repr__(self):
9386 
    L = ['%s=%r' % (key, value)
9387 
      for key, value in self.__dict__.iteritems()]
9388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9389 
 
9390 
  def __eq__(self, other):
9391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9392 
 
9393 
  def __ne__(self, other):
9394 
    return not (self == other)
9395 
 
1398 varun.gupt 9396 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9397 
  """
9398 
  Attributes:
9399 
   - success
9400 
   - ex
9401 
  """
9402 
 
9403 
  thrift_spec = (
9404 
    (0, TType.BOOL, 'success', None, None, ), # 0
9405 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9406 
  )
9407 
 
9408 
  def __init__(self, success=None, ex=None,):
9409 
    self.success = success
9410 
    self.ex = ex
9411 
 
9412 
  def read(self, iprot):
9413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9415 
      return
9416 
    iprot.readStructBegin()
9417 
    while True:
9418 
      (fname, ftype, fid) = iprot.readFieldBegin()
9419 
      if ftype == TType.STOP:
9420 
        break
9421 
      if fid == 0:
9422 
        if ftype == TType.BOOL:
9423 
          self.success = iprot.readBool();
9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      elif fid == 1:
9427 
        if ftype == TType.STRUCT:
9428 
          self.ex = TransactionServiceException()
9429 
          self.ex.read(iprot)
9430 
        else:
9431 
          iprot.skip(ftype)
9432 
      else:
9433 
        iprot.skip(ftype)
9434 
      iprot.readFieldEnd()
9435 
    iprot.readStructEnd()
9436 
 
9437 
  def write(self, oprot):
9438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9440 
      return
1398 varun.gupt 9441 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9442 
    if self.success is not None:
1382 varun.gupt 9443 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9444 
      oprot.writeBool(self.success)
9445 
      oprot.writeFieldEnd()
3431 rajveer 9446 
    if self.ex is not None:
1382 varun.gupt 9447 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9448 
      self.ex.write(oprot)
9449 
      oprot.writeFieldEnd()
9450 
    oprot.writeFieldStop()
9451 
    oprot.writeStructEnd()
9452 
 
3431 rajveer 9453 
  def validate(self):
9454 
    return
9455 
 
9456 
 
1382 varun.gupt 9457 
  def __repr__(self):
9458 
    L = ['%s=%r' % (key, value)
9459 
      for key, value in self.__dict__.iteritems()]
9460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9461 
 
9462 
  def __eq__(self, other):
9463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9464 
 
9465 
  def __ne__(self, other):
9466 
    return not (self == other)
9467 
 
483 rajveer 9468 
class getAllOrders_args:
94 ashish 9469 
  """
9470 
  Attributes:
4801 anupam.sin 9471 
   - statuses
483 rajveer 9472 
   - from_date
9473 
   - to_date
9474 
   - warehouse_id
94 ashish 9475 
  """
9476 
 
9477 
  thrift_spec = (
9478 
    None, # 0
4801 anupam.sin 9479 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9480 
    (2, TType.I64, 'from_date', None, None, ), # 2
9481 
    (3, TType.I64, 'to_date', None, None, ), # 3
9482 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9483 
  )
9484 
 
4801 anupam.sin 9485 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9486 
    self.statuses = statuses
483 rajveer 9487 
    self.from_date = from_date
9488 
    self.to_date = to_date
9489 
    self.warehouse_id = warehouse_id
94 ashish 9490 
 
9491 
  def read(self, iprot):
9492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9494 
      return
9495 
    iprot.readStructBegin()
9496 
    while True:
9497 
      (fname, ftype, fid) = iprot.readFieldBegin()
9498 
      if ftype == TType.STOP:
9499 
        break
9500 
      if fid == 1:
4801 anupam.sin 9501 
        if ftype == TType.LIST:
9502 
          self.statuses = []
6188 rajveer 9503 
          (_etype123, _size120) = iprot.readListBegin()
9504 
          for _i124 in xrange(_size120):
9505 
            _elem125 = iprot.readI32();
9506 
            self.statuses.append(_elem125)
4801 anupam.sin 9507 
          iprot.readListEnd()
94 ashish 9508 
        else:
9509 
          iprot.skip(ftype)
483 rajveer 9510 
      elif fid == 2:
9511 
        if ftype == TType.I64:
9512 
          self.from_date = iprot.readI64();
94 ashish 9513 
        else:
9514 
          iprot.skip(ftype)
483 rajveer 9515 
      elif fid == 3:
9516 
        if ftype == TType.I64:
9517 
          self.to_date = iprot.readI64();
94 ashish 9518 
        else:
9519 
          iprot.skip(ftype)
483 rajveer 9520 
      elif fid == 4:
94 ashish 9521 
        if ftype == TType.I64:
483 rajveer 9522 
          self.warehouse_id = iprot.readI64();
94 ashish 9523 
        else:
9524 
          iprot.skip(ftype)
9525 
      else:
9526 
        iprot.skip(ftype)
9527 
      iprot.readFieldEnd()
9528 
    iprot.readStructEnd()
9529 
 
9530 
  def write(self, oprot):
9531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9533 
      return
483 rajveer 9534 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9535 
    if self.statuses is not None:
9536 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9537 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9538 
      for iter126 in self.statuses:
9539 
        oprot.writeI32(iter126)
4801 anupam.sin 9540 
      oprot.writeListEnd()
94 ashish 9541 
      oprot.writeFieldEnd()
3431 rajveer 9542 
    if self.from_date is not None:
483 rajveer 9543 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9544 
      oprot.writeI64(self.from_date)
94 ashish 9545 
      oprot.writeFieldEnd()
3431 rajveer 9546 
    if self.to_date is not None:
483 rajveer 9547 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9548 
      oprot.writeI64(self.to_date)
94 ashish 9549 
      oprot.writeFieldEnd()
3431 rajveer 9550 
    if self.warehouse_id is not None:
483 rajveer 9551 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9552 
      oprot.writeI64(self.warehouse_id)
94 ashish 9553 
      oprot.writeFieldEnd()
9554 
    oprot.writeFieldStop()
9555 
    oprot.writeStructEnd()
9556 
 
3431 rajveer 9557 
  def validate(self):
9558 
    return
9559 
 
9560 
 
94 ashish 9561 
  def __repr__(self):
9562 
    L = ['%s=%r' % (key, value)
9563 
      for key, value in self.__dict__.iteritems()]
9564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9565 
 
9566 
  def __eq__(self, other):
9567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9568 
 
9569 
  def __ne__(self, other):
9570 
    return not (self == other)
9571 
 
483 rajveer 9572 
class getAllOrders_result:
94 ashish 9573 
  """
9574 
  Attributes:
9575 
   - success
9576 
   - ex
9577 
  """
9578 
 
9579 
  thrift_spec = (
483 rajveer 9580 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9582 
  )
9583 
 
9584 
  def __init__(self, success=None, ex=None,):
9585 
    self.success = success
9586 
    self.ex = ex
9587 
 
9588 
  def read(self, iprot):
9589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9591 
      return
9592 
    iprot.readStructBegin()
9593 
    while True:
9594 
      (fname, ftype, fid) = iprot.readFieldBegin()
9595 
      if ftype == TType.STOP:
9596 
        break
9597 
      if fid == 0:
483 rajveer 9598 
        if ftype == TType.LIST:
9599 
          self.success = []
6188 rajveer 9600 
          (_etype130, _size127) = iprot.readListBegin()
9601 
          for _i131 in xrange(_size127):
9602 
            _elem132 = Order()
9603 
            _elem132.read(iprot)
9604 
            self.success.append(_elem132)
483 rajveer 9605 
          iprot.readListEnd()
94 ashish 9606 
        else:
9607 
          iprot.skip(ftype)
9608 
      elif fid == 1:
9609 
        if ftype == TType.STRUCT:
9610 
          self.ex = TransactionServiceException()
9611 
          self.ex.read(iprot)
9612 
        else:
9613 
          iprot.skip(ftype)
9614 
      else:
9615 
        iprot.skip(ftype)
9616 
      iprot.readFieldEnd()
9617 
    iprot.readStructEnd()
9618 
 
9619 
  def write(self, oprot):
9620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9622 
      return
483 rajveer 9623 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9624 
    if self.success is not None:
483 rajveer 9625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9627 
      for iter133 in self.success:
9628 
        iter133.write(oprot)
483 rajveer 9629 
      oprot.writeListEnd()
94 ashish 9630 
      oprot.writeFieldEnd()
3431 rajveer 9631 
    if self.ex is not None:
94 ashish 9632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9633 
      self.ex.write(oprot)
9634 
      oprot.writeFieldEnd()
9635 
    oprot.writeFieldStop()
9636 
    oprot.writeStructEnd()
9637 
 
3431 rajveer 9638 
  def validate(self):
9639 
    return
9640 
 
9641 
 
94 ashish 9642 
  def __repr__(self):
9643 
    L = ['%s=%r' % (key, value)
9644 
      for key, value in self.__dict__.iteritems()]
9645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9646 
 
9647 
  def __eq__(self, other):
9648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9649 
 
9650 
  def __ne__(self, other):
9651 
    return not (self == other)
9652 
 
4133 chandransh 9653 
class getOrdersInBatch_args:
9654 
  """
9655 
  Attributes:
9656 
   - statuses
9657 
   - offset
9658 
   - limit
9659 
   - warehouse_id
9660 
  """
9661 
 
9662 
  thrift_spec = (
9663 
    None, # 0
9664 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9665 
    (2, TType.I64, 'offset', None, None, ), # 2
9666 
    (3, TType.I64, 'limit', None, None, ), # 3
9667 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9668 
  )
9669 
 
9670 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9671 
    self.statuses = statuses
9672 
    self.offset = offset
9673 
    self.limit = limit
9674 
    self.warehouse_id = warehouse_id
9675 
 
9676 
  def read(self, iprot):
9677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9679 
      return
9680 
    iprot.readStructBegin()
9681 
    while True:
9682 
      (fname, ftype, fid) = iprot.readFieldBegin()
9683 
      if ftype == TType.STOP:
9684 
        break
9685 
      if fid == 1:
9686 
        if ftype == TType.LIST:
9687 
          self.statuses = []
6188 rajveer 9688 
          (_etype137, _size134) = iprot.readListBegin()
9689 
          for _i138 in xrange(_size134):
9690 
            _elem139 = iprot.readI32();
9691 
            self.statuses.append(_elem139)
4133 chandransh 9692 
          iprot.readListEnd()
9693 
        else:
9694 
          iprot.skip(ftype)
9695 
      elif fid == 2:
9696 
        if ftype == TType.I64:
9697 
          self.offset = iprot.readI64();
9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      elif fid == 3:
9701 
        if ftype == TType.I64:
9702 
          self.limit = iprot.readI64();
9703 
        else:
9704 
          iprot.skip(ftype)
9705 
      elif fid == 4:
9706 
        if ftype == TType.I64:
9707 
          self.warehouse_id = iprot.readI64();
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      else:
9711 
        iprot.skip(ftype)
9712 
      iprot.readFieldEnd()
9713 
    iprot.readStructEnd()
9714 
 
9715 
  def write(self, oprot):
9716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9718 
      return
9719 
    oprot.writeStructBegin('getOrdersInBatch_args')
9720 
    if self.statuses is not None:
9721 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9722 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9723 
      for iter140 in self.statuses:
9724 
        oprot.writeI32(iter140)
4133 chandransh 9725 
      oprot.writeListEnd()
9726 
      oprot.writeFieldEnd()
9727 
    if self.offset is not None:
9728 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9729 
      oprot.writeI64(self.offset)
9730 
      oprot.writeFieldEnd()
9731 
    if self.limit is not None:
9732 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9733 
      oprot.writeI64(self.limit)
9734 
      oprot.writeFieldEnd()
9735 
    if self.warehouse_id is not None:
9736 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9737 
      oprot.writeI64(self.warehouse_id)
9738 
      oprot.writeFieldEnd()
9739 
    oprot.writeFieldStop()
9740 
    oprot.writeStructEnd()
9741 
 
9742 
  def validate(self):
9743 
    return
9744 
 
9745 
 
9746 
  def __repr__(self):
9747 
    L = ['%s=%r' % (key, value)
9748 
      for key, value in self.__dict__.iteritems()]
9749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9750 
 
9751 
  def __eq__(self, other):
9752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9753 
 
9754 
  def __ne__(self, other):
9755 
    return not (self == other)
9756 
 
9757 
class getOrdersInBatch_result:
9758 
  """
9759 
  Attributes:
9760 
   - success
9761 
   - ex
9762 
  """
9763 
 
9764 
  thrift_spec = (
9765 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9766 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9767 
  )
9768 
 
9769 
  def __init__(self, success=None, ex=None,):
9770 
    self.success = success
9771 
    self.ex = ex
9772 
 
9773 
  def read(self, iprot):
9774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9776 
      return
9777 
    iprot.readStructBegin()
9778 
    while True:
9779 
      (fname, ftype, fid) = iprot.readFieldBegin()
9780 
      if ftype == TType.STOP:
9781 
        break
9782 
      if fid == 0:
9783 
        if ftype == TType.LIST:
9784 
          self.success = []
6188 rajveer 9785 
          (_etype144, _size141) = iprot.readListBegin()
9786 
          for _i145 in xrange(_size141):
9787 
            _elem146 = Order()
9788 
            _elem146.read(iprot)
9789 
            self.success.append(_elem146)
4133 chandransh 9790 
          iprot.readListEnd()
9791 
        else:
9792 
          iprot.skip(ftype)
9793 
      elif fid == 1:
9794 
        if ftype == TType.STRUCT:
9795 
          self.ex = TransactionServiceException()
9796 
          self.ex.read(iprot)
9797 
        else:
9798 
          iprot.skip(ftype)
9799 
      else:
9800 
        iprot.skip(ftype)
9801 
      iprot.readFieldEnd()
9802 
    iprot.readStructEnd()
9803 
 
9804 
  def write(self, oprot):
9805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9807 
      return
9808 
    oprot.writeStructBegin('getOrdersInBatch_result')
9809 
    if self.success is not None:
9810 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9811 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9812 
      for iter147 in self.success:
9813 
        iter147.write(oprot)
4133 chandransh 9814 
      oprot.writeListEnd()
9815 
      oprot.writeFieldEnd()
9816 
    if self.ex is not None:
9817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9818 
      self.ex.write(oprot)
9819 
      oprot.writeFieldEnd()
9820 
    oprot.writeFieldStop()
9821 
    oprot.writeStructEnd()
9822 
 
9823 
  def validate(self):
9824 
    return
9825 
 
9826 
 
9827 
  def __repr__(self):
9828 
    L = ['%s=%r' % (key, value)
9829 
      for key, value in self.__dict__.iteritems()]
9830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9831 
 
9832 
  def __eq__(self, other):
9833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9834 
 
9835 
  def __ne__(self, other):
9836 
    return not (self == other)
9837 
 
9838 
class getOrderCount_args:
9839 
  """
9840 
  Attributes:
9841 
   - statuses
9842 
   - warehouseId
9843 
  """
9844 
 
9845 
  thrift_spec = (
9846 
    None, # 0
9847 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9848 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9849 
  )
9850 
 
9851 
  def __init__(self, statuses=None, warehouseId=None,):
9852 
    self.statuses = statuses
9853 
    self.warehouseId = warehouseId
9854 
 
9855 
  def read(self, iprot):
9856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9858 
      return
9859 
    iprot.readStructBegin()
9860 
    while True:
9861 
      (fname, ftype, fid) = iprot.readFieldBegin()
9862 
      if ftype == TType.STOP:
9863 
        break
9864 
      if fid == 1:
9865 
        if ftype == TType.LIST:
9866 
          self.statuses = []
6188 rajveer 9867 
          (_etype151, _size148) = iprot.readListBegin()
9868 
          for _i152 in xrange(_size148):
9869 
            _elem153 = iprot.readI32();
9870 
            self.statuses.append(_elem153)
4133 chandransh 9871 
          iprot.readListEnd()
9872 
        else:
9873 
          iprot.skip(ftype)
9874 
      elif fid == 2:
9875 
        if ftype == TType.I64:
9876 
          self.warehouseId = iprot.readI64();
9877 
        else:
9878 
          iprot.skip(ftype)
9879 
      else:
9880 
        iprot.skip(ftype)
9881 
      iprot.readFieldEnd()
9882 
    iprot.readStructEnd()
9883 
 
9884 
  def write(self, oprot):
9885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9887 
      return
9888 
    oprot.writeStructBegin('getOrderCount_args')
9889 
    if self.statuses is not None:
9890 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9891 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9892 
      for iter154 in self.statuses:
9893 
        oprot.writeI32(iter154)
4133 chandransh 9894 
      oprot.writeListEnd()
9895 
      oprot.writeFieldEnd()
9896 
    if self.warehouseId is not None:
9897 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9898 
      oprot.writeI64(self.warehouseId)
9899 
      oprot.writeFieldEnd()
9900 
    oprot.writeFieldStop()
9901 
    oprot.writeStructEnd()
9902 
 
9903 
  def validate(self):
9904 
    return
9905 
 
9906 
 
9907 
  def __repr__(self):
9908 
    L = ['%s=%r' % (key, value)
9909 
      for key, value in self.__dict__.iteritems()]
9910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9911 
 
9912 
  def __eq__(self, other):
9913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9914 
 
9915 
  def __ne__(self, other):
9916 
    return not (self == other)
9917 
 
9918 
class getOrderCount_result:
9919 
  """
9920 
  Attributes:
9921 
   - success
9922 
   - ex
9923 
  """
9924 
 
9925 
  thrift_spec = (
9926 
    (0, TType.I32, 'success', None, None, ), # 0
9927 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9928 
  )
9929 
 
9930 
  def __init__(self, success=None, ex=None,):
9931 
    self.success = success
9932 
    self.ex = ex
9933 
 
9934 
  def read(self, iprot):
9935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9937 
      return
9938 
    iprot.readStructBegin()
9939 
    while True:
9940 
      (fname, ftype, fid) = iprot.readFieldBegin()
9941 
      if ftype == TType.STOP:
9942 
        break
9943 
      if fid == 0:
9944 
        if ftype == TType.I32:
9945 
          self.success = iprot.readI32();
9946 
        else:
9947 
          iprot.skip(ftype)
9948 
      elif fid == 1:
9949 
        if ftype == TType.STRUCT:
9950 
          self.ex = TransactionServiceException()
9951 
          self.ex.read(iprot)
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      else:
9955 
        iprot.skip(ftype)
9956 
      iprot.readFieldEnd()
9957 
    iprot.readStructEnd()
9958 
 
9959 
  def write(self, oprot):
9960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9962 
      return
9963 
    oprot.writeStructBegin('getOrderCount_result')
9964 
    if self.success is not None:
9965 
      oprot.writeFieldBegin('success', TType.I32, 0)
9966 
      oprot.writeI32(self.success)
9967 
      oprot.writeFieldEnd()
9968 
    if self.ex is not None:
9969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9970 
      self.ex.write(oprot)
9971 
      oprot.writeFieldEnd()
9972 
    oprot.writeFieldStop()
9973 
    oprot.writeStructEnd()
9974 
 
9975 
  def validate(self):
9976 
    return
9977 
 
9978 
 
9979 
  def __repr__(self):
9980 
    L = ['%s=%r' % (key, value)
9981 
      for key, value in self.__dict__.iteritems()]
9982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9983 
 
9984 
  def __eq__(self, other):
9985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9986 
 
9987 
  def __ne__(self, other):
9988 
    return not (self == other)
9989 
 
999 varun.gupt 9990 
class getOrdersByBillingDate_args:
9991 
  """
9992 
  Attributes:
9993 
   - status
9994 
   - start_billing_date
9995 
   - end_billing_date
9996 
   - warehouse_id
9997 
  """
9998 
 
9999 
  thrift_spec = (
10000 
    None, # 0
10001 
    (1, TType.I32, 'status', None, None, ), # 1
10002 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10003 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10004 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10005 
  )
10006 
 
10007 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10008 
    self.status = status
10009 
    self.start_billing_date = start_billing_date
10010 
    self.end_billing_date = end_billing_date
10011 
    self.warehouse_id = warehouse_id
10012 
 
10013 
  def read(self, iprot):
10014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10016 
      return
10017 
    iprot.readStructBegin()
10018 
    while True:
10019 
      (fname, ftype, fid) = iprot.readFieldBegin()
10020 
      if ftype == TType.STOP:
10021 
        break
10022 
      if fid == 1:
10023 
        if ftype == TType.I32:
10024 
          self.status = iprot.readI32();
10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      elif fid == 2:
10028 
        if ftype == TType.I64:
10029 
          self.start_billing_date = iprot.readI64();
10030 
        else:
10031 
          iprot.skip(ftype)
10032 
      elif fid == 3:
10033 
        if ftype == TType.I64:
10034 
          self.end_billing_date = iprot.readI64();
10035 
        else:
10036 
          iprot.skip(ftype)
10037 
      elif fid == 4:
10038 
        if ftype == TType.I64:
10039 
          self.warehouse_id = iprot.readI64();
10040 
        else:
10041 
          iprot.skip(ftype)
10042 
      else:
10043 
        iprot.skip(ftype)
10044 
      iprot.readFieldEnd()
10045 
    iprot.readStructEnd()
10046 
 
10047 
  def write(self, oprot):
10048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10050 
      return
10051 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10052 
    if self.status is not None:
999 varun.gupt 10053 
      oprot.writeFieldBegin('status', TType.I32, 1)
10054 
      oprot.writeI32(self.status)
10055 
      oprot.writeFieldEnd()
3431 rajveer 10056 
    if self.start_billing_date is not None:
999 varun.gupt 10057 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10058 
      oprot.writeI64(self.start_billing_date)
10059 
      oprot.writeFieldEnd()
3431 rajveer 10060 
    if self.end_billing_date is not None:
999 varun.gupt 10061 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10062 
      oprot.writeI64(self.end_billing_date)
10063 
      oprot.writeFieldEnd()
3431 rajveer 10064 
    if self.warehouse_id is not None:
999 varun.gupt 10065 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10066 
      oprot.writeI64(self.warehouse_id)
10067 
      oprot.writeFieldEnd()
10068 
    oprot.writeFieldStop()
10069 
    oprot.writeStructEnd()
10070 
 
3431 rajveer 10071 
  def validate(self):
10072 
    return
10073 
 
10074 
 
999 varun.gupt 10075 
  def __repr__(self):
10076 
    L = ['%s=%r' % (key, value)
10077 
      for key, value in self.__dict__.iteritems()]
10078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10079 
 
10080 
  def __eq__(self, other):
10081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10082 
 
10083 
  def __ne__(self, other):
10084 
    return not (self == other)
10085 
 
10086 
class getOrdersByBillingDate_result:
10087 
  """
10088 
  Attributes:
10089 
   - success
10090 
   - ex
10091 
  """
10092 
 
10093 
  thrift_spec = (
10094 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10096 
  )
10097 
 
10098 
  def __init__(self, success=None, ex=None,):
10099 
    self.success = success
10100 
    self.ex = ex
10101 
 
10102 
  def read(self, iprot):
10103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10105 
      return
10106 
    iprot.readStructBegin()
10107 
    while True:
10108 
      (fname, ftype, fid) = iprot.readFieldBegin()
10109 
      if ftype == TType.STOP:
10110 
        break
10111 
      if fid == 0:
10112 
        if ftype == TType.LIST:
10113 
          self.success = []
6188 rajveer 10114 
          (_etype158, _size155) = iprot.readListBegin()
10115 
          for _i159 in xrange(_size155):
10116 
            _elem160 = Order()
10117 
            _elem160.read(iprot)
10118 
            self.success.append(_elem160)
999 varun.gupt 10119 
          iprot.readListEnd()
10120 
        else:
10121 
          iprot.skip(ftype)
10122 
      elif fid == 1:
10123 
        if ftype == TType.STRUCT:
10124 
          self.ex = TransactionServiceException()
10125 
          self.ex.read(iprot)
10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      else:
10129 
        iprot.skip(ftype)
10130 
      iprot.readFieldEnd()
10131 
    iprot.readStructEnd()
10132 
 
10133 
  def write(self, oprot):
10134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10136 
      return
10137 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10138 
    if self.success is not None:
999 varun.gupt 10139 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10140 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10141 
      for iter161 in self.success:
10142 
        iter161.write(oprot)
999 varun.gupt 10143 
      oprot.writeListEnd()
10144 
      oprot.writeFieldEnd()
3431 rajveer 10145 
    if self.ex is not None:
999 varun.gupt 10146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10147 
      self.ex.write(oprot)
10148 
      oprot.writeFieldEnd()
10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
3431 rajveer 10152 
  def validate(self):
10153 
    return
10154 
 
10155 
 
999 varun.gupt 10156 
  def __repr__(self):
10157 
    L = ['%s=%r' % (key, value)
10158 
      for key, value in self.__dict__.iteritems()]
10159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10160 
 
10161 
  def __eq__(self, other):
10162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10163 
 
10164 
  def __ne__(self, other):
10165 
    return not (self == other)
10166 
 
3427 chandransh 10167 
class getOrdersByShippingDate_args:
10168 
  """
10169 
  Attributes:
10170 
   - fromShippingDate
10171 
   - toShippingDate
10172 
   - providerId
10173 
   - warehouseId
3451 chandransh 10174 
   - cod
3427 chandransh 10175 
  """
10176 
 
10177 
  thrift_spec = (
10178 
    None, # 0
10179 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10180 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10181 
    (3, TType.I64, 'providerId', None, None, ), # 3
10182 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10183 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10184 
  )
10185 
 
3451 chandransh 10186 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10187 
    self.fromShippingDate = fromShippingDate
10188 
    self.toShippingDate = toShippingDate
10189 
    self.providerId = providerId
10190 
    self.warehouseId = warehouseId
3451 chandransh 10191 
    self.cod = cod
3427 chandransh 10192 
 
10193 
  def read(self, iprot):
10194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10196 
      return
10197 
    iprot.readStructBegin()
10198 
    while True:
10199 
      (fname, ftype, fid) = iprot.readFieldBegin()
10200 
      if ftype == TType.STOP:
10201 
        break
10202 
      if fid == 1:
10203 
        if ftype == TType.I64:
10204 
          self.fromShippingDate = iprot.readI64();
10205 
        else:
10206 
          iprot.skip(ftype)
10207 
      elif fid == 2:
10208 
        if ftype == TType.I64:
10209 
          self.toShippingDate = iprot.readI64();
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      elif fid == 3:
10213 
        if ftype == TType.I64:
10214 
          self.providerId = iprot.readI64();
10215 
        else:
10216 
          iprot.skip(ftype)
10217 
      elif fid == 4:
10218 
        if ftype == TType.I64:
10219 
          self.warehouseId = iprot.readI64();
10220 
        else:
10221 
          iprot.skip(ftype)
3451 chandransh 10222 
      elif fid == 5:
10223 
        if ftype == TType.BOOL:
10224 
          self.cod = iprot.readBool();
10225 
        else:
10226 
          iprot.skip(ftype)
3427 chandransh 10227 
      else:
10228 
        iprot.skip(ftype)
10229 
      iprot.readFieldEnd()
10230 
    iprot.readStructEnd()
10231 
 
10232 
  def write(self, oprot):
10233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10235 
      return
10236 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10237 
    if self.fromShippingDate is not None:
3427 chandransh 10238 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10239 
      oprot.writeI64(self.fromShippingDate)
10240 
      oprot.writeFieldEnd()
3431 rajveer 10241 
    if self.toShippingDate is not None:
3427 chandransh 10242 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10243 
      oprot.writeI64(self.toShippingDate)
10244 
      oprot.writeFieldEnd()
3431 rajveer 10245 
    if self.providerId is not None:
3427 chandransh 10246 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10247 
      oprot.writeI64(self.providerId)
10248 
      oprot.writeFieldEnd()
3431 rajveer 10249 
    if self.warehouseId is not None:
3427 chandransh 10250 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10251 
      oprot.writeI64(self.warehouseId)
10252 
      oprot.writeFieldEnd()
3451 chandransh 10253 
    if self.cod is not None:
10254 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10255 
      oprot.writeBool(self.cod)
10256 
      oprot.writeFieldEnd()
3427 chandransh 10257 
    oprot.writeFieldStop()
10258 
    oprot.writeStructEnd()
10259 
 
3431 rajveer 10260 
  def validate(self):
10261 
    return
10262 
 
10263 
 
3427 chandransh 10264 
  def __repr__(self):
10265 
    L = ['%s=%r' % (key, value)
10266 
      for key, value in self.__dict__.iteritems()]
10267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10268 
 
10269 
  def __eq__(self, other):
10270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10271 
 
10272 
  def __ne__(self, other):
10273 
    return not (self == other)
10274 
 
10275 
class getOrdersByShippingDate_result:
10276 
  """
10277 
  Attributes:
10278 
   - success
10279 
   - ex
10280 
  """
10281 
 
10282 
  thrift_spec = (
10283 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10285 
  )
10286 
 
10287 
  def __init__(self, success=None, ex=None,):
10288 
    self.success = success
10289 
    self.ex = ex
10290 
 
10291 
  def read(self, iprot):
10292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10294 
      return
10295 
    iprot.readStructBegin()
10296 
    while True:
10297 
      (fname, ftype, fid) = iprot.readFieldBegin()
10298 
      if ftype == TType.STOP:
10299 
        break
10300 
      if fid == 0:
10301 
        if ftype == TType.LIST:
10302 
          self.success = []
6188 rajveer 10303 
          (_etype165, _size162) = iprot.readListBegin()
10304 
          for _i166 in xrange(_size162):
10305 
            _elem167 = Order()
10306 
            _elem167.read(iprot)
10307 
            self.success.append(_elem167)
3427 chandransh 10308 
          iprot.readListEnd()
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      elif fid == 1:
10312 
        if ftype == TType.STRUCT:
10313 
          self.ex = TransactionServiceException()
10314 
          self.ex.read(iprot)
10315 
        else:
10316 
          iprot.skip(ftype)
10317 
      else:
10318 
        iprot.skip(ftype)
10319 
      iprot.readFieldEnd()
10320 
    iprot.readStructEnd()
10321 
 
10322 
  def write(self, oprot):
10323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10325 
      return
10326 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10327 
    if self.success is not None:
3427 chandransh 10328 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10329 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10330 
      for iter168 in self.success:
10331 
        iter168.write(oprot)
3427 chandransh 10332 
      oprot.writeListEnd()
10333 
      oprot.writeFieldEnd()
3431 rajveer 10334 
    if self.ex is not None:
3427 chandransh 10335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10336 
      self.ex.write(oprot)
10337 
      oprot.writeFieldEnd()
10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
3431 rajveer 10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
3427 chandransh 10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
1382 varun.gupt 10356 
class getReturnableOrdersForCustomer_args:
10357 
  """
10358 
  Attributes:
10359 
   - customer_id
10360 
   - limit
10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    None, # 0
10365 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10366 
    (2, TType.I64, 'limit', None, None, ), # 2
10367 
  )
10368 
 
10369 
  def __init__(self, customer_id=None, limit=None,):
10370 
    self.customer_id = customer_id
10371 
    self.limit = limit
10372 
 
10373 
  def read(self, iprot):
10374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10376 
      return
10377 
    iprot.readStructBegin()
10378 
    while True:
10379 
      (fname, ftype, fid) = iprot.readFieldBegin()
10380 
      if ftype == TType.STOP:
10381 
        break
10382 
      if fid == 1:
10383 
        if ftype == TType.I64:
10384 
          self.customer_id = iprot.readI64();
10385 
        else:
10386 
          iprot.skip(ftype)
10387 
      elif fid == 2:
10388 
        if ftype == TType.I64:
10389 
          self.limit = iprot.readI64();
10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
10401 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10402 
    if self.customer_id is not None:
1382 varun.gupt 10403 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10404 
      oprot.writeI64(self.customer_id)
10405 
      oprot.writeFieldEnd()
3431 rajveer 10406 
    if self.limit is not None:
1382 varun.gupt 10407 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10408 
      oprot.writeI64(self.limit)
10409 
      oprot.writeFieldEnd()
10410 
    oprot.writeFieldStop()
10411 
    oprot.writeStructEnd()
10412 
 
3431 rajveer 10413 
  def validate(self):
10414 
    return
10415 
 
10416 
 
1382 varun.gupt 10417 
  def __repr__(self):
10418 
    L = ['%s=%r' % (key, value)
10419 
      for key, value in self.__dict__.iteritems()]
10420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10421 
 
10422 
  def __eq__(self, other):
10423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10424 
 
10425 
  def __ne__(self, other):
10426 
    return not (self == other)
10427 
 
10428 
class getReturnableOrdersForCustomer_result:
10429 
  """
10430 
  Attributes:
10431 
   - success
10432 
   - ex
10433 
  """
10434 
 
10435 
  thrift_spec = (
10436 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10437 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10438 
  )
10439 
 
10440 
  def __init__(self, success=None, ex=None,):
10441 
    self.success = success
10442 
    self.ex = ex
10443 
 
10444 
  def read(self, iprot):
10445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10447 
      return
10448 
    iprot.readStructBegin()
10449 
    while True:
10450 
      (fname, ftype, fid) = iprot.readFieldBegin()
10451 
      if ftype == TType.STOP:
10452 
        break
10453 
      if fid == 0:
10454 
        if ftype == TType.LIST:
10455 
          self.success = []
6188 rajveer 10456 
          (_etype172, _size169) = iprot.readListBegin()
10457 
          for _i173 in xrange(_size169):
10458 
            _elem174 = iprot.readI64();
10459 
            self.success.append(_elem174)
1382 varun.gupt 10460 
          iprot.readListEnd()
10461 
        else:
10462 
          iprot.skip(ftype)
10463 
      elif fid == 1:
10464 
        if ftype == TType.STRUCT:
10465 
          self.ex = TransactionServiceException()
10466 
          self.ex.read(iprot)
10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      else:
10470 
        iprot.skip(ftype)
10471 
      iprot.readFieldEnd()
10472 
    iprot.readStructEnd()
10473 
 
10474 
  def write(self, oprot):
10475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10477 
      return
10478 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10479 
    if self.success is not None:
1382 varun.gupt 10480 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10481 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10482 
      for iter175 in self.success:
10483 
        oprot.writeI64(iter175)
1382 varun.gupt 10484 
      oprot.writeListEnd()
10485 
      oprot.writeFieldEnd()
3431 rajveer 10486 
    if self.ex is not None:
1382 varun.gupt 10487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10488 
      self.ex.write(oprot)
10489 
      oprot.writeFieldEnd()
10490 
    oprot.writeFieldStop()
10491 
    oprot.writeStructEnd()
10492 
 
3431 rajveer 10493 
  def validate(self):
10494 
    return
10495 
 
10496 
 
1382 varun.gupt 10497 
  def __repr__(self):
10498 
    L = ['%s=%r' % (key, value)
10499 
      for key, value in self.__dict__.iteritems()]
10500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10501 
 
10502 
  def __eq__(self, other):
10503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10504 
 
10505 
  def __ne__(self, other):
10506 
    return not (self == other)
10507 
 
10508 
class getCancellableOrdersForCustomer_args:
10509 
  """
10510 
  Attributes:
10511 
   - customer_id
10512 
   - limit
10513 
  """
10514 
 
10515 
  thrift_spec = (
10516 
    None, # 0
10517 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10518 
    (2, TType.I64, 'limit', None, None, ), # 2
10519 
  )
10520 
 
10521 
  def __init__(self, customer_id=None, limit=None,):
10522 
    self.customer_id = customer_id
10523 
    self.limit = limit
10524 
 
10525 
  def read(self, iprot):
10526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10528 
      return
10529 
    iprot.readStructBegin()
10530 
    while True:
10531 
      (fname, ftype, fid) = iprot.readFieldBegin()
10532 
      if ftype == TType.STOP:
10533 
        break
10534 
      if fid == 1:
10535 
        if ftype == TType.I64:
10536 
          self.customer_id = iprot.readI64();
10537 
        else:
10538 
          iprot.skip(ftype)
10539 
      elif fid == 2:
10540 
        if ftype == TType.I64:
10541 
          self.limit = iprot.readI64();
10542 
        else:
10543 
          iprot.skip(ftype)
10544 
      else:
10545 
        iprot.skip(ftype)
10546 
      iprot.readFieldEnd()
10547 
    iprot.readStructEnd()
10548 
 
10549 
  def write(self, oprot):
10550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10552 
      return
10553 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10554 
    if self.customer_id is not None:
1382 varun.gupt 10555 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10556 
      oprot.writeI64(self.customer_id)
10557 
      oprot.writeFieldEnd()
3431 rajveer 10558 
    if self.limit is not None:
1382 varun.gupt 10559 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10560 
      oprot.writeI64(self.limit)
10561 
      oprot.writeFieldEnd()
10562 
    oprot.writeFieldStop()
10563 
    oprot.writeStructEnd()
10564 
 
3431 rajveer 10565 
  def validate(self):
10566 
    return
10567 
 
10568 
 
1382 varun.gupt 10569 
  def __repr__(self):
10570 
    L = ['%s=%r' % (key, value)
10571 
      for key, value in self.__dict__.iteritems()]
10572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10573 
 
10574 
  def __eq__(self, other):
10575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10576 
 
10577 
  def __ne__(self, other):
10578 
    return not (self == other)
10579 
 
10580 
class getCancellableOrdersForCustomer_result:
10581 
  """
10582 
  Attributes:
10583 
   - success
10584 
   - ex
10585 
  """
10586 
 
10587 
  thrift_spec = (
10588 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10590 
  )
10591 
 
10592 
  def __init__(self, success=None, ex=None,):
10593 
    self.success = success
10594 
    self.ex = ex
10595 
 
10596 
  def read(self, iprot):
10597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10599 
      return
10600 
    iprot.readStructBegin()
10601 
    while True:
10602 
      (fname, ftype, fid) = iprot.readFieldBegin()
10603 
      if ftype == TType.STOP:
10604 
        break
10605 
      if fid == 0:
10606 
        if ftype == TType.LIST:
10607 
          self.success = []
6188 rajveer 10608 
          (_etype179, _size176) = iprot.readListBegin()
10609 
          for _i180 in xrange(_size176):
10610 
            _elem181 = iprot.readI64();
10611 
            self.success.append(_elem181)
1382 varun.gupt 10612 
          iprot.readListEnd()
10613 
        else:
10614 
          iprot.skip(ftype)
10615 
      elif fid == 1:
10616 
        if ftype == TType.STRUCT:
10617 
          self.ex = TransactionServiceException()
10618 
          self.ex.read(iprot)
10619 
        else:
10620 
          iprot.skip(ftype)
10621 
      else:
10622 
        iprot.skip(ftype)
10623 
      iprot.readFieldEnd()
10624 
    iprot.readStructEnd()
10625 
 
10626 
  def write(self, oprot):
10627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10629 
      return
10630 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10631 
    if self.success is not None:
1382 varun.gupt 10632 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10633 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10634 
      for iter182 in self.success:
10635 
        oprot.writeI64(iter182)
1382 varun.gupt 10636 
      oprot.writeListEnd()
10637 
      oprot.writeFieldEnd()
3431 rajveer 10638 
    if self.ex is not None:
1382 varun.gupt 10639 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10640 
      self.ex.write(oprot)
10641 
      oprot.writeFieldEnd()
10642 
    oprot.writeFieldStop()
10643 
    oprot.writeStructEnd()
10644 
 
3431 rajveer 10645 
  def validate(self):
10646 
    return
10647 
 
10648 
 
1382 varun.gupt 10649 
  def __repr__(self):
10650 
    L = ['%s=%r' % (key, value)
10651 
      for key, value in self.__dict__.iteritems()]
10652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10653 
 
10654 
  def __eq__(self, other):
10655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10656 
 
10657 
  def __ne__(self, other):
10658 
    return not (self == other)
10659 
 
483 rajveer 10660 
class changeOrderStatus_args:
94 ashish 10661 
  """
10662 
  Attributes:
483 rajveer 10663 
   - orderId
10664 
   - status
10665 
   - description
94 ashish 10666 
  """
10667 
 
10668 
  thrift_spec = (
10669 
    None, # 0
483 rajveer 10670 
    (1, TType.I64, 'orderId', None, None, ), # 1
10671 
    (2, TType.I32, 'status', None, None, ), # 2
10672 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10673 
  )
10674 
 
483 rajveer 10675 
  def __init__(self, orderId=None, status=None, description=None,):
10676 
    self.orderId = orderId
10677 
    self.status = status
10678 
    self.description = description
94 ashish 10679 
 
10680 
  def read(self, iprot):
10681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10683 
      return
10684 
    iprot.readStructBegin()
10685 
    while True:
10686 
      (fname, ftype, fid) = iprot.readFieldBegin()
10687 
      if ftype == TType.STOP:
10688 
        break
10689 
      if fid == 1:
10690 
        if ftype == TType.I64:
483 rajveer 10691 
          self.orderId = iprot.readI64();
94 ashish 10692 
        else:
10693 
          iprot.skip(ftype)
10694 
      elif fid == 2:
483 rajveer 10695 
        if ftype == TType.I32:
10696 
          self.status = iprot.readI32();
94 ashish 10697 
        else:
10698 
          iprot.skip(ftype)
483 rajveer 10699 
      elif fid == 3:
10700 
        if ftype == TType.STRING:
10701 
          self.description = iprot.readString();
10702 
        else:
10703 
          iprot.skip(ftype)
94 ashish 10704 
      else:
10705 
        iprot.skip(ftype)
10706 
      iprot.readFieldEnd()
10707 
    iprot.readStructEnd()
10708 
 
10709 
  def write(self, oprot):
10710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10712 
      return
483 rajveer 10713 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10714 
    if self.orderId is not None:
483 rajveer 10715 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10716 
      oprot.writeI64(self.orderId)
94 ashish 10717 
      oprot.writeFieldEnd()
3431 rajveer 10718 
    if self.status is not None:
483 rajveer 10719 
      oprot.writeFieldBegin('status', TType.I32, 2)
10720 
      oprot.writeI32(self.status)
94 ashish 10721 
      oprot.writeFieldEnd()
3431 rajveer 10722 
    if self.description is not None:
483 rajveer 10723 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10724 
      oprot.writeString(self.description)
10725 
      oprot.writeFieldEnd()
94 ashish 10726 
    oprot.writeFieldStop()
10727 
    oprot.writeStructEnd()
10728 
 
3431 rajveer 10729 
  def validate(self):
10730 
    return
10731 
 
10732 
 
94 ashish 10733 
  def __repr__(self):
10734 
    L = ['%s=%r' % (key, value)
10735 
      for key, value in self.__dict__.iteritems()]
10736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10737 
 
10738 
  def __eq__(self, other):
10739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10740 
 
10741 
  def __ne__(self, other):
10742 
    return not (self == other)
10743 
 
483 rajveer 10744 
class changeOrderStatus_result:
94 ashish 10745 
  """
10746 
  Attributes:
10747 
   - success
10748 
   - ex
10749 
  """
10750 
 
10751 
  thrift_spec = (
10752 
    (0, TType.BOOL, 'success', None, None, ), # 0
10753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10754 
  )
10755 
 
10756 
  def __init__(self, success=None, ex=None,):
10757 
    self.success = success
10758 
    self.ex = ex
10759 
 
10760 
  def read(self, iprot):
10761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10763 
      return
10764 
    iprot.readStructBegin()
10765 
    while True:
10766 
      (fname, ftype, fid) = iprot.readFieldBegin()
10767 
      if ftype == TType.STOP:
10768 
        break
10769 
      if fid == 0:
10770 
        if ftype == TType.BOOL:
10771 
          self.success = iprot.readBool();
10772 
        else:
10773 
          iprot.skip(ftype)
10774 
      elif fid == 1:
10775 
        if ftype == TType.STRUCT:
10776 
          self.ex = TransactionServiceException()
10777 
          self.ex.read(iprot)
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
483 rajveer 10789 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10790 
    if self.success is not None:
94 ashish 10791 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10792 
      oprot.writeBool(self.success)
10793 
      oprot.writeFieldEnd()
3431 rajveer 10794 
    if self.ex is not None:
94 ashish 10795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10796 
      self.ex.write(oprot)
10797 
      oprot.writeFieldEnd()
10798 
    oprot.writeFieldStop()
10799 
    oprot.writeStructEnd()
10800 
 
3431 rajveer 10801 
  def validate(self):
10802 
    return
10803 
 
10804 
 
94 ashish 10805 
  def __repr__(self):
10806 
    L = ['%s=%r' % (key, value)
10807 
      for key, value in self.__dict__.iteritems()]
10808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10809 
 
10810 
  def __eq__(self, other):
10811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10812 
 
10813 
  def __ne__(self, other):
10814 
    return not (self == other)
10815 
 
3064 chandransh 10816 
class getOrdersForTransaction_args:
494 rajveer 10817 
  """
10818 
  Attributes:
3064 chandransh 10819 
   - transactionId
10820 
   - customerId
494 rajveer 10821 
  """
10822 
 
10823 
  thrift_spec = (
10824 
    None, # 0
3064 chandransh 10825 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10826 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10827 
  )
10828 
 
3064 chandransh 10829 
  def __init__(self, transactionId=None, customerId=None,):
10830 
    self.transactionId = transactionId
10831 
    self.customerId = customerId
494 rajveer 10832 
 
10833 
  def read(self, iprot):
10834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10836 
      return
10837 
    iprot.readStructBegin()
10838 
    while True:
10839 
      (fname, ftype, fid) = iprot.readFieldBegin()
10840 
      if ftype == TType.STOP:
10841 
        break
10842 
      if fid == 1:
10843 
        if ftype == TType.I64:
3064 chandransh 10844 
          self.transactionId = iprot.readI64();
494 rajveer 10845 
        else:
10846 
          iprot.skip(ftype)
10847 
      elif fid == 2:
3064 chandransh 10848 
        if ftype == TType.I64:
10849 
          self.customerId = iprot.readI64();
494 rajveer 10850 
        else:
10851 
          iprot.skip(ftype)
10852 
      else:
10853 
        iprot.skip(ftype)
10854 
      iprot.readFieldEnd()
10855 
    iprot.readStructEnd()
10856 
 
10857 
  def write(self, oprot):
10858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10860 
      return
3064 chandransh 10861 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10862 
    if self.transactionId is not None:
3064 chandransh 10863 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10864 
      oprot.writeI64(self.transactionId)
494 rajveer 10865 
      oprot.writeFieldEnd()
3431 rajveer 10866 
    if self.customerId is not None:
3064 chandransh 10867 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10868 
      oprot.writeI64(self.customerId)
494 rajveer 10869 
      oprot.writeFieldEnd()
10870 
    oprot.writeFieldStop()
10871 
    oprot.writeStructEnd()
10872 
 
3431 rajveer 10873 
  def validate(self):
10874 
    return
10875 
 
10876 
 
494 rajveer 10877 
  def __repr__(self):
10878 
    L = ['%s=%r' % (key, value)
10879 
      for key, value in self.__dict__.iteritems()]
10880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10881 
 
10882 
  def __eq__(self, other):
10883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10884 
 
10885 
  def __ne__(self, other):
10886 
    return not (self == other)
10887 
 
3064 chandransh 10888 
class getOrdersForTransaction_result:
494 rajveer 10889 
  """
10890 
  Attributes:
10891 
   - success
10892 
   - ex
10893 
  """
10894 
 
10895 
  thrift_spec = (
3064 chandransh 10896 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10898 
  )
10899 
 
10900 
  def __init__(self, success=None, ex=None,):
10901 
    self.success = success
10902 
    self.ex = ex
10903 
 
10904 
  def read(self, iprot):
10905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10907 
      return
10908 
    iprot.readStructBegin()
10909 
    while True:
10910 
      (fname, ftype, fid) = iprot.readFieldBegin()
10911 
      if ftype == TType.STOP:
10912 
        break
10913 
      if fid == 0:
3064 chandransh 10914 
        if ftype == TType.LIST:
10915 
          self.success = []
6188 rajveer 10916 
          (_etype186, _size183) = iprot.readListBegin()
10917 
          for _i187 in xrange(_size183):
10918 
            _elem188 = Order()
10919 
            _elem188.read(iprot)
10920 
            self.success.append(_elem188)
3064 chandransh 10921 
          iprot.readListEnd()
494 rajveer 10922 
        else:
10923 
          iprot.skip(ftype)
10924 
      elif fid == 1:
10925 
        if ftype == TType.STRUCT:
10926 
          self.ex = TransactionServiceException()
10927 
          self.ex.read(iprot)
10928 
        else:
10929 
          iprot.skip(ftype)
10930 
      else:
10931 
        iprot.skip(ftype)
10932 
      iprot.readFieldEnd()
10933 
    iprot.readStructEnd()
10934 
 
10935 
  def write(self, oprot):
10936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10938 
      return
3064 chandransh 10939 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10940 
    if self.success is not None:
3064 chandransh 10941 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10942 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10943 
      for iter189 in self.success:
10944 
        iter189.write(oprot)
3064 chandransh 10945 
      oprot.writeListEnd()
494 rajveer 10946 
      oprot.writeFieldEnd()
3431 rajveer 10947 
    if self.ex is not None:
494 rajveer 10948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10949 
      self.ex.write(oprot)
10950 
      oprot.writeFieldEnd()
10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
3431 rajveer 10954 
  def validate(self):
10955 
    return
10956 
 
10957 
 
494 rajveer 10958 
  def __repr__(self):
10959 
    L = ['%s=%r' % (key, value)
10960 
      for key, value in self.__dict__.iteritems()]
10961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10962 
 
10963 
  def __eq__(self, other):
10964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10965 
 
10966 
  def __ne__(self, other):
10967 
    return not (self == other)
10968 
 
3064 chandransh 10969 
class getOrdersForCustomer_args:
1149 chandransh 10970 
  """
10971 
  Attributes:
3064 chandransh 10972 
   - customerId
10973 
   - from_date
10974 
   - to_date
10975 
   - statuses
1149 chandransh 10976 
  """
10977 
 
10978 
  thrift_spec = (
10979 
    None, # 0
3064 chandransh 10980 
    (1, TType.I64, 'customerId', None, None, ), # 1
10981 
    (2, TType.I64, 'from_date', None, None, ), # 2
10982 
    (3, TType.I64, 'to_date', None, None, ), # 3
10983 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10984 
  )
10985 
 
3064 chandransh 10986 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10987 
    self.customerId = customerId
10988 
    self.from_date = from_date
10989 
    self.to_date = to_date
10990 
    self.statuses = statuses
1149 chandransh 10991 
 
10992 
  def read(self, iprot):
10993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10995 
      return
10996 
    iprot.readStructBegin()
10997 
    while True:
10998 
      (fname, ftype, fid) = iprot.readFieldBegin()
10999 
      if ftype == TType.STOP:
11000 
        break
11001 
      if fid == 1:
11002 
        if ftype == TType.I64:
3064 chandransh 11003 
          self.customerId = iprot.readI64();
1149 chandransh 11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      elif fid == 2:
11007 
        if ftype == TType.I64:
3064 chandransh 11008 
          self.from_date = iprot.readI64();
1149 chandransh 11009 
        else:
11010 
          iprot.skip(ftype)
2783 chandransh 11011 
      elif fid == 3:
11012 
        if ftype == TType.I64:
3064 chandransh 11013 
          self.to_date = iprot.readI64();
2783 chandransh 11014 
        else:
11015 
          iprot.skip(ftype)
11016 
      elif fid == 4:
3064 chandransh 11017 
        if ftype == TType.LIST:
11018 
          self.statuses = []
6188 rajveer 11019 
          (_etype193, _size190) = iprot.readListBegin()
11020 
          for _i194 in xrange(_size190):
11021 
            _elem195 = iprot.readI32();
11022 
            self.statuses.append(_elem195)
3064 chandransh 11023 
          iprot.readListEnd()
2783 chandransh 11024 
        else:
11025 
          iprot.skip(ftype)
1149 chandransh 11026 
      else:
11027 
        iprot.skip(ftype)
11028 
      iprot.readFieldEnd()
11029 
    iprot.readStructEnd()
11030 
 
11031 
  def write(self, oprot):
11032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11034 
      return
3064 chandransh 11035 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11036 
    if self.customerId is not None:
3064 chandransh 11037 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11038 
      oprot.writeI64(self.customerId)
1149 chandransh 11039 
      oprot.writeFieldEnd()
3431 rajveer 11040 
    if self.from_date is not None:
3064 chandransh 11041 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11042 
      oprot.writeI64(self.from_date)
1149 chandransh 11043 
      oprot.writeFieldEnd()
3431 rajveer 11044 
    if self.to_date is not None:
3064 chandransh 11045 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11046 
      oprot.writeI64(self.to_date)
2783 chandransh 11047 
      oprot.writeFieldEnd()
3431 rajveer 11048 
    if self.statuses is not None:
3064 chandransh 11049 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11050 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11051 
      for iter196 in self.statuses:
11052 
        oprot.writeI32(iter196)
3064 chandransh 11053 
      oprot.writeListEnd()
2783 chandransh 11054 
      oprot.writeFieldEnd()
1149 chandransh 11055 
    oprot.writeFieldStop()
11056 
    oprot.writeStructEnd()
11057 
 
3431 rajveer 11058 
  def validate(self):
11059 
    return
11060 
 
11061 
 
1149 chandransh 11062 
  def __repr__(self):
11063 
    L = ['%s=%r' % (key, value)
11064 
      for key, value in self.__dict__.iteritems()]
11065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11066 
 
11067 
  def __eq__(self, other):
11068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11069 
 
11070 
  def __ne__(self, other):
11071 
    return not (self == other)
11072 
 
3064 chandransh 11073 
class getOrdersForCustomer_result:
1149 chandransh 11074 
  """
11075 
  Attributes:
11076 
   - success
11077 
   - ex
11078 
  """
11079 
 
11080 
  thrift_spec = (
3064 chandransh 11081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11083 
  )
11084 
 
11085 
  def __init__(self, success=None, ex=None,):
11086 
    self.success = success
11087 
    self.ex = ex
11088 
 
11089 
  def read(self, iprot):
11090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11092 
      return
11093 
    iprot.readStructBegin()
11094 
    while True:
11095 
      (fname, ftype, fid) = iprot.readFieldBegin()
11096 
      if ftype == TType.STOP:
11097 
        break
11098 
      if fid == 0:
3064 chandransh 11099 
        if ftype == TType.LIST:
11100 
          self.success = []
6188 rajveer 11101 
          (_etype200, _size197) = iprot.readListBegin()
11102 
          for _i201 in xrange(_size197):
11103 
            _elem202 = Order()
11104 
            _elem202.read(iprot)
11105 
            self.success.append(_elem202)
3064 chandransh 11106 
          iprot.readListEnd()
1149 chandransh 11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      elif fid == 1:
11110 
        if ftype == TType.STRUCT:
11111 
          self.ex = TransactionServiceException()
11112 
          self.ex.read(iprot)
11113 
        else:
11114 
          iprot.skip(ftype)
11115 
      else:
11116 
        iprot.skip(ftype)
11117 
      iprot.readFieldEnd()
11118 
    iprot.readStructEnd()
11119 
 
11120 
  def write(self, oprot):
11121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11123 
      return
3064 chandransh 11124 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11125 
    if self.success is not None:
3064 chandransh 11126 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11127 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11128 
      for iter203 in self.success:
11129 
        iter203.write(oprot)
3064 chandransh 11130 
      oprot.writeListEnd()
1149 chandransh 11131 
      oprot.writeFieldEnd()
3431 rajveer 11132 
    if self.ex is not None:
1149 chandransh 11133 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11134 
      self.ex.write(oprot)
11135 
      oprot.writeFieldEnd()
11136 
    oprot.writeFieldStop()
11137 
    oprot.writeStructEnd()
11138 
 
3431 rajveer 11139 
  def validate(self):
11140 
    return
11141 
 
11142 
 
1149 chandransh 11143 
  def __repr__(self):
11144 
    L = ['%s=%r' % (key, value)
11145 
      for key, value in self.__dict__.iteritems()]
11146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11147 
 
11148 
  def __eq__(self, other):
11149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11150 
 
11151 
  def __ne__(self, other):
11152 
    return not (self == other)
11153 
 
3064 chandransh 11154 
class createOrder_args:
921 rajveer 11155 
  """
11156 
  Attributes:
3064 chandransh 11157 
   - order
921 rajveer 11158 
  """
11159 
 
11160 
  thrift_spec = (
11161 
    None, # 0
3064 chandransh 11162 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11163 
  )
11164 
 
3064 chandransh 11165 
  def __init__(self, order=None,):
11166 
    self.order = order
921 rajveer 11167 
 
11168 
  def read(self, iprot):
11169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11171 
      return
11172 
    iprot.readStructBegin()
11173 
    while True:
11174 
      (fname, ftype, fid) = iprot.readFieldBegin()
11175 
      if ftype == TType.STOP:
11176 
        break
11177 
      if fid == 1:
3064 chandransh 11178 
        if ftype == TType.STRUCT:
11179 
          self.order = Order()
11180 
          self.order.read(iprot)
921 rajveer 11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      else:
11184 
        iprot.skip(ftype)
11185 
      iprot.readFieldEnd()
11186 
    iprot.readStructEnd()
11187 
 
11188 
  def write(self, oprot):
11189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11191 
      return
3064 chandransh 11192 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11193 
    if self.order is not None:
3064 chandransh 11194 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11195 
      self.order.write(oprot)
921 rajveer 11196 
      oprot.writeFieldEnd()
11197 
    oprot.writeFieldStop()
11198 
    oprot.writeStructEnd()
11199 
 
3431 rajveer 11200 
  def validate(self):
11201 
    return
11202 
 
11203 
 
921 rajveer 11204 
  def __repr__(self):
11205 
    L = ['%s=%r' % (key, value)
11206 
      for key, value in self.__dict__.iteritems()]
11207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11208 
 
11209 
  def __eq__(self, other):
11210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11211 
 
11212 
  def __ne__(self, other):
11213 
    return not (self == other)
11214 
 
3064 chandransh 11215 
class createOrder_result:
921 rajveer 11216 
  """
11217 
  Attributes:
11218 
   - success
11219 
   - ex
11220 
  """
11221 
 
11222 
  thrift_spec = (
3064 chandransh 11223 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11224 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11225 
  )
11226 
 
11227 
  def __init__(self, success=None, ex=None,):
11228 
    self.success = success
11229 
    self.ex = ex
11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 0:
3064 chandransh 11241 
        if ftype == TType.I64:
11242 
          self.success = iprot.readI64();
921 rajveer 11243 
        else:
11244 
          iprot.skip(ftype)
11245 
      elif fid == 1:
11246 
        if ftype == TType.STRUCT:
11247 
          self.ex = TransactionServiceException()
11248 
          self.ex.read(iprot)
11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      else:
11252 
        iprot.skip(ftype)
11253 
      iprot.readFieldEnd()
11254 
    iprot.readStructEnd()
11255 
 
11256 
  def write(self, oprot):
11257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11259 
      return
3064 chandransh 11260 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11261 
    if self.success is not None:
3064 chandransh 11262 
      oprot.writeFieldBegin('success', TType.I64, 0)
11263 
      oprot.writeI64(self.success)
921 rajveer 11264 
      oprot.writeFieldEnd()
3431 rajveer 11265 
    if self.ex is not None:
921 rajveer 11266 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11267 
      self.ex.write(oprot)
11268 
      oprot.writeFieldEnd()
11269 
    oprot.writeFieldStop()
11270 
    oprot.writeStructEnd()
11271 
 
3431 rajveer 11272 
  def validate(self):
11273 
    return
11274 
 
11275 
 
921 rajveer 11276 
  def __repr__(self):
11277 
    L = ['%s=%r' % (key, value)
11278 
      for key, value in self.__dict__.iteritems()]
11279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11280 
 
11281 
  def __eq__(self, other):
11282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11283 
 
11284 
  def __ne__(self, other):
11285 
    return not (self == other)
11286 
 
3064 chandransh 11287 
class getOrder_args:
921 rajveer 11288 
  """
11289 
  Attributes:
3064 chandransh 11290 
   - id
921 rajveer 11291 
  """
11292 
 
11293 
  thrift_spec = (
11294 
    None, # 0
3064 chandransh 11295 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11296 
  )
11297 
 
3064 chandransh 11298 
  def __init__(self, id=None,):
11299 
    self.id = id
921 rajveer 11300 
 
11301 
  def read(self, iprot):
11302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11304 
      return
11305 
    iprot.readStructBegin()
11306 
    while True:
11307 
      (fname, ftype, fid) = iprot.readFieldBegin()
11308 
      if ftype == TType.STOP:
11309 
        break
11310 
      if fid == 1:
11311 
        if ftype == TType.I64:
3064 chandransh 11312 
          self.id = iprot.readI64();
921 rajveer 11313 
        else:
11314 
          iprot.skip(ftype)
11315 
      else:
11316 
        iprot.skip(ftype)
11317 
      iprot.readFieldEnd()
11318 
    iprot.readStructEnd()
11319 
 
11320 
  def write(self, oprot):
11321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11323 
      return
3064 chandransh 11324 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11325 
    if self.id is not None:
3064 chandransh 11326 
      oprot.writeFieldBegin('id', TType.I64, 1)
11327 
      oprot.writeI64(self.id)
921 rajveer 11328 
      oprot.writeFieldEnd()
11329 
    oprot.writeFieldStop()
11330 
    oprot.writeStructEnd()
11331 
 
3431 rajveer 11332 
  def validate(self):
11333 
    return
11334 
 
11335 
 
921 rajveer 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 getOrder_result:
921 rajveer 11348 
  """
11349 
  Attributes:
11350 
   - success
11351 
   - ex
11352 
  """
11353 
 
11354 
  thrift_spec = (
3064 chandransh 11355 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11356 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11357 
  )
11358 
 
11359 
  def __init__(self, success=None, ex=None,):
11360 
    self.success = success
11361 
    self.ex = ex
11362 
 
11363 
  def read(self, iprot):
11364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11366 
      return
11367 
    iprot.readStructBegin()
11368 
    while True:
11369 
      (fname, ftype, fid) = iprot.readFieldBegin()
11370 
      if ftype == TType.STOP:
11371 
        break
11372 
      if fid == 0:
3064 chandransh 11373 
        if ftype == TType.STRUCT:
11374 
          self.success = Order()
11375 
          self.success.read(iprot)
921 rajveer 11376 
        else:
11377 
          iprot.skip(ftype)
11378 
      elif fid == 1:
11379 
        if ftype == TType.STRUCT:
11380 
          self.ex = TransactionServiceException()
11381 
          self.ex.read(iprot)
11382 
        else:
11383 
          iprot.skip(ftype)
11384 
      else:
11385 
        iprot.skip(ftype)
11386 
      iprot.readFieldEnd()
11387 
    iprot.readStructEnd()
11388 
 
11389 
  def write(self, oprot):
11390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11392 
      return
3064 chandransh 11393 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11394 
    if self.success is not None:
3064 chandransh 11395 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11396 
      self.success.write(oprot)
921 rajveer 11397 
      oprot.writeFieldEnd()
3431 rajveer 11398 
    if self.ex is not None:
921 rajveer 11399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11400 
      self.ex.write(oprot)
11401 
      oprot.writeFieldEnd()
11402 
    oprot.writeFieldStop()
11403 
    oprot.writeStructEnd()
11404 
 
3431 rajveer 11405 
  def validate(self):
11406 
    return
11407 
 
11408 
 
921 rajveer 11409 
  def __repr__(self):
11410 
    L = ['%s=%r' % (key, value)
11411 
      for key, value in self.__dict__.iteritems()]
11412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11413 
 
11414 
  def __eq__(self, other):
11415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11416 
 
11417 
  def __ne__(self, other):
11418 
    return not (self == other)
11419 
 
3064 chandransh 11420 
class getLineItemsForOrder_args:
94 ashish 11421 
  """
11422 
  Attributes:
3064 chandransh 11423 
   - orderId
94 ashish 11424 
  """
11425 
 
11426 
  thrift_spec = (
11427 
    None, # 0
3064 chandransh 11428 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11429 
  )
11430 
 
3064 chandransh 11431 
  def __init__(self, orderId=None,):
11432 
    self.orderId = orderId
94 ashish 11433 
 
11434 
  def read(self, iprot):
11435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11437 
      return
11438 
    iprot.readStructBegin()
11439 
    while True:
11440 
      (fname, ftype, fid) = iprot.readFieldBegin()
11441 
      if ftype == TType.STOP:
11442 
        break
11443 
      if fid == 1:
11444 
        if ftype == TType.I64:
3064 chandransh 11445 
          self.orderId = iprot.readI64();
94 ashish 11446 
        else:
11447 
          iprot.skip(ftype)
11448 
      else:
11449 
        iprot.skip(ftype)
11450 
      iprot.readFieldEnd()
11451 
    iprot.readStructEnd()
11452 
 
11453 
  def write(self, oprot):
11454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11456 
      return
3064 chandransh 11457 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11458 
    if self.orderId is not None:
3064 chandransh 11459 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11460 
      oprot.writeI64(self.orderId)
94 ashish 11461 
      oprot.writeFieldEnd()
11462 
    oprot.writeFieldStop()
11463 
    oprot.writeStructEnd()
11464 
 
3431 rajveer 11465 
  def validate(self):
11466 
    return
11467 
 
11468 
 
94 ashish 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 getLineItemsForOrder_result:
94 ashish 11481 
  """
11482 
  Attributes:
11483 
   - success
11484 
   - ex
11485 
  """
11486 
 
11487 
  thrift_spec = (
3064 chandransh 11488 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11489 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11490 
  )
11491 
 
11492 
  def __init__(self, success=None, ex=None,):
11493 
    self.success = success
11494 
    self.ex = ex
11495 
 
11496 
  def read(self, iprot):
11497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11499 
      return
11500 
    iprot.readStructBegin()
11501 
    while True:
11502 
      (fname, ftype, fid) = iprot.readFieldBegin()
11503 
      if ftype == TType.STOP:
11504 
        break
11505 
      if fid == 0:
483 rajveer 11506 
        if ftype == TType.LIST:
11507 
          self.success = []
6188 rajveer 11508 
          (_etype207, _size204) = iprot.readListBegin()
11509 
          for _i208 in xrange(_size204):
11510 
            _elem209 = LineItem()
11511 
            _elem209.read(iprot)
11512 
            self.success.append(_elem209)
483 rajveer 11513 
          iprot.readListEnd()
94 ashish 11514 
        else:
11515 
          iprot.skip(ftype)
11516 
      elif fid == 1:
11517 
        if ftype == TType.STRUCT:
11518 
          self.ex = TransactionServiceException()
11519 
          self.ex.read(iprot)
11520 
        else:
11521 
          iprot.skip(ftype)
11522 
      else:
11523 
        iprot.skip(ftype)
11524 
      iprot.readFieldEnd()
11525 
    iprot.readStructEnd()
11526 
 
11527 
  def write(self, oprot):
11528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11530 
      return
3064 chandransh 11531 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11532 
    if self.success is not None:
483 rajveer 11533 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11534 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11535 
      for iter210 in self.success:
11536 
        iter210.write(oprot)
483 rajveer 11537 
      oprot.writeListEnd()
94 ashish 11538 
      oprot.writeFieldEnd()
3431 rajveer 11539 
    if self.ex is not None:
94 ashish 11540 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11541 
      self.ex.write(oprot)
11542 
      oprot.writeFieldEnd()
11543 
    oprot.writeFieldStop()
11544 
    oprot.writeStructEnd()
11545 
 
3431 rajveer 11546 
  def validate(self):
11547 
    return
11548 
 
11549 
 
94 ashish 11550 
  def __repr__(self):
11551 
    L = ['%s=%r' % (key, value)
11552 
      for key, value in self.__dict__.iteritems()]
11553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11554 
 
11555 
  def __eq__(self, other):
11556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11557 
 
11558 
  def __ne__(self, other):
11559 
    return not (self == other)
11560 
 
4999 phani.kuma 11561 
class getOrderList_args:
11562 
  """
11563 
  Attributes:
11564 
   - order_ids
11565 
  """
11566 
 
11567 
  thrift_spec = (
11568 
    None, # 0
11569 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11570 
  )
11571 
 
11572 
  def __init__(self, order_ids=None,):
11573 
    self.order_ids = order_ids
11574 
 
11575 
  def read(self, iprot):
11576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11578 
      return
11579 
    iprot.readStructBegin()
11580 
    while True:
11581 
      (fname, ftype, fid) = iprot.readFieldBegin()
11582 
      if ftype == TType.STOP:
11583 
        break
11584 
      if fid == 1:
11585 
        if ftype == TType.LIST:
11586 
          self.order_ids = []
6188 rajveer 11587 
          (_etype214, _size211) = iprot.readListBegin()
11588 
          for _i215 in xrange(_size211):
11589 
            _elem216 = iprot.readI64();
11590 
            self.order_ids.append(_elem216)
4999 phani.kuma 11591 
          iprot.readListEnd()
11592 
        else:
11593 
          iprot.skip(ftype)
11594 
      else:
11595 
        iprot.skip(ftype)
11596 
      iprot.readFieldEnd()
11597 
    iprot.readStructEnd()
11598 
 
11599 
  def write(self, oprot):
11600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11602 
      return
11603 
    oprot.writeStructBegin('getOrderList_args')
11604 
    if self.order_ids is not None:
11605 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11606 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11607 
      for iter217 in self.order_ids:
11608 
        oprot.writeI64(iter217)
4999 phani.kuma 11609 
      oprot.writeListEnd()
11610 
      oprot.writeFieldEnd()
11611 
    oprot.writeFieldStop()
11612 
    oprot.writeStructEnd()
11613 
 
11614 
  def validate(self):
11615 
    return
11616 
 
11617 
 
11618 
  def __repr__(self):
11619 
    L = ['%s=%r' % (key, value)
11620 
      for key, value in self.__dict__.iteritems()]
11621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11622 
 
11623 
  def __eq__(self, other):
11624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11625 
 
11626 
  def __ne__(self, other):
11627 
    return not (self == other)
11628 
 
11629 
class getOrderList_result:
11630 
  """
11631 
  Attributes:
11632 
   - success
11633 
  """
11634 
 
11635 
  thrift_spec = (
11636 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11637 
  )
11638 
 
11639 
  def __init__(self, success=None,):
11640 
    self.success = success
11641 
 
11642 
  def read(self, iprot):
11643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11645 
      return
11646 
    iprot.readStructBegin()
11647 
    while True:
11648 
      (fname, ftype, fid) = iprot.readFieldBegin()
11649 
      if ftype == TType.STOP:
11650 
        break
11651 
      if fid == 0:
11652 
        if ftype == TType.LIST:
11653 
          self.success = []
6188 rajveer 11654 
          (_etype221, _size218) = iprot.readListBegin()
11655 
          for _i222 in xrange(_size218):
11656 
            _elem223 = Order()
11657 
            _elem223.read(iprot)
11658 
            self.success.append(_elem223)
4999 phani.kuma 11659 
          iprot.readListEnd()
11660 
        else:
11661 
          iprot.skip(ftype)
11662 
      else:
11663 
        iprot.skip(ftype)
11664 
      iprot.readFieldEnd()
11665 
    iprot.readStructEnd()
11666 
 
11667 
  def write(self, oprot):
11668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11670 
      return
11671 
    oprot.writeStructBegin('getOrderList_result')
11672 
    if self.success is not None:
11673 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11674 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11675 
      for iter224 in self.success:
11676 
        iter224.write(oprot)
4999 phani.kuma 11677 
      oprot.writeListEnd()
11678 
      oprot.writeFieldEnd()
11679 
    oprot.writeFieldStop()
11680 
    oprot.writeStructEnd()
11681 
 
11682 
  def validate(self):
11683 
    return
11684 
 
11685 
 
11686 
  def __repr__(self):
11687 
    L = ['%s=%r' % (key, value)
11688 
      for key, value in self.__dict__.iteritems()]
11689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11690 
 
11691 
  def __eq__(self, other):
11692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11693 
 
11694 
  def __ne__(self, other):
11695 
    return not (self == other)
11696 
 
5386 phani.kuma 11697 
class getOrderListForVendor_args:
11698 
  """
11699 
  Attributes:
11700 
   - order_ids
11701 
   - vendorId
11702 
  """
11703 
 
11704 
  thrift_spec = (
11705 
    None, # 0
11706 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11707 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11708 
  )
11709 
 
11710 
  def __init__(self, order_ids=None, vendorId=None,):
11711 
    self.order_ids = order_ids
11712 
    self.vendorId = vendorId
11713 
 
11714 
  def read(self, iprot):
11715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11717 
      return
11718 
    iprot.readStructBegin()
11719 
    while True:
11720 
      (fname, ftype, fid) = iprot.readFieldBegin()
11721 
      if ftype == TType.STOP:
11722 
        break
11723 
      if fid == 1:
11724 
        if ftype == TType.LIST:
11725 
          self.order_ids = []
6188 rajveer 11726 
          (_etype228, _size225) = iprot.readListBegin()
11727 
          for _i229 in xrange(_size225):
11728 
            _elem230 = iprot.readI64();
11729 
            self.order_ids.append(_elem230)
5386 phani.kuma 11730 
          iprot.readListEnd()
11731 
        else:
11732 
          iprot.skip(ftype)
11733 
      elif fid == 2:
11734 
        if ftype == TType.I64:
11735 
          self.vendorId = iprot.readI64();
11736 
        else:
11737 
          iprot.skip(ftype)
11738 
      else:
11739 
        iprot.skip(ftype)
11740 
      iprot.readFieldEnd()
11741 
    iprot.readStructEnd()
11742 
 
11743 
  def write(self, oprot):
11744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11746 
      return
11747 
    oprot.writeStructBegin('getOrderListForVendor_args')
11748 
    if self.order_ids is not None:
11749 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11750 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11751 
      for iter231 in self.order_ids:
11752 
        oprot.writeI64(iter231)
5386 phani.kuma 11753 
      oprot.writeListEnd()
11754 
      oprot.writeFieldEnd()
11755 
    if self.vendorId is not None:
11756 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11757 
      oprot.writeI64(self.vendorId)
11758 
      oprot.writeFieldEnd()
11759 
    oprot.writeFieldStop()
11760 
    oprot.writeStructEnd()
11761 
 
11762 
  def validate(self):
11763 
    return
11764 
 
11765 
 
11766 
  def __repr__(self):
11767 
    L = ['%s=%r' % (key, value)
11768 
      for key, value in self.__dict__.iteritems()]
11769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11770 
 
11771 
  def __eq__(self, other):
11772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11773 
 
11774 
  def __ne__(self, other):
11775 
    return not (self == other)
11776 
 
11777 
class getOrderListForVendor_result:
11778 
  """
11779 
  Attributes:
11780 
   - success
11781 
  """
11782 
 
11783 
  thrift_spec = (
11784 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11785 
  )
11786 
 
11787 
  def __init__(self, success=None,):
11788 
    self.success = success
11789 
 
11790 
  def read(self, iprot):
11791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11793 
      return
11794 
    iprot.readStructBegin()
11795 
    while True:
11796 
      (fname, ftype, fid) = iprot.readFieldBegin()
11797 
      if ftype == TType.STOP:
11798 
        break
11799 
      if fid == 0:
11800 
        if ftype == TType.LIST:
11801 
          self.success = []
6188 rajveer 11802 
          (_etype235, _size232) = iprot.readListBegin()
11803 
          for _i236 in xrange(_size232):
11804 
            _elem237 = Order()
11805 
            _elem237.read(iprot)
11806 
            self.success.append(_elem237)
5386 phani.kuma 11807 
          iprot.readListEnd()
11808 
        else:
11809 
          iprot.skip(ftype)
11810 
      else:
11811 
        iprot.skip(ftype)
11812 
      iprot.readFieldEnd()
11813 
    iprot.readStructEnd()
11814 
 
11815 
  def write(self, oprot):
11816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11818 
      return
11819 
    oprot.writeStructBegin('getOrderListForVendor_result')
11820 
    if self.success is not None:
11821 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11822 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11823 
      for iter238 in self.success:
11824 
        iter238.write(oprot)
5386 phani.kuma 11825 
      oprot.writeListEnd()
11826 
      oprot.writeFieldEnd()
11827 
    oprot.writeFieldStop()
11828 
    oprot.writeStructEnd()
11829 
 
11830 
  def validate(self):
11831 
    return
11832 
 
11833 
 
11834 
  def __repr__(self):
11835 
    L = ['%s=%r' % (key, value)
11836 
      for key, value in self.__dict__.iteritems()]
11837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11838 
 
11839 
  def __eq__(self, other):
11840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11841 
 
11842 
  def __ne__(self, other):
11843 
    return not (self == other)
11844 
 
3064 chandransh 11845 
class getOrderForCustomer_args:
94 ashish 11846 
  """
11847 
  Attributes:
3064 chandransh 11848 
   - orderId
483 rajveer 11849 
   - customerId
94 ashish 11850 
  """
11851 
 
11852 
  thrift_spec = (
11853 
    None, # 0
3064 chandransh 11854 
    (1, TType.I64, 'orderId', None, None, ), # 1
11855 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11856 
  )
11857 
 
3064 chandransh 11858 
  def __init__(self, orderId=None, customerId=None,):
11859 
    self.orderId = orderId
483 rajveer 11860 
    self.customerId = customerId
94 ashish 11861 
 
11862 
  def read(self, iprot):
11863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11865 
      return
11866 
    iprot.readStructBegin()
11867 
    while True:
11868 
      (fname, ftype, fid) = iprot.readFieldBegin()
11869 
      if ftype == TType.STOP:
11870 
        break
11871 
      if fid == 1:
11872 
        if ftype == TType.I64:
3064 chandransh 11873 
          self.orderId = iprot.readI64();
94 ashish 11874 
        else:
11875 
          iprot.skip(ftype)
11876 
      elif fid == 2:
11877 
        if ftype == TType.I64:
3064 chandransh 11878 
          self.customerId = iprot.readI64();
94 ashish 11879 
        else:
11880 
          iprot.skip(ftype)
11881 
      else:
11882 
        iprot.skip(ftype)
11883 
      iprot.readFieldEnd()
11884 
    iprot.readStructEnd()
11885 
 
11886 
  def write(self, oprot):
11887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11889 
      return
3064 chandransh 11890 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11891 
    if self.orderId is not None:
3064 chandransh 11892 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11893 
      oprot.writeI64(self.orderId)
11894 
      oprot.writeFieldEnd()
3431 rajveer 11895 
    if self.customerId is not None:
3064 chandransh 11896 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11897 
      oprot.writeI64(self.customerId)
94 ashish 11898 
      oprot.writeFieldEnd()
11899 
    oprot.writeFieldStop()
11900 
    oprot.writeStructEnd()
11901 
 
3431 rajveer 11902 
  def validate(self):
11903 
    return
11904 
 
11905 
 
94 ashish 11906 
  def __repr__(self):
11907 
    L = ['%s=%r' % (key, value)
11908 
      for key, value in self.__dict__.iteritems()]
11909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11910 
 
11911 
  def __eq__(self, other):
11912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11913 
 
11914 
  def __ne__(self, other):
11915 
    return not (self == other)
11916 
 
3064 chandransh 11917 
class getOrderForCustomer_result:
94 ashish 11918 
  """
11919 
  Attributes:
11920 
   - success
11921 
   - ex
11922 
  """
11923 
 
11924 
  thrift_spec = (
3064 chandransh 11925 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11926 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11927 
  )
11928 
 
11929 
  def __init__(self, success=None, ex=None,):
11930 
    self.success = success
11931 
    self.ex = ex
11932 
 
11933 
  def read(self, iprot):
11934 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11935 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11936 
      return
11937 
    iprot.readStructBegin()
11938 
    while True:
11939 
      (fname, ftype, fid) = iprot.readFieldBegin()
11940 
      if ftype == TType.STOP:
11941 
        break
11942 
      if fid == 0:
3064 chandransh 11943 
        if ftype == TType.STRUCT:
11944 
          self.success = Order()
11945 
          self.success.read(iprot)
94 ashish 11946 
        else:
11947 
          iprot.skip(ftype)
11948 
      elif fid == 1:
11949 
        if ftype == TType.STRUCT:
11950 
          self.ex = TransactionServiceException()
11951 
          self.ex.read(iprot)
11952 
        else:
11953 
          iprot.skip(ftype)
11954 
      else:
11955 
        iprot.skip(ftype)
11956 
      iprot.readFieldEnd()
11957 
    iprot.readStructEnd()
11958 
 
11959 
  def write(self, oprot):
11960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11962 
      return
3064 chandransh 11963 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11964 
    if self.success is not None:
3064 chandransh 11965 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11966 
      self.success.write(oprot)
94 ashish 11967 
      oprot.writeFieldEnd()
3431 rajveer 11968 
    if self.ex is not None:
94 ashish 11969 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11970 
      self.ex.write(oprot)
11971 
      oprot.writeFieldEnd()
11972 
    oprot.writeFieldStop()
11973 
    oprot.writeStructEnd()
11974 
 
3431 rajveer 11975 
  def validate(self):
11976 
    return
11977 
 
11978 
 
94 ashish 11979 
  def __repr__(self):
11980 
    L = ['%s=%r' % (key, value)
11981 
      for key, value in self.__dict__.iteritems()]
11982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11983 
 
11984 
  def __eq__(self, other):
11985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11986 
 
11987 
  def __ne__(self, other):
11988 
    return not (self == other)
11989 
 
3064 chandransh 11990 
class getAlerts_args:
94 ashish 11991 
  """
11992 
  Attributes:
4394 rajveer 11993 
   - type
4444 rajveer 11994 
   - warehouseId
4394 rajveer 11995 
   - status
11996 
   - timestamp
94 ashish 11997 
  """
11998 
 
11999 
  thrift_spec = (
12000 
    None, # 0
4394 rajveer 12001 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12002 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12003 
    (3, TType.I64, 'status', None, None, ), # 3
12004 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12005 
  )
12006 
 
4444 rajveer 12007 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12008 
    self.type = type
4444 rajveer 12009 
    self.warehouseId = warehouseId
4394 rajveer 12010 
    self.status = status
12011 
    self.timestamp = timestamp
94 ashish 12012 
 
12013 
  def read(self, iprot):
12014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12016 
      return
12017 
    iprot.readStructBegin()
12018 
    while True:
12019 
      (fname, ftype, fid) = iprot.readFieldBegin()
12020 
      if ftype == TType.STOP:
12021 
        break
12022 
      if fid == 1:
3064 chandransh 12023 
        if ftype == TType.I64:
4394 rajveer 12024 
          self.type = iprot.readI64();
94 ashish 12025 
        else:
12026 
          iprot.skip(ftype)
3064 chandransh 12027 
      elif fid == 2:
4394 rajveer 12028 
        if ftype == TType.I64:
4444 rajveer 12029 
          self.warehouseId = iprot.readI64();
3064 chandransh 12030 
        else:
12031 
          iprot.skip(ftype)
4394 rajveer 12032 
      elif fid == 3:
12033 
        if ftype == TType.I64:
4444 rajveer 12034 
          self.status = iprot.readI64();
12035 
        else:
12036 
          iprot.skip(ftype)
12037 
      elif fid == 4:
12038 
        if ftype == TType.I64:
4394 rajveer 12039 
          self.timestamp = iprot.readI64();
12040 
        else:
12041 
          iprot.skip(ftype)
94 ashish 12042 
      else:
12043 
        iprot.skip(ftype)
12044 
      iprot.readFieldEnd()
12045 
    iprot.readStructEnd()
12046 
 
12047 
  def write(self, oprot):
12048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12050 
      return
3064 chandransh 12051 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12052 
    if self.type is not None:
12053 
      oprot.writeFieldBegin('type', TType.I64, 1)
12054 
      oprot.writeI64(self.type)
94 ashish 12055 
      oprot.writeFieldEnd()
4444 rajveer 12056 
    if self.warehouseId is not None:
12057 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12058 
      oprot.writeI64(self.warehouseId)
12059 
      oprot.writeFieldEnd()
4394 rajveer 12060 
    if self.status is not None:
4444 rajveer 12061 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12062 
      oprot.writeI64(self.status)
3064 chandransh 12063 
      oprot.writeFieldEnd()
4394 rajveer 12064 
    if self.timestamp is not None:
4444 rajveer 12065 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12066 
      oprot.writeI64(self.timestamp)
12067 
      oprot.writeFieldEnd()
94 ashish 12068 
    oprot.writeFieldStop()
12069 
    oprot.writeStructEnd()
12070 
 
3431 rajveer 12071 
  def validate(self):
12072 
    return
12073 
 
12074 
 
94 ashish 12075 
  def __repr__(self):
12076 
    L = ['%s=%r' % (key, value)
12077 
      for key, value in self.__dict__.iteritems()]
12078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12079 
 
12080 
  def __eq__(self, other):
12081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12082 
 
12083 
  def __ne__(self, other):
12084 
    return not (self == other)
12085 
 
3064 chandransh 12086 
class getAlerts_result:
94 ashish 12087 
  """
12088 
  Attributes:
12089 
   - success
12090 
  """
12091 
 
12092 
  thrift_spec = (
3064 chandransh 12093 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12094 
  )
12095 
 
3064 chandransh 12096 
  def __init__(self, success=None,):
94 ashish 12097 
    self.success = success
12098 
 
12099 
  def read(self, iprot):
12100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12102 
      return
12103 
    iprot.readStructBegin()
12104 
    while True:
12105 
      (fname, ftype, fid) = iprot.readFieldBegin()
12106 
      if ftype == TType.STOP:
12107 
        break
12108 
      if fid == 0:
3064 chandransh 12109 
        if ftype == TType.LIST:
12110 
          self.success = []
6188 rajveer 12111 
          (_etype242, _size239) = iprot.readListBegin()
12112 
          for _i243 in xrange(_size239):
12113 
            _elem244 = Alert()
12114 
            _elem244.read(iprot)
12115 
            self.success.append(_elem244)
3064 chandransh 12116 
          iprot.readListEnd()
94 ashish 12117 
        else:
12118 
          iprot.skip(ftype)
12119 
      else:
12120 
        iprot.skip(ftype)
12121 
      iprot.readFieldEnd()
12122 
    iprot.readStructEnd()
12123 
 
12124 
  def write(self, oprot):
12125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12127 
      return
3064 chandransh 12128 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12129 
    if self.success is not None:
3064 chandransh 12130 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12131 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12132 
      for iter245 in self.success:
12133 
        iter245.write(oprot)
3064 chandransh 12134 
      oprot.writeListEnd()
94 ashish 12135 
      oprot.writeFieldEnd()
12136 
    oprot.writeFieldStop()
12137 
    oprot.writeStructEnd()
12138 
 
3431 rajveer 12139 
  def validate(self):
12140 
    return
12141 
 
12142 
 
94 ashish 12143 
  def __repr__(self):
12144 
    L = ['%s=%r' % (key, value)
12145 
      for key, value in self.__dict__.iteritems()]
12146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12147 
 
12148 
  def __eq__(self, other):
12149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12150 
 
12151 
  def __ne__(self, other):
12152 
    return not (self == other)
12153 
 
4394 rajveer 12154 
class addAlert_args:
94 ashish 12155 
  """
12156 
  Attributes:
3064 chandransh 12157 
   - type
4444 rajveer 12158 
   - warehouseId
4394 rajveer 12159 
   - description
94 ashish 12160 
  """
12161 
 
12162 
  thrift_spec = (
12163 
    None, # 0
4394 rajveer 12164 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12165 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12166 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12167 
  )
12168 
 
4444 rajveer 12169 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12170 
    self.type = type
4444 rajveer 12171 
    self.warehouseId = warehouseId
4394 rajveer 12172 
    self.description = description
94 ashish 12173 
 
12174 
  def read(self, iprot):
12175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12177 
      return
12178 
    iprot.readStructBegin()
12179 
    while True:
12180 
      (fname, ftype, fid) = iprot.readFieldBegin()
12181 
      if ftype == TType.STOP:
12182 
        break
12183 
      if fid == 1:
12184 
        if ftype == TType.I64:
4394 rajveer 12185 
          self.type = iprot.readI64();
94 ashish 12186 
        else:
12187 
          iprot.skip(ftype)
3064 chandransh 12188 
      elif fid == 2:
4444 rajveer 12189 
        if ftype == TType.I64:
12190 
          self.warehouseId = iprot.readI64();
12191 
        else:
12192 
          iprot.skip(ftype)
12193 
      elif fid == 3:
3064 chandransh 12194 
        if ftype == TType.STRING:
4394 rajveer 12195 
          self.description = iprot.readString();
3064 chandransh 12196 
        else:
12197 
          iprot.skip(ftype)
94 ashish 12198 
      else:
12199 
        iprot.skip(ftype)
12200 
      iprot.readFieldEnd()
12201 
    iprot.readStructEnd()
12202 
 
12203 
  def write(self, oprot):
12204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12206 
      return
4394 rajveer 12207 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12208 
    if self.type is not None:
4394 rajveer 12209 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12210 
      oprot.writeI64(self.type)
12211 
      oprot.writeFieldEnd()
4444 rajveer 12212 
    if self.warehouseId is not None:
12213 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12214 
      oprot.writeI64(self.warehouseId)
12215 
      oprot.writeFieldEnd()
4394 rajveer 12216 
    if self.description is not None:
4444 rajveer 12217 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12218 
      oprot.writeString(self.description)
3064 chandransh 12219 
      oprot.writeFieldEnd()
94 ashish 12220 
    oprot.writeFieldStop()
12221 
    oprot.writeStructEnd()
12222 
 
3431 rajveer 12223 
  def validate(self):
12224 
    return
12225 
 
12226 
 
94 ashish 12227 
  def __repr__(self):
12228 
    L = ['%s=%r' % (key, value)
12229 
      for key, value in self.__dict__.iteritems()]
12230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12231 
 
12232 
  def __eq__(self, other):
12233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12234 
 
12235 
  def __ne__(self, other):
12236 
    return not (self == other)
12237 
 
4394 rajveer 12238 
class addAlert_result:
3064 chandransh 12239 
 
12240 
  thrift_spec = (
12241 
  )
12242 
 
12243 
  def read(self, iprot):
12244 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12245 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12246 
      return
12247 
    iprot.readStructBegin()
12248 
    while True:
12249 
      (fname, ftype, fid) = iprot.readFieldBegin()
12250 
      if ftype == TType.STOP:
12251 
        break
12252 
      else:
12253 
        iprot.skip(ftype)
12254 
      iprot.readFieldEnd()
12255 
    iprot.readStructEnd()
12256 
 
12257 
  def write(self, oprot):
12258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12260 
      return
4394 rajveer 12261 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12262 
    oprot.writeFieldStop()
12263 
    oprot.writeStructEnd()
12264 
 
3431 rajveer 12265 
  def validate(self):
12266 
    return
12267 
 
12268 
 
3064 chandransh 12269 
  def __repr__(self):
12270 
    L = ['%s=%r' % (key, value)
12271 
      for key, value in self.__dict__.iteritems()]
12272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12273 
 
12274 
  def __eq__(self, other):
12275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12276 
 
12277 
  def __ne__(self, other):
12278 
    return not (self == other)
12279 
 
4444 rajveer 12280 
class markAlertsAsSeen_args:
12281 
  """
12282 
  Attributes:
12283 
   - warehouseId
12284 
  """
12285 
 
12286 
  thrift_spec = (
12287 
    None, # 0
12288 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12289 
  )
12290 
 
12291 
  def __init__(self, warehouseId=None,):
12292 
    self.warehouseId = warehouseId
12293 
 
12294 
  def read(self, iprot):
12295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12297 
      return
12298 
    iprot.readStructBegin()
12299 
    while True:
12300 
      (fname, ftype, fid) = iprot.readFieldBegin()
12301 
      if ftype == TType.STOP:
12302 
        break
12303 
      if fid == 1:
12304 
        if ftype == TType.I64:
12305 
          self.warehouseId = iprot.readI64();
12306 
        else:
12307 
          iprot.skip(ftype)
12308 
      else:
12309 
        iprot.skip(ftype)
12310 
      iprot.readFieldEnd()
12311 
    iprot.readStructEnd()
12312 
 
12313 
  def write(self, oprot):
12314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12316 
      return
12317 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12318 
    if self.warehouseId is not None:
12319 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12320 
      oprot.writeI64(self.warehouseId)
12321 
      oprot.writeFieldEnd()
12322 
    oprot.writeFieldStop()
12323 
    oprot.writeStructEnd()
12324 
 
12325 
  def validate(self):
12326 
    return
12327 
 
12328 
 
12329 
  def __repr__(self):
12330 
    L = ['%s=%r' % (key, value)
12331 
      for key, value in self.__dict__.iteritems()]
12332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12333 
 
12334 
  def __eq__(self, other):
12335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12336 
 
12337 
  def __ne__(self, other):
12338 
    return not (self == other)
12339 
 
12340 
class markAlertsAsSeen_result:
12341 
 
12342 
  thrift_spec = (
12343 
  )
12344 
 
12345 
  def read(self, iprot):
12346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12348 
      return
12349 
    iprot.readStructBegin()
12350 
    while True:
12351 
      (fname, ftype, fid) = iprot.readFieldBegin()
12352 
      if ftype == TType.STOP:
12353 
        break
12354 
      else:
12355 
        iprot.skip(ftype)
12356 
      iprot.readFieldEnd()
12357 
    iprot.readStructEnd()
12358 
 
12359 
  def write(self, oprot):
12360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12362 
      return
12363 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12364 
    oprot.writeFieldStop()
12365 
    oprot.writeStructEnd()
12366 
 
12367 
  def validate(self):
12368 
    return
12369 
 
12370 
 
12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
3064 chandransh 12382 
class getValidOrderCount_args:
12383 
 
12384 
  thrift_spec = (
12385 
  )
12386 
 
12387 
  def read(self, iprot):
12388 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12389 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12390 
      return
12391 
    iprot.readStructBegin()
12392 
    while True:
12393 
      (fname, ftype, fid) = iprot.readFieldBegin()
12394 
      if ftype == TType.STOP:
12395 
        break
12396 
      else:
12397 
        iprot.skip(ftype)
12398 
      iprot.readFieldEnd()
12399 
    iprot.readStructEnd()
12400 
 
12401 
  def write(self, oprot):
12402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12404 
      return
12405 
    oprot.writeStructBegin('getValidOrderCount_args')
12406 
    oprot.writeFieldStop()
12407 
    oprot.writeStructEnd()
12408 
 
3431 rajveer 12409 
  def validate(self):
12410 
    return
12411 
 
12412 
 
3064 chandransh 12413 
  def __repr__(self):
12414 
    L = ['%s=%r' % (key, value)
12415 
      for key, value in self.__dict__.iteritems()]
12416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12417 
 
12418 
  def __eq__(self, other):
12419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12420 
 
12421 
  def __ne__(self, other):
12422 
    return not (self == other)
12423 
 
12424 
class getValidOrderCount_result:
94 ashish 12425 
  """
12426 
  Attributes:
12427 
   - success
12428 
  """
12429 
 
12430 
  thrift_spec = (
3064 chandransh 12431 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12432 
  )
12433 
 
3064 chandransh 12434 
  def __init__(self, success=None,):
94 ashish 12435 
    self.success = success
12436 
 
12437 
  def read(self, iprot):
12438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12440 
      return
12441 
    iprot.readStructBegin()
12442 
    while True:
12443 
      (fname, ftype, fid) = iprot.readFieldBegin()
12444 
      if ftype == TType.STOP:
12445 
        break
12446 
      if fid == 0:
3064 chandransh 12447 
        if ftype == TType.I64:
12448 
          self.success = iprot.readI64();
94 ashish 12449 
        else:
12450 
          iprot.skip(ftype)
12451 
      else:
12452 
        iprot.skip(ftype)
12453 
      iprot.readFieldEnd()
12454 
    iprot.readStructEnd()
12455 
 
12456 
  def write(self, oprot):
12457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12459 
      return
3064 chandransh 12460 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12461 
    if self.success is not None:
3064 chandransh 12462 
      oprot.writeFieldBegin('success', TType.I64, 0)
12463 
      oprot.writeI64(self.success)
94 ashish 12464 
      oprot.writeFieldEnd()
12465 
    oprot.writeFieldStop()
12466 
    oprot.writeStructEnd()
12467 
 
3431 rajveer 12468 
  def validate(self):
12469 
    return
12470 
 
12471 
 
94 ashish 12472 
  def __repr__(self):
12473 
    L = ['%s=%r' % (key, value)
12474 
      for key, value in self.__dict__.iteritems()]
12475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12476 
 
12477 
  def __eq__(self, other):
12478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12479 
 
12480 
  def __ne__(self, other):
12481 
    return not (self == other)
12482 
 
3064 chandransh 12483 
class getNoOfCustomersWithSuccessfulTransaction_args:
12484 
 
12485 
  thrift_spec = (
12486 
  )
12487 
 
12488 
  def read(self, iprot):
12489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12491 
      return
12492 
    iprot.readStructBegin()
12493 
    while True:
12494 
      (fname, ftype, fid) = iprot.readFieldBegin()
12495 
      if ftype == TType.STOP:
12496 
        break
12497 
      else:
12498 
        iprot.skip(ftype)
12499 
      iprot.readFieldEnd()
12500 
    iprot.readStructEnd()
12501 
 
12502 
  def write(self, oprot):
12503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12505 
      return
12506 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12507 
    oprot.writeFieldStop()
12508 
    oprot.writeStructEnd()
12509 
 
3431 rajveer 12510 
  def validate(self):
12511 
    return
12512 
 
12513 
 
3064 chandransh 12514 
  def __repr__(self):
12515 
    L = ['%s=%r' % (key, value)
12516 
      for key, value in self.__dict__.iteritems()]
12517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12518 
 
12519 
  def __eq__(self, other):
12520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12521 
 
12522 
  def __ne__(self, other):
12523 
    return not (self == other)
12524 
 
12525 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12526 
  """
12527 
  Attributes:
3064 chandransh 12528 
   - success
94 ashish 12529 
  """
12530 
 
12531 
  thrift_spec = (
3064 chandransh 12532 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12533 
  )
12534 
 
3064 chandransh 12535 
  def __init__(self, success=None,):
12536 
    self.success = success
94 ashish 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
3064 chandransh 12547 
      if fid == 0:
94 ashish 12548 
        if ftype == TType.I64:
3064 chandransh 12549 
          self.success = iprot.readI64();
94 ashish 12550 
        else:
12551 
          iprot.skip(ftype)
12552 
      else:
12553 
        iprot.skip(ftype)
12554 
      iprot.readFieldEnd()
12555 
    iprot.readStructEnd()
12556 
 
12557 
  def write(self, oprot):
12558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12560 
      return
3064 chandransh 12561 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12562 
    if self.success is not None:
3064 chandransh 12563 
      oprot.writeFieldBegin('success', TType.I64, 0)
12564 
      oprot.writeI64(self.success)
94 ashish 12565 
      oprot.writeFieldEnd()
12566 
    oprot.writeFieldStop()
12567 
    oprot.writeStructEnd()
12568 
 
3431 rajveer 12569 
  def validate(self):
12570 
    return
12571 
 
12572 
 
94 ashish 12573 
  def __repr__(self):
12574 
    L = ['%s=%r' % (key, value)
12575 
      for key, value in self.__dict__.iteritems()]
12576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12577 
 
12578 
  def __eq__(self, other):
12579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12580 
 
12581 
  def __ne__(self, other):
12582 
    return not (self == other)
12583 
 
3064 chandransh 12584 
class getValidOrdersAmountRange_args:
12585 
 
12586 
  thrift_spec = (
12587 
  )
12588 
 
12589 
  def read(self, iprot):
12590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12592 
      return
12593 
    iprot.readStructBegin()
12594 
    while True:
12595 
      (fname, ftype, fid) = iprot.readFieldBegin()
12596 
      if ftype == TType.STOP:
12597 
        break
12598 
      else:
12599 
        iprot.skip(ftype)
12600 
      iprot.readFieldEnd()
12601 
    iprot.readStructEnd()
12602 
 
12603 
  def write(self, oprot):
12604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12606 
      return
12607 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12608 
    oprot.writeFieldStop()
12609 
    oprot.writeStructEnd()
12610 
 
3431 rajveer 12611 
  def validate(self):
12612 
    return
12613 
 
12614 
 
3064 chandransh 12615 
  def __repr__(self):
12616 
    L = ['%s=%r' % (key, value)
12617 
      for key, value in self.__dict__.iteritems()]
12618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12619 
 
12620 
  def __eq__(self, other):
12621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12622 
 
12623 
  def __ne__(self, other):
12624 
    return not (self == other)
12625 
 
12626 
class getValidOrdersAmountRange_result:
94 ashish 12627 
  """
12628 
  Attributes:
12629 
   - success
12630 
  """
12631 
 
12632 
  thrift_spec = (
3064 chandransh 12633 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12634 
  )
12635 
 
3064 chandransh 12636 
  def __init__(self, success=None,):
94 ashish 12637 
    self.success = success
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      if fid == 0:
483 rajveer 12649 
        if ftype == TType.LIST:
12650 
          self.success = []
6188 rajveer 12651 
          (_etype249, _size246) = iprot.readListBegin()
12652 
          for _i250 in xrange(_size246):
12653 
            _elem251 = iprot.readDouble();
12654 
            self.success.append(_elem251)
483 rajveer 12655 
          iprot.readListEnd()
94 ashish 12656 
        else:
12657 
          iprot.skip(ftype)
12658 
      else:
12659 
        iprot.skip(ftype)
12660 
      iprot.readFieldEnd()
12661 
    iprot.readStructEnd()
12662 
 
12663 
  def write(self, oprot):
12664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12666 
      return
3064 chandransh 12667 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12668 
    if self.success is not None:
483 rajveer 12669 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12670 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12671 
      for iter252 in self.success:
12672 
        oprot.writeDouble(iter252)
483 rajveer 12673 
      oprot.writeListEnd()
94 ashish 12674 
      oprot.writeFieldEnd()
12675 
    oprot.writeFieldStop()
12676 
    oprot.writeStructEnd()
12677 
 
3431 rajveer 12678 
  def validate(self):
12679 
    return
12680 
 
12681 
 
94 ashish 12682 
  def __repr__(self):
12683 
    L = ['%s=%r' % (key, value)
12684 
      for key, value in self.__dict__.iteritems()]
12685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12686 
 
12687 
  def __eq__(self, other):
12688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12689 
 
12690 
  def __ne__(self, other):
12691 
    return not (self == other)
12692 
 
3064 chandransh 12693 
class getValidOrders_args:
1528 ankur.sing 12694 
  """
12695 
  Attributes:
3064 chandransh 12696 
   - limit
5874 rajveer 12697 
   - onlyStore
1528 ankur.sing 12698 
  """
12699 
 
12700 
  thrift_spec = (
12701 
    None, # 0
3064 chandransh 12702 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12703 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12704 
  )
12705 
 
5874 rajveer 12706 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12707 
    self.limit = limit
5874 rajveer 12708 
    self.onlyStore = onlyStore
1528 ankur.sing 12709 
 
12710 
  def read(self, iprot):
12711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12713 
      return
12714 
    iprot.readStructBegin()
12715 
    while True:
12716 
      (fname, ftype, fid) = iprot.readFieldBegin()
12717 
      if ftype == TType.STOP:
12718 
        break
12719 
      if fid == 1:
12720 
        if ftype == TType.I64:
3064 chandransh 12721 
          self.limit = iprot.readI64();
1528 ankur.sing 12722 
        else:
12723 
          iprot.skip(ftype)
5874 rajveer 12724 
      elif fid == 2:
12725 
        if ftype == TType.BOOL:
12726 
          self.onlyStore = iprot.readBool();
12727 
        else:
12728 
          iprot.skip(ftype)
1528 ankur.sing 12729 
      else:
12730 
        iprot.skip(ftype)
12731 
      iprot.readFieldEnd()
12732 
    iprot.readStructEnd()
12733 
 
12734 
  def write(self, oprot):
12735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12737 
      return
3064 chandransh 12738 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12739 
    if self.limit is not None:
3064 chandransh 12740 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12741 
      oprot.writeI64(self.limit)
1528 ankur.sing 12742 
      oprot.writeFieldEnd()
5874 rajveer 12743 
    if self.onlyStore is not None:
12744 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12745 
      oprot.writeBool(self.onlyStore)
12746 
      oprot.writeFieldEnd()
1528 ankur.sing 12747 
    oprot.writeFieldStop()
12748 
    oprot.writeStructEnd()
12749 
 
3431 rajveer 12750 
  def validate(self):
12751 
    return
12752 
 
12753 
 
1528 ankur.sing 12754 
  def __repr__(self):
12755 
    L = ['%s=%r' % (key, value)
12756 
      for key, value in self.__dict__.iteritems()]
12757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12758 
 
12759 
  def __eq__(self, other):
12760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12761 
 
12762 
  def __ne__(self, other):
12763 
    return not (self == other)
12764 
 
3064 chandransh 12765 
class getValidOrders_result:
1528 ankur.sing 12766 
  """
12767 
  Attributes:
12768 
   - success
12769 
  """
12770 
 
12771 
  thrift_spec = (
3064 chandransh 12772 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12773 
  )
12774 
 
3064 chandransh 12775 
  def __init__(self, success=None,):
1528 ankur.sing 12776 
    self.success = success
12777 
 
12778 
  def read(self, iprot):
12779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12781 
      return
12782 
    iprot.readStructBegin()
12783 
    while True:
12784 
      (fname, ftype, fid) = iprot.readFieldBegin()
12785 
      if ftype == TType.STOP:
12786 
        break
12787 
      if fid == 0:
3064 chandransh 12788 
        if ftype == TType.LIST:
12789 
          self.success = []
6188 rajveer 12790 
          (_etype256, _size253) = iprot.readListBegin()
12791 
          for _i257 in xrange(_size253):
12792 
            _elem258 = Order()
12793 
            _elem258.read(iprot)
12794 
            self.success.append(_elem258)
3064 chandransh 12795 
          iprot.readListEnd()
1528 ankur.sing 12796 
        else:
12797 
          iprot.skip(ftype)
12798 
      else:
12799 
        iprot.skip(ftype)
12800 
      iprot.readFieldEnd()
12801 
    iprot.readStructEnd()
12802 
 
12803 
  def write(self, oprot):
12804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12806 
      return
3064 chandransh 12807 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12808 
    if self.success is not None:
3064 chandransh 12809 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12810 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12811 
      for iter259 in self.success:
12812 
        iter259.write(oprot)
3064 chandransh 12813 
      oprot.writeListEnd()
1528 ankur.sing 12814 
      oprot.writeFieldEnd()
12815 
    oprot.writeFieldStop()
12816 
    oprot.writeStructEnd()
12817 
 
3431 rajveer 12818 
  def validate(self):
12819 
    return
12820 
 
12821 
 
1528 ankur.sing 12822 
  def __repr__(self):
12823 
    L = ['%s=%r' % (key, value)
12824 
      for key, value in self.__dict__.iteritems()]
12825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12826 
 
12827 
  def __eq__(self, other):
12828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12829 
 
12830 
  def __ne__(self, other):
12831 
    return not (self == other)
12832 
 
1220 chandransh 12833 
class batchOrders_args:
12834 
  """
12835 
  Attributes:
12836 
   - warehouseId
12837 
  """
12838 
 
12839 
  thrift_spec = (
12840 
    None, # 0
12841 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12842 
  )
12843 
 
12844 
  def __init__(self, warehouseId=None,):
12845 
    self.warehouseId = warehouseId
12846 
 
12847 
  def read(self, iprot):
12848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12850 
      return
12851 
    iprot.readStructBegin()
12852 
    while True:
12853 
      (fname, ftype, fid) = iprot.readFieldBegin()
12854 
      if ftype == TType.STOP:
12855 
        break
12856 
      if fid == 1:
12857 
        if ftype == TType.I64:
12858 
          self.warehouseId = iprot.readI64();
12859 
        else:
12860 
          iprot.skip(ftype)
12861 
      else:
12862 
        iprot.skip(ftype)
12863 
      iprot.readFieldEnd()
12864 
    iprot.readStructEnd()
12865 
 
12866 
  def write(self, oprot):
12867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12869 
      return
12870 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12871 
    if self.warehouseId is not None:
1220 chandransh 12872 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12873 
      oprot.writeI64(self.warehouseId)
12874 
      oprot.writeFieldEnd()
12875 
    oprot.writeFieldStop()
12876 
    oprot.writeStructEnd()
12877 
 
3431 rajveer 12878 
  def validate(self):
12879 
    return
12880 
 
12881 
 
1220 chandransh 12882 
  def __repr__(self):
12883 
    L = ['%s=%r' % (key, value)
12884 
      for key, value in self.__dict__.iteritems()]
12885 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12886 
 
12887 
  def __eq__(self, other):
12888 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12889 
 
12890 
  def __ne__(self, other):
12891 
    return not (self == other)
12892 
 
12893 
class batchOrders_result:
12894 
  """
12895 
  Attributes:
12896 
   - success
12897 
   - ex
12898 
  """
12899 
 
12900 
  thrift_spec = (
12901 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12902 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12903 
  )
12904 
 
12905 
  def __init__(self, success=None, ex=None,):
12906 
    self.success = success
12907 
    self.ex = ex
12908 
 
12909 
  def read(self, iprot):
12910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12912 
      return
12913 
    iprot.readStructBegin()
12914 
    while True:
12915 
      (fname, ftype, fid) = iprot.readFieldBegin()
12916 
      if ftype == TType.STOP:
12917 
        break
12918 
      if fid == 0:
12919 
        if ftype == TType.LIST:
12920 
          self.success = []
6188 rajveer 12921 
          (_etype263, _size260) = iprot.readListBegin()
12922 
          for _i264 in xrange(_size260):
12923 
            _elem265 = Order()
12924 
            _elem265.read(iprot)
12925 
            self.success.append(_elem265)
1220 chandransh 12926 
          iprot.readListEnd()
12927 
        else:
12928 
          iprot.skip(ftype)
12929 
      elif fid == 1:
12930 
        if ftype == TType.STRUCT:
12931 
          self.ex = TransactionServiceException()
12932 
          self.ex.read(iprot)
12933 
        else:
12934 
          iprot.skip(ftype)
12935 
      else:
12936 
        iprot.skip(ftype)
12937 
      iprot.readFieldEnd()
12938 
    iprot.readStructEnd()
12939 
 
12940 
  def write(self, oprot):
12941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12943 
      return
12944 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12945 
    if self.success is not None:
1220 chandransh 12946 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12947 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12948 
      for iter266 in self.success:
12949 
        iter266.write(oprot)
1220 chandransh 12950 
      oprot.writeListEnd()
12951 
      oprot.writeFieldEnd()
3431 rajveer 12952 
    if self.ex is not None:
1220 chandransh 12953 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12954 
      self.ex.write(oprot)
12955 
      oprot.writeFieldEnd()
12956 
    oprot.writeFieldStop()
12957 
    oprot.writeStructEnd()
12958 
 
3431 rajveer 12959 
  def validate(self):
12960 
    return
12961 
 
12962 
 
1220 chandransh 12963 
  def __repr__(self):
12964 
    L = ['%s=%r' % (key, value)
12965 
      for key, value in self.__dict__.iteritems()]
12966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12967 
 
12968 
  def __eq__(self, other):
12969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12970 
 
12971 
  def __ne__(self, other):
12972 
    return not (self == other)
12973 
 
1208 chandransh 12974 
class markOrderAsOutOfStock_args:
12975 
  """
12976 
  Attributes:
12977 
   - orderId
12978 
  """
12979 
 
12980 
  thrift_spec = (
12981 
    None, # 0
12982 
    (1, TType.I64, 'orderId', None, None, ), # 1
12983 
  )
12984 
 
12985 
  def __init__(self, orderId=None,):
12986 
    self.orderId = orderId
12987 
 
12988 
  def read(self, iprot):
12989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12991 
      return
12992 
    iprot.readStructBegin()
12993 
    while True:
12994 
      (fname, ftype, fid) = iprot.readFieldBegin()
12995 
      if ftype == TType.STOP:
12996 
        break
12997 
      if fid == 1:
12998 
        if ftype == TType.I64:
12999 
          self.orderId = iprot.readI64();
13000 
        else:
13001 
          iprot.skip(ftype)
13002 
      else:
13003 
        iprot.skip(ftype)
13004 
      iprot.readFieldEnd()
13005 
    iprot.readStructEnd()
13006 
 
13007 
  def write(self, oprot):
13008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13010 
      return
13011 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13012 
    if self.orderId is not None:
1208 chandransh 13013 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13014 
      oprot.writeI64(self.orderId)
13015 
      oprot.writeFieldEnd()
13016 
    oprot.writeFieldStop()
13017 
    oprot.writeStructEnd()
13018 
 
3431 rajveer 13019 
  def validate(self):
13020 
    return
13021 
 
13022 
 
1208 chandransh 13023 
  def __repr__(self):
13024 
    L = ['%s=%r' % (key, value)
13025 
      for key, value in self.__dict__.iteritems()]
13026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13027 
 
13028 
  def __eq__(self, other):
13029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13030 
 
13031 
  def __ne__(self, other):
13032 
    return not (self == other)
13033 
 
13034 
class markOrderAsOutOfStock_result:
13035 
  """
13036 
  Attributes:
13037 
   - success
13038 
   - ex
13039 
  """
13040 
 
13041 
  thrift_spec = (
13042 
    (0, TType.BOOL, 'success', None, None, ), # 0
13043 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13044 
  )
13045 
 
13046 
  def __init__(self, success=None, ex=None,):
13047 
    self.success = success
13048 
    self.ex = ex
13049 
 
13050 
  def read(self, iprot):
13051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13053 
      return
13054 
    iprot.readStructBegin()
13055 
    while True:
13056 
      (fname, ftype, fid) = iprot.readFieldBegin()
13057 
      if ftype == TType.STOP:
13058 
        break
13059 
      if fid == 0:
13060 
        if ftype == TType.BOOL:
13061 
          self.success = iprot.readBool();
13062 
        else:
13063 
          iprot.skip(ftype)
13064 
      elif fid == 1:
13065 
        if ftype == TType.STRUCT:
13066 
          self.ex = TransactionServiceException()
13067 
          self.ex.read(iprot)
13068 
        else:
13069 
          iprot.skip(ftype)
13070 
      else:
13071 
        iprot.skip(ftype)
13072 
      iprot.readFieldEnd()
13073 
    iprot.readStructEnd()
13074 
 
13075 
  def write(self, oprot):
13076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13078 
      return
13079 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13080 
    if self.success is not None:
1208 chandransh 13081 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13082 
      oprot.writeBool(self.success)
13083 
      oprot.writeFieldEnd()
3431 rajveer 13084 
    if self.ex is not None:
1208 chandransh 13085 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13086 
      self.ex.write(oprot)
13087 
      oprot.writeFieldEnd()
13088 
    oprot.writeFieldStop()
13089 
    oprot.writeStructEnd()
13090 
 
3431 rajveer 13091 
  def validate(self):
13092 
    return
13093 
 
13094 
 
1208 chandransh 13095 
  def __repr__(self):
13096 
    L = ['%s=%r' % (key, value)
13097 
      for key, value in self.__dict__.iteritems()]
13098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13099 
 
13100 
  def __eq__(self, other):
13101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13102 
 
13103 
  def __ne__(self, other):
13104 
    return not (self == other)
13105 
 
3064 chandransh 13106 
class verifyOrder_args:
759 chandransh 13107 
  """
13108 
  Attributes:
3064 chandransh 13109 
   - orderId
759 chandransh 13110 
  """
13111 
 
13112 
  thrift_spec = (
13113 
    None, # 0
3064 chandransh 13114 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13115 
  )
13116 
 
3064 chandransh 13117 
  def __init__(self, orderId=None,):
13118 
    self.orderId = orderId
759 chandransh 13119 
 
13120 
  def read(self, iprot):
13121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13123 
      return
13124 
    iprot.readStructBegin()
13125 
    while True:
13126 
      (fname, ftype, fid) = iprot.readFieldBegin()
13127 
      if ftype == TType.STOP:
13128 
        break
13129 
      if fid == 1:
13130 
        if ftype == TType.I64:
3064 chandransh 13131 
          self.orderId = iprot.readI64();
759 chandransh 13132 
        else:
13133 
          iprot.skip(ftype)
13134 
      else:
13135 
        iprot.skip(ftype)
13136 
      iprot.readFieldEnd()
13137 
    iprot.readStructEnd()
13138 
 
13139 
  def write(self, oprot):
13140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13142 
      return
3064 chandransh 13143 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13144 
    if self.orderId is not None:
3064 chandransh 13145 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13146 
      oprot.writeI64(self.orderId)
759 chandransh 13147 
      oprot.writeFieldEnd()
13148 
    oprot.writeFieldStop()
13149 
    oprot.writeStructEnd()
13150 
 
3431 rajveer 13151 
  def validate(self):
13152 
    return
13153 
 
13154 
 
759 chandransh 13155 
  def __repr__(self):
13156 
    L = ['%s=%r' % (key, value)
13157 
      for key, value in self.__dict__.iteritems()]
13158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13159 
 
13160 
  def __eq__(self, other):
13161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13162 
 
13163 
  def __ne__(self, other):
13164 
    return not (self == other)
13165 
 
3064 chandransh 13166 
class verifyOrder_result:
759 chandransh 13167 
  """
13168 
  Attributes:
13169 
   - success
13170 
   - ex
13171 
  """
13172 
 
13173 
  thrift_spec = (
13174 
    (0, TType.BOOL, 'success', None, None, ), # 0
13175 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13176 
  )
13177 
 
13178 
  def __init__(self, success=None, ex=None,):
13179 
    self.success = success
13180 
    self.ex = ex
13181 
 
13182 
  def read(self, iprot):
13183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13185 
      return
13186 
    iprot.readStructBegin()
13187 
    while True:
13188 
      (fname, ftype, fid) = iprot.readFieldBegin()
13189 
      if ftype == TType.STOP:
13190 
        break
13191 
      if fid == 0:
13192 
        if ftype == TType.BOOL:
13193 
          self.success = iprot.readBool();
13194 
        else:
13195 
          iprot.skip(ftype)
13196 
      elif fid == 1:
13197 
        if ftype == TType.STRUCT:
13198 
          self.ex = TransactionServiceException()
13199 
          self.ex.read(iprot)
13200 
        else:
13201 
          iprot.skip(ftype)
13202 
      else:
13203 
        iprot.skip(ftype)
13204 
      iprot.readFieldEnd()
13205 
    iprot.readStructEnd()
13206 
 
13207 
  def write(self, oprot):
13208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13210 
      return
3064 chandransh 13211 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13212 
    if self.success is not None:
759 chandransh 13213 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13214 
      oprot.writeBool(self.success)
13215 
      oprot.writeFieldEnd()
3431 rajveer 13216 
    if self.ex is not None:
759 chandransh 13217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13218 
      self.ex.write(oprot)
13219 
      oprot.writeFieldEnd()
13220 
    oprot.writeFieldStop()
13221 
    oprot.writeStructEnd()
13222 
 
3431 rajveer 13223 
  def validate(self):
13224 
    return
13225 
 
13226 
 
759 chandransh 13227 
  def __repr__(self):
13228 
    L = ['%s=%r' % (key, value)
13229 
      for key, value in self.__dict__.iteritems()]
13230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13231 
 
13232 
  def __eq__(self, other):
13233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13234 
 
13235 
  def __ne__(self, other):
13236 
    return not (self == other)
13237 
 
3064 chandransh 13238 
class acceptOrder_args:
1113 chandransh 13239 
  """
13240 
  Attributes:
3064 chandransh 13241 
   - orderId
1113 chandransh 13242 
  """
13243 
 
13244 
  thrift_spec = (
13245 
    None, # 0
3064 chandransh 13246 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13247 
  )
13248 
 
3064 chandransh 13249 
  def __init__(self, orderId=None,):
13250 
    self.orderId = orderId
1113 chandransh 13251 
 
13252 
  def read(self, iprot):
13253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13255 
      return
13256 
    iprot.readStructBegin()
13257 
    while True:
13258 
      (fname, ftype, fid) = iprot.readFieldBegin()
13259 
      if ftype == TType.STOP:
13260 
        break
13261 
      if fid == 1:
13262 
        if ftype == TType.I64:
3064 chandransh 13263 
          self.orderId = iprot.readI64();
1113 chandransh 13264 
        else:
13265 
          iprot.skip(ftype)
13266 
      else:
13267 
        iprot.skip(ftype)
13268 
      iprot.readFieldEnd()
13269 
    iprot.readStructEnd()
13270 
 
13271 
  def write(self, oprot):
13272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13274 
      return
3064 chandransh 13275 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13276 
    if self.orderId is not None:
3064 chandransh 13277 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13278 
      oprot.writeI64(self.orderId)
1113 chandransh 13279 
      oprot.writeFieldEnd()
13280 
    oprot.writeFieldStop()
13281 
    oprot.writeStructEnd()
13282 
 
3431 rajveer 13283 
  def validate(self):
13284 
    return
13285 
 
13286 
 
1113 chandransh 13287 
  def __repr__(self):
13288 
    L = ['%s=%r' % (key, value)
13289 
      for key, value in self.__dict__.iteritems()]
13290 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13291 
 
13292 
  def __eq__(self, other):
13293 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13294 
 
13295 
  def __ne__(self, other):
13296 
    return not (self == other)
13297 
 
3064 chandransh 13298 
class acceptOrder_result:
1113 chandransh 13299 
  """
13300 
  Attributes:
13301 
   - success
13302 
   - ex
13303 
  """
13304 
 
13305 
  thrift_spec = (
3064 chandransh 13306 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13307 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13308 
  )
13309 
 
13310 
  def __init__(self, success=None, ex=None,):
13311 
    self.success = success
13312 
    self.ex = ex
13313 
 
13314 
  def read(self, iprot):
13315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13317 
      return
13318 
    iprot.readStructBegin()
13319 
    while True:
13320 
      (fname, ftype, fid) = iprot.readFieldBegin()
13321 
      if ftype == TType.STOP:
13322 
        break
13323 
      if fid == 0:
3064 chandransh 13324 
        if ftype == TType.BOOL:
13325 
          self.success = iprot.readBool();
1113 chandransh 13326 
        else:
13327 
          iprot.skip(ftype)
13328 
      elif fid == 1:
13329 
        if ftype == TType.STRUCT:
13330 
          self.ex = TransactionServiceException()
13331 
          self.ex.read(iprot)
13332 
        else:
13333 
          iprot.skip(ftype)
13334 
      else:
13335 
        iprot.skip(ftype)
13336 
      iprot.readFieldEnd()
13337 
    iprot.readStructEnd()
13338 
 
13339 
  def write(self, oprot):
13340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13342 
      return
3064 chandransh 13343 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13344 
    if self.success is not None:
3064 chandransh 13345 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13346 
      oprot.writeBool(self.success)
1113 chandransh 13347 
      oprot.writeFieldEnd()
3431 rajveer 13348 
    if self.ex is not None:
1113 chandransh 13349 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13350 
      self.ex.write(oprot)
13351 
      oprot.writeFieldEnd()
13352 
    oprot.writeFieldStop()
13353 
    oprot.writeStructEnd()
13354 
 
3431 rajveer 13355 
  def validate(self):
13356 
    return
13357 
 
13358 
 
1113 chandransh 13359 
  def __repr__(self):
13360 
    L = ['%s=%r' % (key, value)
13361 
      for key, value in self.__dict__.iteritems()]
13362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13363 
 
13364 
  def __eq__(self, other):
13365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13366 
 
13367 
  def __ne__(self, other):
13368 
    return not (self == other)
13369 
 
3064 chandransh 13370 
class addBillingDetails_args:
1135 chandransh 13371 
  """
13372 
  Attributes:
3064 chandransh 13373 
   - orderId
13374 
   - invoice_number
4658 mandeep.dh 13375 
   - serialNumber
4283 anupam.sin 13376 
   - itemNumber
3064 chandransh 13377 
   - billed_by
4264 rajveer 13378 
   - jacketNumber
4283 anupam.sin 13379 
   - billingType
5110 mandeep.dh 13380 
   - fulfilmentWarehouseId
4763 rajveer 13381 
   - authorize
1135 chandransh 13382 
  """
13383 
 
13384 
  thrift_spec = (
13385 
    None, # 0
3064 chandransh 13386 
    (1, TType.I64, 'orderId', None, None, ), # 1
13387 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13388 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13389 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13390 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13391 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13392 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13393 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13394 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13395 
  )
13396 
 
5110 mandeep.dh 13397 
  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 13398 
    self.orderId = orderId
13399 
    self.invoice_number = invoice_number
4658 mandeep.dh 13400 
    self.serialNumber = serialNumber
4283 anupam.sin 13401 
    self.itemNumber = itemNumber
3064 chandransh 13402 
    self.billed_by = billed_by
4264 rajveer 13403 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13404 
    self.billingType = billingType
5110 mandeep.dh 13405 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13406 
    self.authorize = authorize
1135 chandransh 13407 
 
13408 
  def read(self, iprot):
13409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13411 
      return
13412 
    iprot.readStructBegin()
13413 
    while True:
13414 
      (fname, ftype, fid) = iprot.readFieldBegin()
13415 
      if ftype == TType.STOP:
13416 
        break
13417 
      if fid == 1:
13418 
        if ftype == TType.I64:
3064 chandransh 13419 
          self.orderId = iprot.readI64();
1135 chandransh 13420 
        else:
13421 
          iprot.skip(ftype)
13422 
      elif fid == 2:
3064 chandransh 13423 
        if ftype == TType.STRING:
13424 
          self.invoice_number = iprot.readString();
1135 chandransh 13425 
        else:
13426 
          iprot.skip(ftype)
3064 chandransh 13427 
      elif fid == 3:
5411 rajveer 13428 
        if ftype == TType.LIST:
13429 
          self.serialNumber = []
6188 rajveer 13430 
          (_etype270, _size267) = iprot.readListBegin()
13431 
          for _i271 in xrange(_size267):
13432 
            _elem272 = iprot.readString();
13433 
            self.serialNumber.append(_elem272)
5411 rajveer 13434 
          iprot.readListEnd()
3064 chandransh 13435 
        else:
13436 
          iprot.skip(ftype)
13437 
      elif fid == 4:
5411 rajveer 13438 
        if ftype == TType.LIST:
13439 
          self.itemNumber = []
6188 rajveer 13440 
          (_etype276, _size273) = iprot.readListBegin()
13441 
          for _i277 in xrange(_size273):
13442 
            _elem278 = iprot.readString();
13443 
            self.itemNumber.append(_elem278)
5411 rajveer 13444 
          iprot.readListEnd()
3064 chandransh 13445 
        else:
13446 
          iprot.skip(ftype)
13447 
      elif fid == 5:
13448 
        if ftype == TType.STRING:
4283 anupam.sin 13449 
          self.billed_by = iprot.readString();
3064 chandransh 13450 
        else:
13451 
          iprot.skip(ftype)
13452 
      elif fid == 6:
13453 
        if ftype == TType.I64:
4283 anupam.sin 13454 
          self.jacketNumber = iprot.readI64();
13455 
        else:
13456 
          iprot.skip(ftype)
13457 
      elif fid == 7:
13458 
        if ftype == TType.I64:
3064 chandransh 13459 
          self.billingType = iprot.readI64();
13460 
        else:
13461 
          iprot.skip(ftype)
4283 anupam.sin 13462 
      elif fid == 8:
13463 
        if ftype == TType.I64:
5110 mandeep.dh 13464 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13465 
        else:
13466 
          iprot.skip(ftype)
4763 rajveer 13467 
      elif fid == 9:
13468 
        if ftype == TType.BOOL:
13469 
          self.authorize = iprot.readBool();
13470 
        else:
13471 
          iprot.skip(ftype)
1246 chandransh 13472 
      else:
13473 
        iprot.skip(ftype)
13474 
      iprot.readFieldEnd()
13475 
    iprot.readStructEnd()
13476 
 
13477 
  def write(self, oprot):
13478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13480 
      return
4283 anupam.sin 13481 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13482 
    if self.orderId is not None:
3064 chandransh 13483 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13484 
      oprot.writeI64(self.orderId)
1246 chandransh 13485 
      oprot.writeFieldEnd()
4283 anupam.sin 13486 
    if self.invoice_number is not None:
13487 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13488 
      oprot.writeString(self.invoice_number)
1246 chandransh 13489 
      oprot.writeFieldEnd()
4658 mandeep.dh 13490 
    if self.serialNumber is not None:
5411 rajveer 13491 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13492 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13493 
      for iter279 in self.serialNumber:
13494 
        oprot.writeString(iter279)
5411 rajveer 13495 
      oprot.writeListEnd()
3064 chandransh 13496 
      oprot.writeFieldEnd()
3431 rajveer 13497 
    if self.itemNumber is not None:
5411 rajveer 13498 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13499 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13500 
      for iter280 in self.itemNumber:
13501 
        oprot.writeString(iter280)
5411 rajveer 13502 
      oprot.writeListEnd()
3064 chandransh 13503 
      oprot.writeFieldEnd()
4283 anupam.sin 13504 
    if self.billed_by is not None:
13505 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13506 
      oprot.writeString(self.billed_by)
3064 chandransh 13507 
      oprot.writeFieldEnd()
4283 anupam.sin 13508 
    if self.jacketNumber is not None:
13509 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13510 
      oprot.writeI64(self.jacketNumber)
13511 
      oprot.writeFieldEnd()
3431 rajveer 13512 
    if self.billingType is not None:
4283 anupam.sin 13513 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13514 
      oprot.writeI64(self.billingType)
13515 
      oprot.writeFieldEnd()
5110 mandeep.dh 13516 
    if self.fulfilmentWarehouseId is not None:
13517 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13518 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13519 
      oprot.writeFieldEnd()
4763 rajveer 13520 
    if self.authorize is not None:
13521 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13522 
      oprot.writeBool(self.authorize)
13523 
      oprot.writeFieldEnd()
1246 chandransh 13524 
    oprot.writeFieldStop()
13525 
    oprot.writeStructEnd()
13526 
 
3431 rajveer 13527 
  def validate(self):
13528 
    return
13529 
 
13530 
 
1246 chandransh 13531 
  def __repr__(self):
13532 
    L = ['%s=%r' % (key, value)
13533 
      for key, value in self.__dict__.iteritems()]
13534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13535 
 
13536 
  def __eq__(self, other):
13537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13538 
 
13539 
  def __ne__(self, other):
13540 
    return not (self == other)
13541 
 
4283 anupam.sin 13542 
class addBillingDetails_result:
1246 chandransh 13543 
  """
13544 
  Attributes:
3064 chandransh 13545 
   - success
1246 chandransh 13546 
   - ex
13547 
  """
13548 
 
13549 
  thrift_spec = (
3064 chandransh 13550 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13552 
  )
13553 
 
3064 chandransh 13554 
  def __init__(self, success=None, ex=None,):
13555 
    self.success = success
1246 chandransh 13556 
    self.ex = ex
13557 
 
13558 
  def read(self, iprot):
13559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13561 
      return
13562 
    iprot.readStructBegin()
13563 
    while True:
13564 
      (fname, ftype, fid) = iprot.readFieldBegin()
13565 
      if ftype == TType.STOP:
13566 
        break
3064 chandransh 13567 
      if fid == 0:
13568 
        if ftype == TType.BOOL:
13569 
          self.success = iprot.readBool();
13570 
        else:
13571 
          iprot.skip(ftype)
13572 
      elif fid == 1:
1246 chandransh 13573 
        if ftype == TType.STRUCT:
13574 
          self.ex = TransactionServiceException()
13575 
          self.ex.read(iprot)
13576 
        else:
13577 
          iprot.skip(ftype)
13578 
      else:
13579 
        iprot.skip(ftype)
13580 
      iprot.readFieldEnd()
13581 
    iprot.readStructEnd()
13582 
 
13583 
  def write(self, oprot):
13584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13586 
      return
4283 anupam.sin 13587 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13588 
    if self.success is not None:
3064 chandransh 13589 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13590 
      oprot.writeBool(self.success)
13591 
      oprot.writeFieldEnd()
3431 rajveer 13592 
    if self.ex is not None:
1246 chandransh 13593 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13594 
      self.ex.write(oprot)
13595 
      oprot.writeFieldEnd()
13596 
    oprot.writeFieldStop()
13597 
    oprot.writeStructEnd()
13598 
 
3431 rajveer 13599 
  def validate(self):
13600 
    return
13601 
 
13602 
 
1246 chandransh 13603 
  def __repr__(self):
13604 
    L = ['%s=%r' % (key, value)
13605 
      for key, value in self.__dict__.iteritems()]
13606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13607 
 
13608 
  def __eq__(self, other):
13609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13610 
 
13611 
  def __ne__(self, other):
13612 
    return not (self == other)
13613 
 
4579 rajveer 13614 
class addInvoiceNumber_args:
13615 
  """
13616 
  Attributes:
13617 
   - orderId
13618 
   - invoiceNumber
4763 rajveer 13619 
   - color
4579 rajveer 13620 
  """
13621 
 
13622 
  thrift_spec = (
13623 
    None, # 0
13624 
    (1, TType.I64, 'orderId', None, None, ), # 1
13625 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13626 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13627 
  )
13628 
 
4763 rajveer 13629 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13630 
    self.orderId = orderId
13631 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13632 
    self.color = color
4579 rajveer 13633 
 
13634 
  def read(self, iprot):
13635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13637 
      return
13638 
    iprot.readStructBegin()
13639 
    while True:
13640 
      (fname, ftype, fid) = iprot.readFieldBegin()
13641 
      if ftype == TType.STOP:
13642 
        break
13643 
      if fid == 1:
13644 
        if ftype == TType.I64:
13645 
          self.orderId = iprot.readI64();
13646 
        else:
13647 
          iprot.skip(ftype)
13648 
      elif fid == 2:
13649 
        if ftype == TType.STRING:
13650 
          self.invoiceNumber = iprot.readString();
13651 
        else:
13652 
          iprot.skip(ftype)
4763 rajveer 13653 
      elif fid == 3:
13654 
        if ftype == TType.STRING:
13655 
          self.color = iprot.readString();
13656 
        else:
13657 
          iprot.skip(ftype)
4579 rajveer 13658 
      else:
13659 
        iprot.skip(ftype)
13660 
      iprot.readFieldEnd()
13661 
    iprot.readStructEnd()
13662 
 
13663 
  def write(self, oprot):
13664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13666 
      return
13667 
    oprot.writeStructBegin('addInvoiceNumber_args')
13668 
    if self.orderId is not None:
13669 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13670 
      oprot.writeI64(self.orderId)
13671 
      oprot.writeFieldEnd()
13672 
    if self.invoiceNumber is not None:
13673 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13674 
      oprot.writeString(self.invoiceNumber)
13675 
      oprot.writeFieldEnd()
4763 rajveer 13676 
    if self.color is not None:
13677 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13678 
      oprot.writeString(self.color)
13679 
      oprot.writeFieldEnd()
4579 rajveer 13680 
    oprot.writeFieldStop()
13681 
    oprot.writeStructEnd()
13682 
 
13683 
  def validate(self):
13684 
    return
13685 
 
13686 
 
13687 
  def __repr__(self):
13688 
    L = ['%s=%r' % (key, value)
13689 
      for key, value in self.__dict__.iteritems()]
13690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13691 
 
13692 
  def __eq__(self, other):
13693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13694 
 
13695 
  def __ne__(self, other):
13696 
    return not (self == other)
13697 
 
13698 
class addInvoiceNumber_result:
13699 
  """
13700 
  Attributes:
13701 
   - ex
13702 
  """
13703 
 
13704 
  thrift_spec = (
13705 
    None, # 0
13706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13707 
  )
13708 
 
13709 
  def __init__(self, ex=None,):
13710 
    self.ex = ex
13711 
 
13712 
  def read(self, iprot):
13713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13715 
      return
13716 
    iprot.readStructBegin()
13717 
    while True:
13718 
      (fname, ftype, fid) = iprot.readFieldBegin()
13719 
      if ftype == TType.STOP:
13720 
        break
13721 
      if fid == 1:
13722 
        if ftype == TType.STRUCT:
13723 
          self.ex = TransactionServiceException()
13724 
          self.ex.read(iprot)
13725 
        else:
13726 
          iprot.skip(ftype)
13727 
      else:
13728 
        iprot.skip(ftype)
13729 
      iprot.readFieldEnd()
13730 
    iprot.readStructEnd()
13731 
 
13732 
  def write(self, oprot):
13733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13735 
      return
13736 
    oprot.writeStructBegin('addInvoiceNumber_result')
13737 
    if self.ex is not None:
13738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13739 
      self.ex.write(oprot)
13740 
      oprot.writeFieldEnd()
13741 
    oprot.writeFieldStop()
13742 
    oprot.writeStructEnd()
13743 
 
13744 
  def validate(self):
13745 
    return
13746 
 
13747 
 
13748 
  def __repr__(self):
13749 
    L = ['%s=%r' % (key, value)
13750 
      for key, value in self.__dict__.iteritems()]
13751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13752 
 
13753 
  def __eq__(self, other):
13754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13755 
 
13756 
  def __ne__(self, other):
13757 
    return not (self == other)
13758 
 
4910 phani.kuma 13759 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13760 
  """
13761 
  Attributes:
3064 chandransh 13762 
   - warehouseId
1408 ankur.sing 13763 
   - providerId
3064 chandransh 13764 
   - cod
4910 phani.kuma 13765 
   - orderIds
1408 ankur.sing 13766 
  """
13767 
 
13768 
  thrift_spec = (
13769 
    None, # 0
3064 chandransh 13770 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13771 
    (2, TType.I64, 'providerId', None, None, ), # 2
13772 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13773 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13774 
  )
13775 
 
4910 phani.kuma 13776 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13777 
    self.warehouseId = warehouseId
1408 ankur.sing 13778 
    self.providerId = providerId
3064 chandransh 13779 
    self.cod = cod
4910 phani.kuma 13780 
    self.orderIds = orderIds
1408 ankur.sing 13781 
 
13782 
  def read(self, iprot):
13783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13785 
      return
13786 
    iprot.readStructBegin()
13787 
    while True:
13788 
      (fname, ftype, fid) = iprot.readFieldBegin()
13789 
      if ftype == TType.STOP:
13790 
        break
13791 
      if fid == 1:
13792 
        if ftype == TType.I64:
3064 chandransh 13793 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13794 
        else:
13795 
          iprot.skip(ftype)
13796 
      elif fid == 2:
13797 
        if ftype == TType.I64:
3064 chandransh 13798 
          self.providerId = iprot.readI64();
1408 ankur.sing 13799 
        else:
13800 
          iprot.skip(ftype)
3064 chandransh 13801 
      elif fid == 3:
13802 
        if ftype == TType.BOOL:
13803 
          self.cod = iprot.readBool();
13804 
        else:
13805 
          iprot.skip(ftype)
4910 phani.kuma 13806 
      elif fid == 4:
13807 
        if ftype == TType.LIST:
13808 
          self.orderIds = []
6188 rajveer 13809 
          (_etype284, _size281) = iprot.readListBegin()
13810 
          for _i285 in xrange(_size281):
13811 
            _elem286 = iprot.readI64();
13812 
            self.orderIds.append(_elem286)
4910 phani.kuma 13813 
          iprot.readListEnd()
13814 
        else:
13815 
          iprot.skip(ftype)
1408 ankur.sing 13816 
      else:
13817 
        iprot.skip(ftype)
13818 
      iprot.readFieldEnd()
13819 
    iprot.readStructEnd()
13820 
 
13821 
  def write(self, oprot):
13822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13824 
      return
4910 phani.kuma 13825 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13826 
    if self.warehouseId is not None:
3064 chandransh 13827 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13828 
      oprot.writeI64(self.warehouseId)
13829 
      oprot.writeFieldEnd()
3431 rajveer 13830 
    if self.providerId is not None:
3064 chandransh 13831 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13832 
      oprot.writeI64(self.providerId)
13833 
      oprot.writeFieldEnd()
3431 rajveer 13834 
    if self.cod is not None:
3064 chandransh 13835 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13836 
      oprot.writeBool(self.cod)
1408 ankur.sing 13837 
      oprot.writeFieldEnd()
4910 phani.kuma 13838 
    if self.orderIds is not None:
13839 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13840 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13841 
      for iter287 in self.orderIds:
13842 
        oprot.writeI64(iter287)
4910 phani.kuma 13843 
      oprot.writeListEnd()
13844 
      oprot.writeFieldEnd()
1408 ankur.sing 13845 
    oprot.writeFieldStop()
13846 
    oprot.writeStructEnd()
13847 
 
3431 rajveer 13848 
  def validate(self):
13849 
    return
13850 
 
13851 
 
1408 ankur.sing 13852 
  def __repr__(self):
13853 
    L = ['%s=%r' % (key, value)
13854 
      for key, value in self.__dict__.iteritems()]
13855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13856 
 
13857 
  def __eq__(self, other):
13858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13859 
 
13860 
  def __ne__(self, other):
13861 
    return not (self == other)
13862 
 
4910 phani.kuma 13863 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13864 
  """
13865 
  Attributes:
13866 
   - success
3064 chandransh 13867 
   - ex
1408 ankur.sing 13868 
  """
13869 
 
13870 
  thrift_spec = (
3064 chandransh 13871 
    (0, TType.BOOL, 'success', None, None, ), # 0
13872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13873 
  )
13874 
 
3064 chandransh 13875 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13876 
    self.success = success
3064 chandransh 13877 
    self.ex = ex
1408 ankur.sing 13878 
 
13879 
  def read(self, iprot):
13880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13882 
      return
13883 
    iprot.readStructBegin()
13884 
    while True:
13885 
      (fname, ftype, fid) = iprot.readFieldBegin()
13886 
      if ftype == TType.STOP:
13887 
        break
13888 
      if fid == 0:
3064 chandransh 13889 
        if ftype == TType.BOOL:
13890 
          self.success = iprot.readBool();
1408 ankur.sing 13891 
        else:
13892 
          iprot.skip(ftype)
3064 chandransh 13893 
      elif fid == 1:
13894 
        if ftype == TType.STRUCT:
13895 
          self.ex = TransactionServiceException()
13896 
          self.ex.read(iprot)
13897 
        else:
13898 
          iprot.skip(ftype)
1408 ankur.sing 13899 
      else:
13900 
        iprot.skip(ftype)
13901 
      iprot.readFieldEnd()
13902 
    iprot.readStructEnd()
13903 
 
13904 
  def write(self, oprot):
13905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13907 
      return
4910 phani.kuma 13908 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13909 
    if self.success is not None:
3064 chandransh 13910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13911 
      oprot.writeBool(self.success)
1408 ankur.sing 13912 
      oprot.writeFieldEnd()
3431 rajveer 13913 
    if self.ex is not None:
3064 chandransh 13914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13915 
      self.ex.write(oprot)
13916 
      oprot.writeFieldEnd()
1408 ankur.sing 13917 
    oprot.writeFieldStop()
13918 
    oprot.writeStructEnd()
13919 
 
3431 rajveer 13920 
  def validate(self):
13921 
    return
13922 
 
13923 
 
1408 ankur.sing 13924 
  def __repr__(self):
13925 
    L = ['%s=%r' % (key, value)
13926 
      for key, value in self.__dict__.iteritems()]
13927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13928 
 
13929 
  def __eq__(self, other):
13930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13931 
 
13932 
  def __ne__(self, other):
13933 
    return not (self == other)
13934 
 
5676 rajveer 13935 
class markOrdersAsReturnedFromStore_args:
13936 
  """
13937 
  Attributes:
13938 
   - providerId
13939 
   - orderIds
5713 rajveer 13940 
   - awbs
5676 rajveer 13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    None, # 0
13945 
    (1, TType.I64, 'providerId', None, None, ), # 1
13946 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13947 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13948 
  )
13949 
 
5713 rajveer 13950 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13951 
    self.providerId = providerId
13952 
    self.orderIds = orderIds
5713 rajveer 13953 
    self.awbs = awbs
5676 rajveer 13954 
 
13955 
  def read(self, iprot):
13956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13958 
      return
13959 
    iprot.readStructBegin()
13960 
    while True:
13961 
      (fname, ftype, fid) = iprot.readFieldBegin()
13962 
      if ftype == TType.STOP:
13963 
        break
13964 
      if fid == 1:
13965 
        if ftype == TType.I64:
13966 
          self.providerId = iprot.readI64();
13967 
        else:
13968 
          iprot.skip(ftype)
13969 
      elif fid == 2:
13970 
        if ftype == TType.LIST:
13971 
          self.orderIds = []
6188 rajveer 13972 
          (_etype291, _size288) = iprot.readListBegin()
13973 
          for _i292 in xrange(_size288):
13974 
            _elem293 = iprot.readI64();
13975 
            self.orderIds.append(_elem293)
5676 rajveer 13976 
          iprot.readListEnd()
13977 
        else:
13978 
          iprot.skip(ftype)
5713 rajveer 13979 
      elif fid == 3:
13980 
        if ftype == TType.LIST:
13981 
          self.awbs = []
6188 rajveer 13982 
          (_etype297, _size294) = iprot.readListBegin()
13983 
          for _i298 in xrange(_size294):
13984 
            _elem299 = iprot.readString();
13985 
            self.awbs.append(_elem299)
5713 rajveer 13986 
          iprot.readListEnd()
13987 
        else:
13988 
          iprot.skip(ftype)
5676 rajveer 13989 
      else:
13990 
        iprot.skip(ftype)
13991 
      iprot.readFieldEnd()
13992 
    iprot.readStructEnd()
13993 
 
13994 
  def write(self, oprot):
13995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13997 
      return
13998 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13999 
    if self.providerId is not None:
14000 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14001 
      oprot.writeI64(self.providerId)
14002 
      oprot.writeFieldEnd()
14003 
    if self.orderIds is not None:
14004 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14005 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14006 
      for iter300 in self.orderIds:
14007 
        oprot.writeI64(iter300)
5676 rajveer 14008 
      oprot.writeListEnd()
14009 
      oprot.writeFieldEnd()
5713 rajveer 14010 
    if self.awbs is not None:
14011 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14012 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14013 
      for iter301 in self.awbs:
14014 
        oprot.writeString(iter301)
5713 rajveer 14015 
      oprot.writeListEnd()
14016 
      oprot.writeFieldEnd()
5676 rajveer 14017 
    oprot.writeFieldStop()
14018 
    oprot.writeStructEnd()
14019 
 
14020 
  def validate(self):
14021 
    return
14022 
 
14023 
 
14024 
  def __repr__(self):
14025 
    L = ['%s=%r' % (key, value)
14026 
      for key, value in self.__dict__.iteritems()]
14027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14028 
 
14029 
  def __eq__(self, other):
14030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14031 
 
14032 
  def __ne__(self, other):
14033 
    return not (self == other)
14034 
 
14035 
class markOrdersAsReturnedFromStore_result:
14036 
  """
14037 
  Attributes:
14038 
   - success
14039 
   - ex
14040 
  """
14041 
 
14042 
  thrift_spec = (
14043 
    (0, TType.BOOL, 'success', None, None, ), # 0
14044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14045 
  )
14046 
 
14047 
  def __init__(self, success=None, ex=None,):
14048 
    self.success = success
14049 
    self.ex = ex
14050 
 
14051 
  def read(self, iprot):
14052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14054 
      return
14055 
    iprot.readStructBegin()
14056 
    while True:
14057 
      (fname, ftype, fid) = iprot.readFieldBegin()
14058 
      if ftype == TType.STOP:
14059 
        break
14060 
      if fid == 0:
14061 
        if ftype == TType.BOOL:
14062 
          self.success = iprot.readBool();
14063 
        else:
14064 
          iprot.skip(ftype)
14065 
      elif fid == 1:
14066 
        if ftype == TType.STRUCT:
14067 
          self.ex = TransactionServiceException()
14068 
          self.ex.read(iprot)
14069 
        else:
14070 
          iprot.skip(ftype)
14071 
      else:
14072 
        iprot.skip(ftype)
14073 
      iprot.readFieldEnd()
14074 
    iprot.readStructEnd()
14075 
 
14076 
  def write(self, oprot):
14077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14079 
      return
14080 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14081 
    if self.success is not None:
14082 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14083 
      oprot.writeBool(self.success)
14084 
      oprot.writeFieldEnd()
14085 
    if self.ex is not None:
14086 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14087 
      self.ex.write(oprot)
14088 
      oprot.writeFieldEnd()
14089 
    oprot.writeFieldStop()
14090 
    oprot.writeStructEnd()
14091 
 
14092 
  def validate(self):
14093 
    return
14094 
 
14095 
 
14096 
  def __repr__(self):
14097 
    L = ['%s=%r' % (key, value)
14098 
      for key, value in self.__dict__.iteritems()]
14099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14100 
 
14101 
  def __eq__(self, other):
14102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14103 
 
14104 
  def __ne__(self, other):
14105 
    return not (self == other)
14106 
 
4910 phani.kuma 14107 
class markOrdersAsPickedUp_args:
4410 rajveer 14108 
  """
14109 
  Attributes:
14110 
   - providerId
4910 phani.kuma 14111 
   - pickupDetails
4410 rajveer 14112 
  """
14113 
 
14114 
  thrift_spec = (
14115 
    None, # 0
4910 phani.kuma 14116 
    (1, TType.I64, 'providerId', None, None, ), # 1
14117 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14118 
  )
14119 
 
4910 phani.kuma 14120 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14121 
    self.providerId = providerId
4910 phani.kuma 14122 
    self.pickupDetails = pickupDetails
4410 rajveer 14123 
 
14124 
  def read(self, iprot):
14125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14127 
      return
14128 
    iprot.readStructBegin()
14129 
    while True:
14130 
      (fname, ftype, fid) = iprot.readFieldBegin()
14131 
      if ftype == TType.STOP:
14132 
        break
14133 
      if fid == 1:
14134 
        if ftype == TType.I64:
4910 phani.kuma 14135 
          self.providerId = iprot.readI64();
4410 rajveer 14136 
        else:
14137 
          iprot.skip(ftype)
14138 
      elif fid == 2:
4910 phani.kuma 14139 
        if ftype == TType.MAP:
14140 
          self.pickupDetails = {}
6188 rajveer 14141 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14142 
          for _i306 in xrange(_size302):
14143 
            _key307 = iprot.readString();
14144 
            _val308 = iprot.readString();
14145 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14146 
          iprot.readMapEnd()
4410 rajveer 14147 
        else:
14148 
          iprot.skip(ftype)
14149 
      else:
14150 
        iprot.skip(ftype)
14151 
      iprot.readFieldEnd()
14152 
    iprot.readStructEnd()
14153 
 
14154 
  def write(self, oprot):
14155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14157 
      return
4910 phani.kuma 14158 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14159 
    if self.providerId is not None:
4910 phani.kuma 14160 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14161 
      oprot.writeI64(self.providerId)
14162 
      oprot.writeFieldEnd()
4910 phani.kuma 14163 
    if self.pickupDetails is not None:
14164 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14165 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14166 
      for kiter309,viter310 in self.pickupDetails.items():
14167 
        oprot.writeString(kiter309)
14168 
        oprot.writeString(viter310)
4910 phani.kuma 14169 
      oprot.writeMapEnd()
4410 rajveer 14170 
      oprot.writeFieldEnd()
14171 
    oprot.writeFieldStop()
14172 
    oprot.writeStructEnd()
14173 
 
14174 
  def validate(self):
14175 
    return
14176 
 
14177 
 
14178 
  def __repr__(self):
14179 
    L = ['%s=%r' % (key, value)
14180 
      for key, value in self.__dict__.iteritems()]
14181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14182 
 
14183 
  def __eq__(self, other):
14184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14185 
 
14186 
  def __ne__(self, other):
14187 
    return not (self == other)
14188 
 
4910 phani.kuma 14189 
class markOrdersAsPickedUp_result:
4410 rajveer 14190 
  """
14191 
  Attributes:
14192 
   - ex
14193 
  """
14194 
 
14195 
  thrift_spec = (
4910 phani.kuma 14196 
    None, # 0
4410 rajveer 14197 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14198 
  )
14199 
 
4910 phani.kuma 14200 
  def __init__(self, ex=None,):
4410 rajveer 14201 
    self.ex = ex
14202 
 
14203 
  def read(self, iprot):
14204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14206 
      return
14207 
    iprot.readStructBegin()
14208 
    while True:
14209 
      (fname, ftype, fid) = iprot.readFieldBegin()
14210 
      if ftype == TType.STOP:
14211 
        break
4910 phani.kuma 14212 
      if fid == 1:
4410 rajveer 14213 
        if ftype == TType.STRUCT:
14214 
          self.ex = TransactionServiceException()
14215 
          self.ex.read(iprot)
14216 
        else:
14217 
          iprot.skip(ftype)
14218 
      else:
14219 
        iprot.skip(ftype)
14220 
      iprot.readFieldEnd()
14221 
    iprot.readStructEnd()
14222 
 
14223 
  def write(self, oprot):
14224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14226 
      return
4910 phani.kuma 14227 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14228 
    if self.ex is not None:
14229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14230 
      self.ex.write(oprot)
14231 
      oprot.writeFieldEnd()
14232 
    oprot.writeFieldStop()
14233 
    oprot.writeStructEnd()
14234 
 
14235 
  def validate(self):
14236 
    return
14237 
 
14238 
 
14239 
  def __repr__(self):
14240 
    L = ['%s=%r' % (key, value)
14241 
      for key, value in self.__dict__.iteritems()]
14242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14243 
 
14244 
  def __eq__(self, other):
14245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14246 
 
14247 
  def __ne__(self, other):
14248 
    return not (self == other)
14249 
 
4910 phani.kuma 14250 
class getOrdersNotPickedUp_args:
304 ashish 14251 
  """
14252 
  Attributes:
3064 chandransh 14253 
   - providerId
304 ashish 14254 
  """
94 ashish 14255 
 
304 ashish 14256 
  thrift_spec = (
14257 
    None, # 0
3064 chandransh 14258 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14259 
  )
14260 
 
4910 phani.kuma 14261 
  def __init__(self, providerId=None,):
3064 chandransh 14262 
    self.providerId = providerId
304 ashish 14263 
 
14264 
  def read(self, iprot):
14265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14267 
      return
14268 
    iprot.readStructBegin()
14269 
    while True:
14270 
      (fname, ftype, fid) = iprot.readFieldBegin()
14271 
      if ftype == TType.STOP:
14272 
        break
14273 
      if fid == 1:
14274 
        if ftype == TType.I64:
3064 chandransh 14275 
          self.providerId = iprot.readI64();
304 ashish 14276 
        else:
14277 
          iprot.skip(ftype)
14278 
      else:
14279 
        iprot.skip(ftype)
14280 
      iprot.readFieldEnd()
14281 
    iprot.readStructEnd()
14282 
 
14283 
  def write(self, oprot):
14284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14286 
      return
4910 phani.kuma 14287 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14288 
    if self.providerId is not None:
3064 chandransh 14289 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14290 
      oprot.writeI64(self.providerId)
304 ashish 14291 
      oprot.writeFieldEnd()
14292 
    oprot.writeFieldStop()
14293 
    oprot.writeStructEnd()
14294 
 
3431 rajveer 14295 
  def validate(self):
14296 
    return
14297 
 
14298 
 
304 ashish 14299 
  def __repr__(self):
14300 
    L = ['%s=%r' % (key, value)
14301 
      for key, value in self.__dict__.iteritems()]
14302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14303 
 
14304 
  def __eq__(self, other):
14305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14306 
 
14307 
  def __ne__(self, other):
14308 
    return not (self == other)
14309 
 
4910 phani.kuma 14310 
class getOrdersNotPickedUp_result:
304 ashish 14311 
  """
14312 
  Attributes:
14313 
   - success
14314 
  """
14315 
 
14316 
  thrift_spec = (
3064 chandransh 14317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14318 
  )
14319 
 
4910 phani.kuma 14320 
  def __init__(self, success=None,):
304 ashish 14321 
    self.success = success
14322 
 
14323 
  def read(self, iprot):
14324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14326 
      return
14327 
    iprot.readStructBegin()
14328 
    while True:
14329 
      (fname, ftype, fid) = iprot.readFieldBegin()
14330 
      if ftype == TType.STOP:
14331 
        break
14332 
      if fid == 0:
14333 
        if ftype == TType.LIST:
14334 
          self.success = []
6188 rajveer 14335 
          (_etype314, _size311) = iprot.readListBegin()
14336 
          for _i315 in xrange(_size311):
14337 
            _elem316 = Order()
14338 
            _elem316.read(iprot)
14339 
            self.success.append(_elem316)
304 ashish 14340 
          iprot.readListEnd()
14341 
        else:
14342 
          iprot.skip(ftype)
14343 
      else:
14344 
        iprot.skip(ftype)
14345 
      iprot.readFieldEnd()
14346 
    iprot.readStructEnd()
14347 
 
14348 
  def write(self, oprot):
14349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14351 
      return
4910 phani.kuma 14352 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14353 
    if self.success is not None:
304 ashish 14354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14356 
      for iter317 in self.success:
14357 
        iter317.write(oprot)
304 ashish 14358 
      oprot.writeListEnd()
14359 
      oprot.writeFieldEnd()
14360 
    oprot.writeFieldStop()
14361 
    oprot.writeStructEnd()
14362 
 
3431 rajveer 14363 
  def validate(self):
14364 
    return
14365 
 
14366 
 
304 ashish 14367 
  def __repr__(self):
14368 
    L = ['%s=%r' % (key, value)
14369 
      for key, value in self.__dict__.iteritems()]
14370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14371 
 
14372 
  def __eq__(self, other):
14373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14374 
 
14375 
  def __ne__(self, other):
14376 
    return not (self == other)
14377 
 
3064 chandransh 14378 
class markOrdersAsDelivered_args:
304 ashish 14379 
  """
14380 
  Attributes:
3064 chandransh 14381 
   - providerId
14382 
   - deliveredOrders
304 ashish 14383 
  """
14384 
 
14385 
  thrift_spec = (
14386 
    None, # 0
3064 chandransh 14387 
    (1, TType.I64, 'providerId', None, None, ), # 1
14388 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14389 
  )
14390 
 
3064 chandransh 14391 
  def __init__(self, providerId=None, deliveredOrders=None,):
14392 
    self.providerId = providerId
14393 
    self.deliveredOrders = deliveredOrders
304 ashish 14394 
 
14395 
  def read(self, iprot):
14396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14398 
      return
14399 
    iprot.readStructBegin()
14400 
    while True:
14401 
      (fname, ftype, fid) = iprot.readFieldBegin()
14402 
      if ftype == TType.STOP:
14403 
        break
14404 
      if fid == 1:
14405 
        if ftype == TType.I64:
3064 chandransh 14406 
          self.providerId = iprot.readI64();
304 ashish 14407 
        else:
14408 
          iprot.skip(ftype)
14409 
      elif fid == 2:
3064 chandransh 14410 
        if ftype == TType.MAP:
14411 
          self.deliveredOrders = {}
6188 rajveer 14412 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14413 
          for _i322 in xrange(_size318):
14414 
            _key323 = iprot.readString();
14415 
            _val324 = iprot.readString();
14416 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14417 
          iprot.readMapEnd()
304 ashish 14418 
        else:
14419 
          iprot.skip(ftype)
14420 
      else:
14421 
        iprot.skip(ftype)
14422 
      iprot.readFieldEnd()
14423 
    iprot.readStructEnd()
14424 
 
14425 
  def write(self, oprot):
14426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14428 
      return
3064 chandransh 14429 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14430 
    if self.providerId is not None:
3064 chandransh 14431 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14432 
      oprot.writeI64(self.providerId)
304 ashish 14433 
      oprot.writeFieldEnd()
3431 rajveer 14434 
    if self.deliveredOrders is not None:
3064 chandransh 14435 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14436 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14437 
      for kiter325,viter326 in self.deliveredOrders.items():
14438 
        oprot.writeString(kiter325)
14439 
        oprot.writeString(viter326)
3064 chandransh 14440 
      oprot.writeMapEnd()
304 ashish 14441 
      oprot.writeFieldEnd()
14442 
    oprot.writeFieldStop()
14443 
    oprot.writeStructEnd()
14444 
 
3431 rajveer 14445 
  def validate(self):
14446 
    return
14447 
 
14448 
 
304 ashish 14449 
  def __repr__(self):
14450 
    L = ['%s=%r' % (key, value)
14451 
      for key, value in self.__dict__.iteritems()]
14452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14453 
 
14454 
  def __eq__(self, other):
14455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14456 
 
14457 
  def __ne__(self, other):
14458 
    return not (self == other)
14459 
 
3064 chandransh 14460 
class markOrdersAsDelivered_result:
14461 
  """
14462 
  Attributes:
14463 
   - ex
14464 
  """
304 ashish 14465 
 
14466 
  thrift_spec = (
3064 chandransh 14467 
    None, # 0
14468 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14469 
  )
14470 
 
3064 chandransh 14471 
  def __init__(self, ex=None,):
14472 
    self.ex = ex
304 ashish 14473 
 
1596 ankur.sing 14474 
  def read(self, iprot):
14475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14477 
      return
14478 
    iprot.readStructBegin()
14479 
    while True:
14480 
      (fname, ftype, fid) = iprot.readFieldBegin()
14481 
      if ftype == TType.STOP:
14482 
        break
3064 chandransh 14483 
      if fid == 1:
14484 
        if ftype == TType.STRUCT:
14485 
          self.ex = TransactionServiceException()
14486 
          self.ex.read(iprot)
14487 
        else:
14488 
          iprot.skip(ftype)
1596 ankur.sing 14489 
      else:
14490 
        iprot.skip(ftype)
14491 
      iprot.readFieldEnd()
14492 
    iprot.readStructEnd()
14493 
 
14494 
  def write(self, oprot):
14495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14497 
      return
3064 chandransh 14498 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14499 
    if self.ex is not None:
3064 chandransh 14500 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14501 
      self.ex.write(oprot)
14502 
      oprot.writeFieldEnd()
1596 ankur.sing 14503 
    oprot.writeFieldStop()
14504 
    oprot.writeStructEnd()
14505 
 
3431 rajveer 14506 
  def validate(self):
14507 
    return
14508 
 
14509 
 
1596 ankur.sing 14510 
  def __repr__(self):
14511 
    L = ['%s=%r' % (key, value)
14512 
      for key, value in self.__dict__.iteritems()]
14513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14514 
 
14515 
  def __eq__(self, other):
14516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14517 
 
14518 
  def __ne__(self, other):
14519 
    return not (self == other)
14520 
 
4910 phani.kuma 14521 
class markAsRTOrders_args:
1596 ankur.sing 14522 
  """
14523 
  Attributes:
3064 chandransh 14524 
   - providerId
14525 
   - returnedOrders
1596 ankur.sing 14526 
  """
14527 
 
14528 
  thrift_spec = (
3064 chandransh 14529 
    None, # 0
14530 
    (1, TType.I64, 'providerId', None, None, ), # 1
14531 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14532 
  )
14533 
 
3064 chandransh 14534 
  def __init__(self, providerId=None, returnedOrders=None,):
14535 
    self.providerId = providerId
14536 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14537 
 
14538 
  def read(self, iprot):
14539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14541 
      return
14542 
    iprot.readStructBegin()
14543 
    while True:
14544 
      (fname, ftype, fid) = iprot.readFieldBegin()
14545 
      if ftype == TType.STOP:
14546 
        break
3064 chandransh 14547 
      if fid == 1:
1596 ankur.sing 14548 
        if ftype == TType.I64:
3064 chandransh 14549 
          self.providerId = iprot.readI64();
1596 ankur.sing 14550 
        else:
14551 
          iprot.skip(ftype)
3064 chandransh 14552 
      elif fid == 2:
14553 
        if ftype == TType.MAP:
14554 
          self.returnedOrders = {}
6188 rajveer 14555 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14556 
          for _i331 in xrange(_size327):
14557 
            _key332 = iprot.readString();
14558 
            _val333 = iprot.readString();
14559 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14560 
          iprot.readMapEnd()
14561 
        else:
14562 
          iprot.skip(ftype)
1596 ankur.sing 14563 
      else:
14564 
        iprot.skip(ftype)
14565 
      iprot.readFieldEnd()
14566 
    iprot.readStructEnd()
14567 
 
14568 
  def write(self, oprot):
14569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14571 
      return
4910 phani.kuma 14572 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14573 
    if self.providerId is not None:
3064 chandransh 14574 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14575 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14576 
      oprot.writeFieldEnd()
3431 rajveer 14577 
    if self.returnedOrders is not None:
3064 chandransh 14578 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14579 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14580 
      for kiter334,viter335 in self.returnedOrders.items():
14581 
        oprot.writeString(kiter334)
14582 
        oprot.writeString(viter335)
3064 chandransh 14583 
      oprot.writeMapEnd()
14584 
      oprot.writeFieldEnd()
1596 ankur.sing 14585 
    oprot.writeFieldStop()
14586 
    oprot.writeStructEnd()
14587 
 
3431 rajveer 14588 
  def validate(self):
14589 
    return
14590 
 
14591 
 
1596 ankur.sing 14592 
  def __repr__(self):
14593 
    L = ['%s=%r' % (key, value)
14594 
      for key, value in self.__dict__.iteritems()]
14595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14596 
 
14597 
  def __eq__(self, other):
14598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14599 
 
14600 
  def __ne__(self, other):
14601 
    return not (self == other)
14602 
 
4910 phani.kuma 14603 
class markAsRTOrders_result:
3064 chandransh 14604 
  """
14605 
  Attributes:
14606 
   - ex
14607 
  """
1596 ankur.sing 14608 
 
1627 ankur.sing 14609 
  thrift_spec = (
3064 chandransh 14610 
    None, # 0
14611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14612 
  )
14613 
 
3064 chandransh 14614 
  def __init__(self, ex=None,):
14615 
    self.ex = ex
14616 
 
1627 ankur.sing 14617 
  def read(self, iprot):
14618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14620 
      return
14621 
    iprot.readStructBegin()
14622 
    while True:
14623 
      (fname, ftype, fid) = iprot.readFieldBegin()
14624 
      if ftype == TType.STOP:
14625 
        break
3064 chandransh 14626 
      if fid == 1:
14627 
        if ftype == TType.STRUCT:
14628 
          self.ex = TransactionServiceException()
14629 
          self.ex.read(iprot)
14630 
        else:
14631 
          iprot.skip(ftype)
1627 ankur.sing 14632 
      else:
14633 
        iprot.skip(ftype)
14634 
      iprot.readFieldEnd()
14635 
    iprot.readStructEnd()
14636 
 
14637 
  def write(self, oprot):
14638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14640 
      return
4910 phani.kuma 14641 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14642 
    if self.ex is not None:
3064 chandransh 14643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14644 
      self.ex.write(oprot)
14645 
      oprot.writeFieldEnd()
1627 ankur.sing 14646 
    oprot.writeFieldStop()
14647 
    oprot.writeStructEnd()
14648 
 
3431 rajveer 14649 
  def validate(self):
14650 
    return
14651 
 
14652 
 
1627 ankur.sing 14653 
  def __repr__(self):
14654 
    L = ['%s=%r' % (key, value)
14655 
      for key, value in self.__dict__.iteritems()]
14656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14657 
 
14658 
  def __eq__(self, other):
14659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14660 
 
14661 
  def __ne__(self, other):
14662 
    return not (self == other)
14663 
 
4910 phani.kuma 14664 
class getRTOrders_args:
14665 
  """
14666 
  Attributes:
14667 
   - providerId
14668 
  """
14669 
 
14670 
  thrift_spec = (
14671 
    None, # 0
14672 
    (1, TType.I64, 'providerId', None, None, ), # 1
14673 
  )
14674 
 
14675 
  def __init__(self, providerId=None,):
14676 
    self.providerId = providerId
14677 
 
14678 
  def read(self, iprot):
14679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14681 
      return
14682 
    iprot.readStructBegin()
14683 
    while True:
14684 
      (fname, ftype, fid) = iprot.readFieldBegin()
14685 
      if ftype == TType.STOP:
14686 
        break
14687 
      if fid == 1:
14688 
        if ftype == TType.I64:
14689 
          self.providerId = iprot.readI64();
14690 
        else:
14691 
          iprot.skip(ftype)
14692 
      else:
14693 
        iprot.skip(ftype)
14694 
      iprot.readFieldEnd()
14695 
    iprot.readStructEnd()
14696 
 
14697 
  def write(self, oprot):
14698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14700 
      return
14701 
    oprot.writeStructBegin('getRTOrders_args')
14702 
    if self.providerId is not None:
14703 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14704 
      oprot.writeI64(self.providerId)
14705 
      oprot.writeFieldEnd()
14706 
    oprot.writeFieldStop()
14707 
    oprot.writeStructEnd()
14708 
 
14709 
  def validate(self):
14710 
    return
14711 
 
14712 
 
14713 
  def __repr__(self):
14714 
    L = ['%s=%r' % (key, value)
14715 
      for key, value in self.__dict__.iteritems()]
14716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14717 
 
14718 
  def __eq__(self, other):
14719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14720 
 
14721 
  def __ne__(self, other):
14722 
    return not (self == other)
14723 
 
14724 
class getRTOrders_result:
14725 
  """
14726 
  Attributes:
14727 
   - success
14728 
  """
14729 
 
14730 
  thrift_spec = (
14731 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14732 
  )
14733 
 
14734 
  def __init__(self, success=None,):
14735 
    self.success = success
14736 
 
14737 
  def read(self, iprot):
14738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14740 
      return
14741 
    iprot.readStructBegin()
14742 
    while True:
14743 
      (fname, ftype, fid) = iprot.readFieldBegin()
14744 
      if ftype == TType.STOP:
14745 
        break
14746 
      if fid == 0:
14747 
        if ftype == TType.LIST:
14748 
          self.success = []
6188 rajveer 14749 
          (_etype339, _size336) = iprot.readListBegin()
14750 
          for _i340 in xrange(_size336):
14751 
            _elem341 = Order()
14752 
            _elem341.read(iprot)
14753 
            self.success.append(_elem341)
4910 phani.kuma 14754 
          iprot.readListEnd()
14755 
        else:
14756 
          iprot.skip(ftype)
14757 
      else:
14758 
        iprot.skip(ftype)
14759 
      iprot.readFieldEnd()
14760 
    iprot.readStructEnd()
14761 
 
14762 
  def write(self, oprot):
14763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14765 
      return
14766 
    oprot.writeStructBegin('getRTOrders_result')
14767 
    if self.success is not None:
14768 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14769 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14770 
      for iter342 in self.success:
14771 
        iter342.write(oprot)
4910 phani.kuma 14772 
      oprot.writeListEnd()
14773 
      oprot.writeFieldEnd()
14774 
    oprot.writeFieldStop()
14775 
    oprot.writeStructEnd()
14776 
 
14777 
  def validate(self):
14778 
    return
14779 
 
14780 
 
14781 
  def __repr__(self):
14782 
    L = ['%s=%r' % (key, value)
14783 
      for key, value in self.__dict__.iteritems()]
14784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14785 
 
14786 
  def __eq__(self, other):
14787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14788 
 
14789 
  def __ne__(self, other):
14790 
    return not (self == other)
14791 
 
3064 chandransh 14792 
class updateNonDeliveryReason_args:
1627 ankur.sing 14793 
  """
14794 
  Attributes:
3064 chandransh 14795 
   - providerId
14796 
   - undeliveredOrders
1627 ankur.sing 14797 
  """
14798 
 
14799 
  thrift_spec = (
3064 chandransh 14800 
    None, # 0
14801 
    (1, TType.I64, 'providerId', None, None, ), # 1
14802 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14803 
  )
14804 
 
3064 chandransh 14805 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14806 
    self.providerId = providerId
14807 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14808 
 
14809 
  def read(self, iprot):
14810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14812 
      return
14813 
    iprot.readStructBegin()
14814 
    while True:
14815 
      (fname, ftype, fid) = iprot.readFieldBegin()
14816 
      if ftype == TType.STOP:
14817 
        break
3064 chandransh 14818 
      if fid == 1:
1627 ankur.sing 14819 
        if ftype == TType.I64:
3064 chandransh 14820 
          self.providerId = iprot.readI64();
1627 ankur.sing 14821 
        else:
14822 
          iprot.skip(ftype)
3064 chandransh 14823 
      elif fid == 2:
14824 
        if ftype == TType.MAP:
14825 
          self.undeliveredOrders = {}
6188 rajveer 14826 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14827 
          for _i347 in xrange(_size343):
14828 
            _key348 = iprot.readString();
14829 
            _val349 = iprot.readString();
14830 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14831 
          iprot.readMapEnd()
14832 
        else:
14833 
          iprot.skip(ftype)
1627 ankur.sing 14834 
      else:
14835 
        iprot.skip(ftype)
14836 
      iprot.readFieldEnd()
14837 
    iprot.readStructEnd()
14838 
 
14839 
  def write(self, oprot):
14840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14842 
      return
3064 chandransh 14843 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14844 
    if self.providerId is not None:
3064 chandransh 14845 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14846 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14847 
      oprot.writeFieldEnd()
3431 rajveer 14848 
    if self.undeliveredOrders is not None:
3064 chandransh 14849 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14850 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14851 
      for kiter350,viter351 in self.undeliveredOrders.items():
14852 
        oprot.writeString(kiter350)
14853 
        oprot.writeString(viter351)
3064 chandransh 14854 
      oprot.writeMapEnd()
14855 
      oprot.writeFieldEnd()
1627 ankur.sing 14856 
    oprot.writeFieldStop()
14857 
    oprot.writeStructEnd()
14858 
 
3431 rajveer 14859 
  def validate(self):
14860 
    return
14861 
 
14862 
 
1627 ankur.sing 14863 
  def __repr__(self):
14864 
    L = ['%s=%r' % (key, value)
14865 
      for key, value in self.__dict__.iteritems()]
14866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14867 
 
14868 
  def __eq__(self, other):
14869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14870 
 
14871 
  def __ne__(self, other):
14872 
    return not (self == other)
14873 
 
3064 chandransh 14874 
class updateNonDeliveryReason_result:
1627 ankur.sing 14875 
  """
14876 
  Attributes:
3064 chandransh 14877 
   - ex
1627 ankur.sing 14878 
  """
14879 
 
14880 
  thrift_spec = (
4910 phani.kuma 14881 
    None, # 0
3064 chandransh 14882 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14883 
  )
14884 
 
4910 phani.kuma 14885 
  def __init__(self, ex=None,):
3064 chandransh 14886 
    self.ex = ex
1627 ankur.sing 14887 
 
14888 
  def read(self, iprot):
14889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14891 
      return
14892 
    iprot.readStructBegin()
14893 
    while True:
14894 
      (fname, ftype, fid) = iprot.readFieldBegin()
14895 
      if ftype == TType.STOP:
14896 
        break
4910 phani.kuma 14897 
      if fid == 1:
14898 
        if ftype == TType.STRUCT:
14899 
          self.ex = TransactionServiceException()
14900 
          self.ex.read(iprot)
14901 
        else:
14902 
          iprot.skip(ftype)
14903 
      else:
14904 
        iprot.skip(ftype)
14905 
      iprot.readFieldEnd()
14906 
    iprot.readStructEnd()
14907 
 
14908 
  def write(self, oprot):
14909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14911 
      return
14912 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14913 
    if self.ex is not None:
14914 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14915 
      self.ex.write(oprot)
14916 
      oprot.writeFieldEnd()
14917 
    oprot.writeFieldStop()
14918 
    oprot.writeStructEnd()
14919 
 
14920 
  def validate(self):
14921 
    return
14922 
 
14923 
 
14924 
  def __repr__(self):
14925 
    L = ['%s=%r' % (key, value)
14926 
      for key, value in self.__dict__.iteritems()]
14927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14928 
 
14929 
  def __eq__(self, other):
14930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14931 
 
14932 
  def __ne__(self, other):
14933 
    return not (self == other)
14934 
 
14935 
class getNonDeliveredOrdersbyCourier_args:
14936 
  """
14937 
  Attributes:
14938 
   - providerId
14939 
  """
14940 
 
14941 
  thrift_spec = (
14942 
    None, # 0
14943 
    (1, TType.I64, 'providerId', None, None, ), # 1
14944 
  )
14945 
 
14946 
  def __init__(self, providerId=None,):
14947 
    self.providerId = providerId
14948 
 
14949 
  def read(self, iprot):
14950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14952 
      return
14953 
    iprot.readStructBegin()
14954 
    while True:
14955 
      (fname, ftype, fid) = iprot.readFieldBegin()
14956 
      if ftype == TType.STOP:
14957 
        break
14958 
      if fid == 1:
14959 
        if ftype == TType.I64:
14960 
          self.providerId = iprot.readI64();
14961 
        else:
14962 
          iprot.skip(ftype)
14963 
      else:
14964 
        iprot.skip(ftype)
14965 
      iprot.readFieldEnd()
14966 
    iprot.readStructEnd()
14967 
 
14968 
  def write(self, oprot):
14969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14971 
      return
14972 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14973 
    if self.providerId is not None:
14974 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14975 
      oprot.writeI64(self.providerId)
14976 
      oprot.writeFieldEnd()
14977 
    oprot.writeFieldStop()
14978 
    oprot.writeStructEnd()
14979 
 
14980 
  def validate(self):
14981 
    return
14982 
 
14983 
 
14984 
  def __repr__(self):
14985 
    L = ['%s=%r' % (key, value)
14986 
      for key, value in self.__dict__.iteritems()]
14987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14988 
 
14989 
  def __eq__(self, other):
14990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14991 
 
14992 
  def __ne__(self, other):
14993 
    return not (self == other)
14994 
 
14995 
class getNonDeliveredOrdersbyCourier_result:
14996 
  """
14997 
  Attributes:
14998 
   - success
14999 
  """
15000 
 
15001 
  thrift_spec = (
15002 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15003 
  )
15004 
 
15005 
  def __init__(self, success=None,):
15006 
    self.success = success
15007 
 
15008 
  def read(self, iprot):
15009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15011 
      return
15012 
    iprot.readStructBegin()
15013 
    while True:
15014 
      (fname, ftype, fid) = iprot.readFieldBegin()
15015 
      if ftype == TType.STOP:
15016 
        break
4581 phani.kuma 15017 
      if fid == 0:
15018 
        if ftype == TType.LIST:
15019 
          self.success = []
6188 rajveer 15020 
          (_etype355, _size352) = iprot.readListBegin()
15021 
          for _i356 in xrange(_size352):
15022 
            _elem357 = Order()
15023 
            _elem357.read(iprot)
15024 
            self.success.append(_elem357)
4581 phani.kuma 15025 
          iprot.readListEnd()
15026 
        else:
15027 
          iprot.skip(ftype)
4910 phani.kuma 15028 
      else:
15029 
        iprot.skip(ftype)
15030 
      iprot.readFieldEnd()
15031 
    iprot.readStructEnd()
15032 
 
15033 
  def write(self, oprot):
15034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15036 
      return
15037 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15038 
    if self.success is not None:
15039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15041 
      for iter358 in self.success:
15042 
        iter358.write(oprot)
4910 phani.kuma 15043 
      oprot.writeListEnd()
15044 
      oprot.writeFieldEnd()
15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
15063 
class markOrdersAsLocalConnected_args:
15064 
  """
15065 
  Attributes:
15066 
   - providerId
15067 
   - local_connected_orders
15068 
  """
15069 
 
15070 
  thrift_spec = (
15071 
    None, # 0
15072 
    (1, TType.I64, 'providerId', None, None, ), # 1
15073 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15074 
  )
15075 
 
15076 
  def __init__(self, providerId=None, local_connected_orders=None,):
15077 
    self.providerId = providerId
15078 
    self.local_connected_orders = local_connected_orders
15079 
 
15080 
  def read(self, iprot):
15081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15083 
      return
15084 
    iprot.readStructBegin()
15085 
    while True:
15086 
      (fname, ftype, fid) = iprot.readFieldBegin()
15087 
      if ftype == TType.STOP:
15088 
        break
15089 
      if fid == 1:
15090 
        if ftype == TType.I64:
15091 
          self.providerId = iprot.readI64();
15092 
        else:
15093 
          iprot.skip(ftype)
15094 
      elif fid == 2:
15095 
        if ftype == TType.MAP:
15096 
          self.local_connected_orders = {}
6188 rajveer 15097 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15098 
          for _i363 in xrange(_size359):
15099 
            _key364 = iprot.readString();
15100 
            _val365 = iprot.readString();
15101 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15102 
          iprot.readMapEnd()
15103 
        else:
15104 
          iprot.skip(ftype)
15105 
      else:
15106 
        iprot.skip(ftype)
15107 
      iprot.readFieldEnd()
15108 
    iprot.readStructEnd()
15109 
 
15110 
  def write(self, oprot):
15111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15113 
      return
15114 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15115 
    if self.providerId is not None:
15116 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15117 
      oprot.writeI64(self.providerId)
15118 
      oprot.writeFieldEnd()
15119 
    if self.local_connected_orders is not None:
15120 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15121 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15122 
      for kiter366,viter367 in self.local_connected_orders.items():
15123 
        oprot.writeString(kiter366)
15124 
        oprot.writeString(viter367)
4910 phani.kuma 15125 
      oprot.writeMapEnd()
15126 
      oprot.writeFieldEnd()
15127 
    oprot.writeFieldStop()
15128 
    oprot.writeStructEnd()
15129 
 
15130 
  def validate(self):
15131 
    return
15132 
 
15133 
 
15134 
  def __repr__(self):
15135 
    L = ['%s=%r' % (key, value)
15136 
      for key, value in self.__dict__.iteritems()]
15137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15138 
 
15139 
  def __eq__(self, other):
15140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15141 
 
15142 
  def __ne__(self, other):
15143 
    return not (self == other)
15144 
 
15145 
class markOrdersAsLocalConnected_result:
15146 
  """
15147 
  Attributes:
15148 
   - ex
15149 
  """
15150 
 
15151 
  thrift_spec = (
15152 
    None, # 0
15153 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15154 
  )
15155 
 
15156 
  def __init__(self, ex=None,):
15157 
    self.ex = ex
15158 
 
15159 
  def read(self, iprot):
15160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15162 
      return
15163 
    iprot.readStructBegin()
15164 
    while True:
15165 
      (fname, ftype, fid) = iprot.readFieldBegin()
15166 
      if ftype == TType.STOP:
15167 
        break
15168 
      if fid == 1:
3064 chandransh 15169 
        if ftype == TType.STRUCT:
15170 
          self.ex = TransactionServiceException()
15171 
          self.ex.read(iprot)
1627 ankur.sing 15172 
        else:
15173 
          iprot.skip(ftype)
15174 
      else:
15175 
        iprot.skip(ftype)
15176 
      iprot.readFieldEnd()
15177 
    iprot.readStructEnd()
15178 
 
15179 
  def write(self, oprot):
15180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15182 
      return
4910 phani.kuma 15183 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15184 
    if self.ex is not None:
15185 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15186 
      self.ex.write(oprot)
15187 
      oprot.writeFieldEnd()
15188 
    oprot.writeFieldStop()
15189 
    oprot.writeStructEnd()
15190 
 
15191 
  def validate(self):
15192 
    return
15193 
 
15194 
 
15195 
  def __repr__(self):
15196 
    L = ['%s=%r' % (key, value)
15197 
      for key, value in self.__dict__.iteritems()]
15198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15199 
 
15200 
  def __eq__(self, other):
15201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15202 
 
15203 
  def __ne__(self, other):
15204 
    return not (self == other)
15205 
 
15206 
class getOrdersNotLocalConnected_args:
15207 
  """
15208 
  Attributes:
15209 
   - providerId
15210 
  """
15211 
 
15212 
  thrift_spec = (
15213 
    None, # 0
15214 
    (1, TType.I64, 'providerId', None, None, ), # 1
15215 
  )
15216 
 
15217 
  def __init__(self, providerId=None,):
15218 
    self.providerId = providerId
15219 
 
15220 
  def read(self, iprot):
15221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15223 
      return
15224 
    iprot.readStructBegin()
15225 
    while True:
15226 
      (fname, ftype, fid) = iprot.readFieldBegin()
15227 
      if ftype == TType.STOP:
15228 
        break
15229 
      if fid == 1:
15230 
        if ftype == TType.I64:
15231 
          self.providerId = iprot.readI64();
15232 
        else:
15233 
          iprot.skip(ftype)
15234 
      else:
15235 
        iprot.skip(ftype)
15236 
      iprot.readFieldEnd()
15237 
    iprot.readStructEnd()
15238 
 
15239 
  def write(self, oprot):
15240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15242 
      return
15243 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15244 
    if self.providerId is not None:
15245 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15246 
      oprot.writeI64(self.providerId)
15247 
      oprot.writeFieldEnd()
15248 
    oprot.writeFieldStop()
15249 
    oprot.writeStructEnd()
15250 
 
15251 
  def validate(self):
15252 
    return
15253 
 
15254 
 
15255 
  def __repr__(self):
15256 
    L = ['%s=%r' % (key, value)
15257 
      for key, value in self.__dict__.iteritems()]
15258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15259 
 
15260 
  def __eq__(self, other):
15261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15262 
 
15263 
  def __ne__(self, other):
15264 
    return not (self == other)
15265 
 
15266 
class getOrdersNotLocalConnected_result:
15267 
  """
15268 
  Attributes:
15269 
   - success
15270 
  """
15271 
 
15272 
  thrift_spec = (
15273 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15274 
  )
15275 
 
15276 
  def __init__(self, success=None,):
15277 
    self.success = success
15278 
 
15279 
  def read(self, iprot):
15280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15282 
      return
15283 
    iprot.readStructBegin()
15284 
    while True:
15285 
      (fname, ftype, fid) = iprot.readFieldBegin()
15286 
      if ftype == TType.STOP:
15287 
        break
15288 
      if fid == 0:
15289 
        if ftype == TType.LIST:
15290 
          self.success = []
6188 rajveer 15291 
          (_etype371, _size368) = iprot.readListBegin()
15292 
          for _i372 in xrange(_size368):
15293 
            _elem373 = Order()
15294 
            _elem373.read(iprot)
15295 
            self.success.append(_elem373)
4910 phani.kuma 15296 
          iprot.readListEnd()
15297 
        else:
15298 
          iprot.skip(ftype)
15299 
      else:
15300 
        iprot.skip(ftype)
15301 
      iprot.readFieldEnd()
15302 
    iprot.readStructEnd()
15303 
 
15304 
  def write(self, oprot):
15305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15307 
      return
15308 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15309 
    if self.success is not None:
15310 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15311 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15312 
      for iter374 in self.success:
15313 
        iter374.write(oprot)
4581 phani.kuma 15314 
      oprot.writeListEnd()
15315 
      oprot.writeFieldEnd()
4910 phani.kuma 15316 
    oprot.writeFieldStop()
15317 
    oprot.writeStructEnd()
15318 
 
15319 
  def validate(self):
15320 
    return
15321 
 
15322 
 
15323 
  def __repr__(self):
15324 
    L = ['%s=%r' % (key, value)
15325 
      for key, value in self.__dict__.iteritems()]
15326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15327 
 
15328 
  def __eq__(self, other):
15329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15330 
 
15331 
  def __ne__(self, other):
15332 
    return not (self == other)
15333 
 
15334 
class markOrdersAsDestinationCityReached_args:
15335 
  """
15336 
  Attributes:
15337 
   - providerId
15338 
   - destination_city_reached_orders
15339 
  """
15340 
 
15341 
  thrift_spec = (
15342 
    None, # 0
15343 
    (1, TType.I64, 'providerId', None, None, ), # 1
15344 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15345 
  )
15346 
 
15347 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15348 
    self.providerId = providerId
15349 
    self.destination_city_reached_orders = destination_city_reached_orders
15350 
 
15351 
  def read(self, iprot):
15352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15354 
      return
15355 
    iprot.readStructBegin()
15356 
    while True:
15357 
      (fname, ftype, fid) = iprot.readFieldBegin()
15358 
      if ftype == TType.STOP:
15359 
        break
15360 
      if fid == 1:
15361 
        if ftype == TType.I64:
15362 
          self.providerId = iprot.readI64();
15363 
        else:
15364 
          iprot.skip(ftype)
15365 
      elif fid == 2:
15366 
        if ftype == TType.MAP:
15367 
          self.destination_city_reached_orders = {}
6188 rajveer 15368 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15369 
          for _i379 in xrange(_size375):
15370 
            _key380 = iprot.readString();
15371 
            _val381 = iprot.readString();
15372 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15373 
          iprot.readMapEnd()
15374 
        else:
15375 
          iprot.skip(ftype)
15376 
      else:
15377 
        iprot.skip(ftype)
15378 
      iprot.readFieldEnd()
15379 
    iprot.readStructEnd()
15380 
 
15381 
  def write(self, oprot):
15382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15384 
      return
15385 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15386 
    if self.providerId is not None:
15387 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15388 
      oprot.writeI64(self.providerId)
15389 
      oprot.writeFieldEnd()
15390 
    if self.destination_city_reached_orders is not None:
15391 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15392 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15393 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15394 
        oprot.writeString(kiter382)
15395 
        oprot.writeString(viter383)
4910 phani.kuma 15396 
      oprot.writeMapEnd()
15397 
      oprot.writeFieldEnd()
15398 
    oprot.writeFieldStop()
15399 
    oprot.writeStructEnd()
15400 
 
15401 
  def validate(self):
15402 
    return
15403 
 
15404 
 
15405 
  def __repr__(self):
15406 
    L = ['%s=%r' % (key, value)
15407 
      for key, value in self.__dict__.iteritems()]
15408 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15409 
 
15410 
  def __eq__(self, other):
15411 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15412 
 
15413 
  def __ne__(self, other):
15414 
    return not (self == other)
15415 
 
15416 
class markOrdersAsDestinationCityReached_result:
15417 
  """
15418 
  Attributes:
15419 
   - ex
15420 
  """
15421 
 
15422 
  thrift_spec = (
15423 
    None, # 0
15424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15425 
  )
15426 
 
15427 
  def __init__(self, ex=None,):
15428 
    self.ex = ex
15429 
 
15430 
  def read(self, iprot):
15431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15433 
      return
15434 
    iprot.readStructBegin()
15435 
    while True:
15436 
      (fname, ftype, fid) = iprot.readFieldBegin()
15437 
      if ftype == TType.STOP:
15438 
        break
15439 
      if fid == 1:
15440 
        if ftype == TType.STRUCT:
15441 
          self.ex = TransactionServiceException()
15442 
          self.ex.read(iprot)
15443 
        else:
15444 
          iprot.skip(ftype)
15445 
      else:
15446 
        iprot.skip(ftype)
15447 
      iprot.readFieldEnd()
15448 
    iprot.readStructEnd()
15449 
 
15450 
  def write(self, oprot):
15451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15453 
      return
15454 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15455 
    if self.ex is not None:
3064 chandransh 15456 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15457 
      self.ex.write(oprot)
1627 ankur.sing 15458 
      oprot.writeFieldEnd()
15459 
    oprot.writeFieldStop()
15460 
    oprot.writeStructEnd()
15461 
 
3431 rajveer 15462 
  def validate(self):
15463 
    return
15464 
 
15465 
 
1627 ankur.sing 15466 
  def __repr__(self):
15467 
    L = ['%s=%r' % (key, value)
15468 
      for key, value in self.__dict__.iteritems()]
15469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15470 
 
15471 
  def __eq__(self, other):
15472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15473 
 
15474 
  def __ne__(self, other):
15475 
    return not (self == other)
15476 
 
4910 phani.kuma 15477 
class markOrdersAsFirstDeliveryAttempted_args:
15478 
  """
15479 
  Attributes:
15480 
   - providerId
15481 
   - first_atdl_orders
15482 
  """
15483 
 
15484 
  thrift_spec = (
15485 
    None, # 0
15486 
    (1, TType.I64, 'providerId', None, None, ), # 1
15487 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15488 
  )
15489 
 
15490 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15491 
    self.providerId = providerId
15492 
    self.first_atdl_orders = first_atdl_orders
15493 
 
15494 
  def read(self, iprot):
15495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15497 
      return
15498 
    iprot.readStructBegin()
15499 
    while True:
15500 
      (fname, ftype, fid) = iprot.readFieldBegin()
15501 
      if ftype == TType.STOP:
15502 
        break
15503 
      if fid == 1:
15504 
        if ftype == TType.I64:
15505 
          self.providerId = iprot.readI64();
15506 
        else:
15507 
          iprot.skip(ftype)
15508 
      elif fid == 2:
15509 
        if ftype == TType.MAP:
15510 
          self.first_atdl_orders = {}
6188 rajveer 15511 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15512 
          for _i388 in xrange(_size384):
15513 
            _key389 = iprot.readString();
15514 
            _val390 = iprot.readString();
15515 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15516 
          iprot.readMapEnd()
15517 
        else:
15518 
          iprot.skip(ftype)
15519 
      else:
15520 
        iprot.skip(ftype)
15521 
      iprot.readFieldEnd()
15522 
    iprot.readStructEnd()
15523 
 
15524 
  def write(self, oprot):
15525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15527 
      return
15528 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15529 
    if self.providerId is not None:
15530 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15531 
      oprot.writeI64(self.providerId)
15532 
      oprot.writeFieldEnd()
15533 
    if self.first_atdl_orders is not None:
15534 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15535 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15536 
      for kiter391,viter392 in self.first_atdl_orders.items():
15537 
        oprot.writeString(kiter391)
15538 
        oprot.writeString(viter392)
4910 phani.kuma 15539 
      oprot.writeMapEnd()
15540 
      oprot.writeFieldEnd()
15541 
    oprot.writeFieldStop()
15542 
    oprot.writeStructEnd()
15543 
 
15544 
  def validate(self):
15545 
    return
15546 
 
15547 
 
15548 
  def __repr__(self):
15549 
    L = ['%s=%r' % (key, value)
15550 
      for key, value in self.__dict__.iteritems()]
15551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15552 
 
15553 
  def __eq__(self, other):
15554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15555 
 
15556 
  def __ne__(self, other):
15557 
    return not (self == other)
15558 
 
15559 
class markOrdersAsFirstDeliveryAttempted_result:
15560 
  """
15561 
  Attributes:
15562 
   - ex
15563 
  """
15564 
 
15565 
  thrift_spec = (
15566 
    None, # 0
15567 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15568 
  )
15569 
 
15570 
  def __init__(self, ex=None,):
15571 
    self.ex = ex
15572 
 
15573 
  def read(self, iprot):
15574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15576 
      return
15577 
    iprot.readStructBegin()
15578 
    while True:
15579 
      (fname, ftype, fid) = iprot.readFieldBegin()
15580 
      if ftype == TType.STOP:
15581 
        break
15582 
      if fid == 1:
15583 
        if ftype == TType.STRUCT:
15584 
          self.ex = TransactionServiceException()
15585 
          self.ex.read(iprot)
15586 
        else:
15587 
          iprot.skip(ftype)
15588 
      else:
15589 
        iprot.skip(ftype)
15590 
      iprot.readFieldEnd()
15591 
    iprot.readStructEnd()
15592 
 
15593 
  def write(self, oprot):
15594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15596 
      return
15597 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15598 
    if self.ex is not None:
15599 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15600 
      self.ex.write(oprot)
15601 
      oprot.writeFieldEnd()
15602 
    oprot.writeFieldStop()
15603 
    oprot.writeStructEnd()
15604 
 
15605 
  def validate(self):
15606 
    return
15607 
 
15608 
 
15609 
  def __repr__(self):
15610 
    L = ['%s=%r' % (key, value)
15611 
      for key, value in self.__dict__.iteritems()]
15612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15613 
 
15614 
  def __eq__(self, other):
15615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15616 
 
15617 
  def __ne__(self, other):
15618 
    return not (self == other)
15619 
 
3064 chandransh 15620 
class getUndeliveredOrders_args:
1886 ankur.sing 15621 
  """
15622 
  Attributes:
3064 chandransh 15623 
   - providerId
15624 
   - warehouseId
1886 ankur.sing 15625 
  """
1627 ankur.sing 15626 
 
1886 ankur.sing 15627 
  thrift_spec = (
15628 
    None, # 0
3064 chandransh 15629 
    (1, TType.I64, 'providerId', None, None, ), # 1
15630 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15631 
  )
15632 
 
3064 chandransh 15633 
  def __init__(self, providerId=None, warehouseId=None,):
15634 
    self.providerId = providerId
15635 
    self.warehouseId = warehouseId
1886 ankur.sing 15636 
 
15637 
  def read(self, iprot):
15638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15640 
      return
15641 
    iprot.readStructBegin()
15642 
    while True:
15643 
      (fname, ftype, fid) = iprot.readFieldBegin()
15644 
      if ftype == TType.STOP:
15645 
        break
15646 
      if fid == 1:
15647 
        if ftype == TType.I64:
3064 chandransh 15648 
          self.providerId = iprot.readI64();
1886 ankur.sing 15649 
        else:
15650 
          iprot.skip(ftype)
3064 chandransh 15651 
      elif fid == 2:
15652 
        if ftype == TType.I64:
15653 
          self.warehouseId = iprot.readI64();
15654 
        else:
15655 
          iprot.skip(ftype)
1886 ankur.sing 15656 
      else:
15657 
        iprot.skip(ftype)
15658 
      iprot.readFieldEnd()
15659 
    iprot.readStructEnd()
15660 
 
15661 
  def write(self, oprot):
15662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15664 
      return
3064 chandransh 15665 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15666 
    if self.providerId is not None:
3064 chandransh 15667 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15668 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15669 
      oprot.writeFieldEnd()
3431 rajveer 15670 
    if self.warehouseId is not None:
3064 chandransh 15671 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15672 
      oprot.writeI64(self.warehouseId)
15673 
      oprot.writeFieldEnd()
1886 ankur.sing 15674 
    oprot.writeFieldStop()
15675 
    oprot.writeStructEnd()
15676 
 
3431 rajveer 15677 
  def validate(self):
15678 
    return
15679 
 
15680 
 
1886 ankur.sing 15681 
  def __repr__(self):
15682 
    L = ['%s=%r' % (key, value)
15683 
      for key, value in self.__dict__.iteritems()]
15684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15685 
 
15686 
  def __eq__(self, other):
15687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15688 
 
15689 
  def __ne__(self, other):
15690 
    return not (self == other)
15691 
 
3064 chandransh 15692 
class getUndeliveredOrders_result:
1886 ankur.sing 15693 
  """
15694 
  Attributes:
15695 
   - success
15696 
  """
15697 
 
15698 
  thrift_spec = (
15699 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15700 
  )
15701 
 
15702 
  def __init__(self, success=None,):
15703 
    self.success = success
15704 
 
15705 
  def read(self, iprot):
15706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15708 
      return
15709 
    iprot.readStructBegin()
15710 
    while True:
15711 
      (fname, ftype, fid) = iprot.readFieldBegin()
15712 
      if ftype == TType.STOP:
15713 
        break
15714 
      if fid == 0:
15715 
        if ftype == TType.LIST:
15716 
          self.success = []
6188 rajveer 15717 
          (_etype396, _size393) = iprot.readListBegin()
15718 
          for _i397 in xrange(_size393):
15719 
            _elem398 = Order()
15720 
            _elem398.read(iprot)
15721 
            self.success.append(_elem398)
1886 ankur.sing 15722 
          iprot.readListEnd()
15723 
        else:
15724 
          iprot.skip(ftype)
15725 
      else:
15726 
        iprot.skip(ftype)
15727 
      iprot.readFieldEnd()
15728 
    iprot.readStructEnd()
15729 
 
15730 
  def write(self, oprot):
15731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15733 
      return
3064 chandransh 15734 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15735 
    if self.success is not None:
1886 ankur.sing 15736 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15737 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15738 
      for iter399 in self.success:
15739 
        iter399.write(oprot)
1886 ankur.sing 15740 
      oprot.writeListEnd()
15741 
      oprot.writeFieldEnd()
15742 
    oprot.writeFieldStop()
15743 
    oprot.writeStructEnd()
15744 
 
3431 rajveer 15745 
  def validate(self):
15746 
    return
15747 
 
15748 
 
1886 ankur.sing 15749 
  def __repr__(self):
15750 
    L = ['%s=%r' % (key, value)
15751 
      for key, value in self.__dict__.iteritems()]
15752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15753 
 
15754 
  def __eq__(self, other):
15755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15756 
 
15757 
  def __ne__(self, other):
15758 
    return not (self == other)
15759 
 
4783 phani.kuma 15760 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15761 
 
15762 
  thrift_spec = (
15763 
  )
15764 
 
15765 
  def read(self, iprot):
15766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15768 
      return
15769 
    iprot.readStructBegin()
15770 
    while True:
15771 
      (fname, ftype, fid) = iprot.readFieldBegin()
15772 
      if ftype == TType.STOP:
15773 
        break
15774 
      else:
15775 
        iprot.skip(ftype)
15776 
      iprot.readFieldEnd()
15777 
    iprot.readStructEnd()
15778 
 
15779 
  def write(self, oprot):
15780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15782 
      return
15783 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15784 
    oprot.writeFieldStop()
15785 
    oprot.writeStructEnd()
15786 
 
15787 
  def validate(self):
15788 
    return
15789 
 
15790 
 
15791 
  def __repr__(self):
15792 
    L = ['%s=%r' % (key, value)
15793 
      for key, value in self.__dict__.iteritems()]
15794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15795 
 
15796 
  def __eq__(self, other):
15797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15798 
 
15799 
  def __ne__(self, other):
15800 
    return not (self == other)
15801 
 
15802 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15803 
  """
15804 
  Attributes:
15805 
   - success
15806 
  """
15807 
 
15808 
  thrift_spec = (
15809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15810 
  )
15811 
 
15812 
  def __init__(self, success=None,):
15813 
    self.success = success
15814 
 
15815 
  def read(self, iprot):
15816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15818 
      return
15819 
    iprot.readStructBegin()
15820 
    while True:
15821 
      (fname, ftype, fid) = iprot.readFieldBegin()
15822 
      if ftype == TType.STOP:
15823 
        break
15824 
      if fid == 0:
15825 
        if ftype == TType.LIST:
15826 
          self.success = []
6188 rajveer 15827 
          (_etype403, _size400) = iprot.readListBegin()
15828 
          for _i404 in xrange(_size400):
15829 
            _elem405 = Order()
15830 
            _elem405.read(iprot)
15831 
            self.success.append(_elem405)
4783 phani.kuma 15832 
          iprot.readListEnd()
15833 
        else:
15834 
          iprot.skip(ftype)
15835 
      else:
15836 
        iprot.skip(ftype)
15837 
      iprot.readFieldEnd()
15838 
    iprot.readStructEnd()
15839 
 
15840 
  def write(self, oprot):
15841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15843 
      return
15844 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15845 
    if self.success is not None:
15846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15848 
      for iter406 in self.success:
15849 
        iter406.write(oprot)
4783 phani.kuma 15850 
      oprot.writeListEnd()
15851 
      oprot.writeFieldEnd()
15852 
    oprot.writeFieldStop()
15853 
    oprot.writeStructEnd()
15854 
 
15855 
  def validate(self):
15856 
    return
15857 
 
15858 
 
15859 
  def __repr__(self):
15860 
    L = ['%s=%r' % (key, value)
15861 
      for key, value in self.__dict__.iteritems()]
15862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15863 
 
15864 
  def __eq__(self, other):
15865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15866 
 
15867 
  def __ne__(self, other):
15868 
    return not (self == other)
15869 
 
2536 chandransh 15870 
class toggleDOAFlag_args:
15871 
  """
15872 
  Attributes:
15873 
   - orderId
15874 
  """
1886 ankur.sing 15875 
 
2536 chandransh 15876 
  thrift_spec = (
15877 
    None, # 0
15878 
    (1, TType.I64, 'orderId', None, None, ), # 1
15879 
  )
15880 
 
15881 
  def __init__(self, orderId=None,):
15882 
    self.orderId = orderId
15883 
 
15884 
  def read(self, iprot):
15885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15887 
      return
15888 
    iprot.readStructBegin()
15889 
    while True:
15890 
      (fname, ftype, fid) = iprot.readFieldBegin()
15891 
      if ftype == TType.STOP:
15892 
        break
15893 
      if fid == 1:
15894 
        if ftype == TType.I64:
15895 
          self.orderId = iprot.readI64();
15896 
        else:
15897 
          iprot.skip(ftype)
15898 
      else:
15899 
        iprot.skip(ftype)
15900 
      iprot.readFieldEnd()
15901 
    iprot.readStructEnd()
15902 
 
15903 
  def write(self, oprot):
15904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15906 
      return
15907 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15908 
    if self.orderId is not None:
2536 chandransh 15909 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15910 
      oprot.writeI64(self.orderId)
15911 
      oprot.writeFieldEnd()
15912 
    oprot.writeFieldStop()
15913 
    oprot.writeStructEnd()
15914 
 
3431 rajveer 15915 
  def validate(self):
15916 
    return
15917 
 
15918 
 
2536 chandransh 15919 
  def __repr__(self):
15920 
    L = ['%s=%r' % (key, value)
15921 
      for key, value in self.__dict__.iteritems()]
15922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15923 
 
15924 
  def __eq__(self, other):
15925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15926 
 
15927 
  def __ne__(self, other):
15928 
    return not (self == other)
15929 
 
15930 
class toggleDOAFlag_result:
15931 
  """
15932 
  Attributes:
15933 
   - success
15934 
   - ex
15935 
  """
15936 
 
15937 
  thrift_spec = (
15938 
    (0, TType.BOOL, 'success', None, None, ), # 0
15939 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15940 
  )
15941 
 
15942 
  def __init__(self, success=None, ex=None,):
15943 
    self.success = success
15944 
    self.ex = ex
15945 
 
15946 
  def read(self, iprot):
15947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15949 
      return
15950 
    iprot.readStructBegin()
15951 
    while True:
15952 
      (fname, ftype, fid) = iprot.readFieldBegin()
15953 
      if ftype == TType.STOP:
15954 
        break
15955 
      if fid == 0:
15956 
        if ftype == TType.BOOL:
15957 
          self.success = iprot.readBool();
15958 
        else:
15959 
          iprot.skip(ftype)
15960 
      elif fid == 1:
15961 
        if ftype == TType.STRUCT:
15962 
          self.ex = TransactionServiceException()
15963 
          self.ex.read(iprot)
15964 
        else:
15965 
          iprot.skip(ftype)
15966 
      else:
15967 
        iprot.skip(ftype)
15968 
      iprot.readFieldEnd()
15969 
    iprot.readStructEnd()
15970 
 
15971 
  def write(self, oprot):
15972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15974 
      return
15975 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15976 
    if self.success is not None:
2536 chandransh 15977 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15978 
      oprot.writeBool(self.success)
15979 
      oprot.writeFieldEnd()
3431 rajveer 15980 
    if self.ex is not None:
2536 chandransh 15981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15982 
      self.ex.write(oprot)
15983 
      oprot.writeFieldEnd()
15984 
    oprot.writeFieldStop()
15985 
    oprot.writeStructEnd()
15986 
 
3431 rajveer 15987 
  def validate(self):
15988 
    return
15989 
 
15990 
 
2536 chandransh 15991 
  def __repr__(self):
15992 
    L = ['%s=%r' % (key, value)
15993 
      for key, value in self.__dict__.iteritems()]
15994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15995 
 
15996 
  def __eq__(self, other):
15997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15998 
 
15999 
  def __ne__(self, other):
16000 
    return not (self == other)
16001 
 
4712 rajveer 16002 
class markOrderAsDelivered_args:
16003 
  """
16004 
  Attributes:
16005 
   - orderId
16006 
   - deliveryTimestamp
16007 
   - receiver
16008 
  """
16009 
 
16010 
  thrift_spec = None
16011 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16012 
    self.orderId = orderId
16013 
    self.deliveryTimestamp = deliveryTimestamp
16014 
    self.receiver = receiver
16015 
 
16016 
  def read(self, iprot):
16017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16019 
      return
16020 
    iprot.readStructBegin()
16021 
    while True:
16022 
      (fname, ftype, fid) = iprot.readFieldBegin()
16023 
      if ftype == TType.STOP:
16024 
        break
16025 
      if fid == 1:
16026 
        if ftype == TType.I64:
16027 
          self.orderId = iprot.readI64();
16028 
        else:
16029 
          iprot.skip(ftype)
16030 
      elif fid == 2:
16031 
        if ftype == TType.I64:
16032 
          self.deliveryTimestamp = iprot.readI64();
16033 
        else:
16034 
          iprot.skip(ftype)
16035 
      elif fid == -1:
16036 
        if ftype == TType.STRING:
16037 
          self.receiver = iprot.readString();
16038 
        else:
16039 
          iprot.skip(ftype)
16040 
      else:
16041 
        iprot.skip(ftype)
16042 
      iprot.readFieldEnd()
16043 
    iprot.readStructEnd()
16044 
 
16045 
  def write(self, oprot):
16046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16048 
      return
16049 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16050 
    if self.receiver is not None:
16051 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16052 
      oprot.writeString(self.receiver)
16053 
      oprot.writeFieldEnd()
16054 
    if self.orderId is not None:
16055 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16056 
      oprot.writeI64(self.orderId)
16057 
      oprot.writeFieldEnd()
16058 
    if self.deliveryTimestamp is not None:
16059 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16060 
      oprot.writeI64(self.deliveryTimestamp)
16061 
      oprot.writeFieldEnd()
16062 
    oprot.writeFieldStop()
16063 
    oprot.writeStructEnd()
16064 
 
16065 
  def validate(self):
16066 
    return
16067 
 
16068 
 
16069 
  def __repr__(self):
16070 
    L = ['%s=%r' % (key, value)
16071 
      for key, value in self.__dict__.iteritems()]
16072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16073 
 
16074 
  def __eq__(self, other):
16075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16076 
 
16077 
  def __ne__(self, other):
16078 
    return not (self == other)
16079 
 
16080 
class markOrderAsDelivered_result:
16081 
  """
16082 
  Attributes:
16083 
   - ex
16084 
  """
16085 
 
16086 
  thrift_spec = (
16087 
    None, # 0
16088 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16089 
  )
16090 
 
16091 
  def __init__(self, ex=None,):
16092 
    self.ex = ex
16093 
 
16094 
  def read(self, iprot):
16095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16097 
      return
16098 
    iprot.readStructBegin()
16099 
    while True:
16100 
      (fname, ftype, fid) = iprot.readFieldBegin()
16101 
      if ftype == TType.STOP:
16102 
        break
16103 
      if fid == 1:
16104 
        if ftype == TType.STRUCT:
16105 
          self.ex = TransactionServiceException()
16106 
          self.ex.read(iprot)
16107 
        else:
16108 
          iprot.skip(ftype)
16109 
      else:
16110 
        iprot.skip(ftype)
16111 
      iprot.readFieldEnd()
16112 
    iprot.readStructEnd()
16113 
 
16114 
  def write(self, oprot):
16115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16117 
      return
16118 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16119 
    if self.ex is not None:
16120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16121 
      self.ex.write(oprot)
16122 
      oprot.writeFieldEnd()
16123 
    oprot.writeFieldStop()
16124 
    oprot.writeStructEnd()
16125 
 
16126 
  def validate(self):
16127 
    return
16128 
 
16129 
 
16130 
  def __repr__(self):
16131 
    L = ['%s=%r' % (key, value)
16132 
      for key, value in self.__dict__.iteritems()]
16133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16134 
 
16135 
  def __eq__(self, other):
16136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16137 
 
16138 
  def __ne__(self, other):
16139 
    return not (self == other)
16140 
 
5553 rajveer 16141 
class markOrderAsReceivedAtStore_args:
16142 
  """
16143 
  Attributes:
16144 
   - orderId
16145 
   - deliveryTimestamp
16146 
  """
16147 
 
16148 
  thrift_spec = (
16149 
    None, # 0
16150 
    (1, TType.I64, 'orderId', None, None, ), # 1
16151 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16152 
  )
16153 
 
16154 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16155 
    self.orderId = orderId
16156 
    self.deliveryTimestamp = deliveryTimestamp
16157 
 
16158 
  def read(self, iprot):
16159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16161 
      return
16162 
    iprot.readStructBegin()
16163 
    while True:
16164 
      (fname, ftype, fid) = iprot.readFieldBegin()
16165 
      if ftype == TType.STOP:
16166 
        break
16167 
      if fid == 1:
16168 
        if ftype == TType.I64:
16169 
          self.orderId = iprot.readI64();
16170 
        else:
16171 
          iprot.skip(ftype)
16172 
      elif fid == 2:
16173 
        if ftype == TType.I64:
16174 
          self.deliveryTimestamp = iprot.readI64();
16175 
        else:
16176 
          iprot.skip(ftype)
16177 
      else:
16178 
        iprot.skip(ftype)
16179 
      iprot.readFieldEnd()
16180 
    iprot.readStructEnd()
16181 
 
16182 
  def write(self, oprot):
16183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16185 
      return
16186 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16187 
    if self.orderId is not None:
16188 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16189 
      oprot.writeI64(self.orderId)
16190 
      oprot.writeFieldEnd()
16191 
    if self.deliveryTimestamp is not None:
16192 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16193 
      oprot.writeI64(self.deliveryTimestamp)
16194 
      oprot.writeFieldEnd()
16195 
    oprot.writeFieldStop()
16196 
    oprot.writeStructEnd()
16197 
 
16198 
  def validate(self):
16199 
    return
16200 
 
16201 
 
16202 
  def __repr__(self):
16203 
    L = ['%s=%r' % (key, value)
16204 
      for key, value in self.__dict__.iteritems()]
16205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16206 
 
16207 
  def __eq__(self, other):
16208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16209 
 
16210 
  def __ne__(self, other):
16211 
    return not (self == other)
16212 
 
16213 
class markOrderAsReceivedAtStore_result:
16214 
  """
16215 
  Attributes:
16216 
   - ex
16217 
  """
16218 
 
16219 
  thrift_spec = (
16220 
    None, # 0
16221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16222 
  )
16223 
 
16224 
  def __init__(self, ex=None,):
16225 
    self.ex = ex
16226 
 
16227 
  def read(self, iprot):
16228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16230 
      return
16231 
    iprot.readStructBegin()
16232 
    while True:
16233 
      (fname, ftype, fid) = iprot.readFieldBegin()
16234 
      if ftype == TType.STOP:
16235 
        break
16236 
      if fid == 1:
16237 
        if ftype == TType.STRUCT:
16238 
          self.ex = TransactionServiceException()
16239 
          self.ex.read(iprot)
16240 
        else:
16241 
          iprot.skip(ftype)
16242 
      else:
16243 
        iprot.skip(ftype)
16244 
      iprot.readFieldEnd()
16245 
    iprot.readStructEnd()
16246 
 
16247 
  def write(self, oprot):
16248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16250 
      return
16251 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16252 
    if self.ex is not None:
16253 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16254 
      self.ex.write(oprot)
16255 
      oprot.writeFieldEnd()
16256 
    oprot.writeFieldStop()
16257 
    oprot.writeStructEnd()
16258 
 
16259 
  def validate(self):
16260 
    return
16261 
 
16262 
 
16263 
  def __repr__(self):
16264 
    L = ['%s=%r' % (key, value)
16265 
      for key, value in self.__dict__.iteritems()]
16266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16267 
 
16268 
  def __eq__(self, other):
16269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16270 
 
16271 
  def __ne__(self, other):
16272 
    return not (self == other)
16273 
 
4454 rajveer 16274 
class markOrderDoaRequestReceived_args:
16275 
  """
16276 
  Attributes:
16277 
   - orderId
16278 
  """
16279 
 
16280 
  thrift_spec = (
16281 
    None, # 0
16282 
    (1, TType.I64, 'orderId', None, None, ), # 1
16283 
  )
16284 
 
16285 
  def __init__(self, orderId=None,):
16286 
    self.orderId = orderId
16287 
 
16288 
  def read(self, iprot):
16289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16291 
      return
16292 
    iprot.readStructBegin()
16293 
    while True:
16294 
      (fname, ftype, fid) = iprot.readFieldBegin()
16295 
      if ftype == TType.STOP:
16296 
        break
16297 
      if fid == 1:
16298 
        if ftype == TType.I64:
16299 
          self.orderId = iprot.readI64();
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('markOrderDoaRequestReceived_args')
16312 
    if self.orderId is not None:
16313 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16314 
      oprot.writeI64(self.orderId)
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 
 
16334 
class markOrderDoaRequestReceived_result:
16335 
  """
16336 
  Attributes:
16337 
   - success
16338 
   - ex
16339 
  """
16340 
 
16341 
  thrift_spec = (
16342 
    (0, TType.BOOL, 'success', None, None, ), # 0
16343 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16344 
  )
16345 
 
16346 
  def __init__(self, success=None, ex=None,):
16347 
    self.success = success
16348 
    self.ex = ex
16349 
 
16350 
  def read(self, iprot):
16351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16353 
      return
16354 
    iprot.readStructBegin()
16355 
    while True:
16356 
      (fname, ftype, fid) = iprot.readFieldBegin()
16357 
      if ftype == TType.STOP:
16358 
        break
16359 
      if fid == 0:
16360 
        if ftype == TType.BOOL:
16361 
          self.success = iprot.readBool();
16362 
        else:
16363 
          iprot.skip(ftype)
16364 
      elif fid == 1:
16365 
        if ftype == TType.STRUCT:
16366 
          self.ex = TransactionServiceException()
16367 
          self.ex.read(iprot)
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('markOrderDoaRequestReceived_result')
16380 
    if self.success is not None:
16381 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16382 
      oprot.writeBool(self.success)
16383 
      oprot.writeFieldEnd()
16384 
    if self.ex is not None:
16385 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16386 
      self.ex.write(oprot)
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 markOrderDoaRequestAuthorized_args:
16407 
  """
16408 
  Attributes:
16409 
   - orderId
16410 
   - isAuthorized
16411 
  """
16412 
 
16413 
  thrift_spec = (
16414 
    None, # 0
16415 
    (1, TType.I64, 'orderId', None, None, ), # 1
16416 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16417 
  )
16418 
 
16419 
  def __init__(self, orderId=None, isAuthorized=None,):
16420 
    self.orderId = orderId
16421 
    self.isAuthorized = isAuthorized
16422 
 
16423 
  def read(self, iprot):
16424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16426 
      return
16427 
    iprot.readStructBegin()
16428 
    while True:
16429 
      (fname, ftype, fid) = iprot.readFieldBegin()
16430 
      if ftype == TType.STOP:
16431 
        break
16432 
      if fid == 1:
16433 
        if ftype == TType.I64:
16434 
          self.orderId = iprot.readI64();
16435 
        else:
16436 
          iprot.skip(ftype)
16437 
      elif fid == 2:
16438 
        if ftype == TType.BOOL:
16439 
          self.isAuthorized = iprot.readBool();
16440 
        else:
16441 
          iprot.skip(ftype)
16442 
      else:
16443 
        iprot.skip(ftype)
16444 
      iprot.readFieldEnd()
16445 
    iprot.readStructEnd()
16446 
 
16447 
  def write(self, oprot):
16448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16450 
      return
16451 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16452 
    if self.orderId is not None:
16453 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16454 
      oprot.writeI64(self.orderId)
16455 
      oprot.writeFieldEnd()
16456 
    if self.isAuthorized is not None:
16457 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16458 
      oprot.writeBool(self.isAuthorized)
16459 
      oprot.writeFieldEnd()
16460 
    oprot.writeFieldStop()
16461 
    oprot.writeStructEnd()
16462 
 
16463 
  def validate(self):
16464 
    return
16465 
 
16466 
 
16467 
  def __repr__(self):
16468 
    L = ['%s=%r' % (key, value)
16469 
      for key, value in self.__dict__.iteritems()]
16470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16471 
 
16472 
  def __eq__(self, other):
16473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16474 
 
16475 
  def __ne__(self, other):
16476 
    return not (self == other)
16477 
 
16478 
class markOrderDoaRequestAuthorized_result:
16479 
  """
16480 
  Attributes:
16481 
   - success
16482 
   - ex
16483 
  """
16484 
 
16485 
  thrift_spec = (
16486 
    (0, TType.BOOL, 'success', None, None, ), # 0
16487 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16488 
  )
16489 
 
16490 
  def __init__(self, success=None, ex=None,):
16491 
    self.success = success
16492 
    self.ex = ex
16493 
 
16494 
  def read(self, iprot):
16495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16497 
      return
16498 
    iprot.readStructBegin()
16499 
    while True:
16500 
      (fname, ftype, fid) = iprot.readFieldBegin()
16501 
      if ftype == TType.STOP:
16502 
        break
16503 
      if fid == 0:
16504 
        if ftype == TType.BOOL:
16505 
          self.success = iprot.readBool();
16506 
        else:
16507 
          iprot.skip(ftype)
16508 
      elif fid == 1:
16509 
        if ftype == TType.STRUCT:
16510 
          self.ex = TransactionServiceException()
16511 
          self.ex.read(iprot)
16512 
        else:
16513 
          iprot.skip(ftype)
16514 
      else:
16515 
        iprot.skip(ftype)
16516 
      iprot.readFieldEnd()
16517 
    iprot.readStructEnd()
16518 
 
16519 
  def write(self, oprot):
16520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16522 
      return
16523 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16524 
    if self.success is not None:
16525 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16526 
      oprot.writeBool(self.success)
16527 
      oprot.writeFieldEnd()
16528 
    if self.ex is not None:
16529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16530 
      self.ex.write(oprot)
16531 
      oprot.writeFieldEnd()
16532 
    oprot.writeFieldStop()
16533 
    oprot.writeStructEnd()
16534 
 
16535 
  def validate(self):
16536 
    return
16537 
 
16538 
 
16539 
  def __repr__(self):
16540 
    L = ['%s=%r' % (key, value)
16541 
      for key, value in self.__dict__.iteritems()]
16542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16543 
 
16544 
  def __eq__(self, other):
16545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16546 
 
16547 
  def __ne__(self, other):
16548 
    return not (self == other)
16549 
 
4488 rajveer 16550 
class markOrderReturnRequestReceived_args:
16551 
  """
16552 
  Attributes:
16553 
   - orderId
16554 
  """
16555 
 
16556 
  thrift_spec = (
16557 
    None, # 0
16558 
    (1, TType.I64, 'orderId', None, None, ), # 1
16559 
  )
16560 
 
16561 
  def __init__(self, orderId=None,):
16562 
    self.orderId = orderId
16563 
 
16564 
  def read(self, iprot):
16565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16567 
      return
16568 
    iprot.readStructBegin()
16569 
    while True:
16570 
      (fname, ftype, fid) = iprot.readFieldBegin()
16571 
      if ftype == TType.STOP:
16572 
        break
16573 
      if fid == 1:
16574 
        if ftype == TType.I64:
16575 
          self.orderId = iprot.readI64();
16576 
        else:
16577 
          iprot.skip(ftype)
16578 
      else:
16579 
        iprot.skip(ftype)
16580 
      iprot.readFieldEnd()
16581 
    iprot.readStructEnd()
16582 
 
16583 
  def write(self, oprot):
16584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16586 
      return
16587 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16588 
    if self.orderId is not None:
16589 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16590 
      oprot.writeI64(self.orderId)
16591 
      oprot.writeFieldEnd()
16592 
    oprot.writeFieldStop()
16593 
    oprot.writeStructEnd()
16594 
 
16595 
  def validate(self):
16596 
    return
16597 
 
16598 
 
16599 
  def __repr__(self):
16600 
    L = ['%s=%r' % (key, value)
16601 
      for key, value in self.__dict__.iteritems()]
16602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16603 
 
16604 
  def __eq__(self, other):
16605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16606 
 
16607 
  def __ne__(self, other):
16608 
    return not (self == other)
16609 
 
16610 
class markOrderReturnRequestReceived_result:
16611 
  """
16612 
  Attributes:
16613 
   - success
16614 
   - ex
16615 
  """
16616 
 
16617 
  thrift_spec = (
16618 
    (0, TType.BOOL, 'success', None, None, ), # 0
16619 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16620 
  )
16621 
 
16622 
  def __init__(self, success=None, ex=None,):
16623 
    self.success = success
16624 
    self.ex = ex
16625 
 
16626 
  def read(self, iprot):
16627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16629 
      return
16630 
    iprot.readStructBegin()
16631 
    while True:
16632 
      (fname, ftype, fid) = iprot.readFieldBegin()
16633 
      if ftype == TType.STOP:
16634 
        break
16635 
      if fid == 0:
16636 
        if ftype == TType.BOOL:
16637 
          self.success = iprot.readBool();
16638 
        else:
16639 
          iprot.skip(ftype)
16640 
      elif fid == 1:
16641 
        if ftype == TType.STRUCT:
16642 
          self.ex = TransactionServiceException()
16643 
          self.ex.read(iprot)
16644 
        else:
16645 
          iprot.skip(ftype)
16646 
      else:
16647 
        iprot.skip(ftype)
16648 
      iprot.readFieldEnd()
16649 
    iprot.readStructEnd()
16650 
 
16651 
  def write(self, oprot):
16652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16654 
      return
16655 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16656 
    if self.success is not None:
16657 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16658 
      oprot.writeBool(self.success)
16659 
      oprot.writeFieldEnd()
16660 
    if self.ex is not None:
16661 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16662 
      self.ex.write(oprot)
16663 
      oprot.writeFieldEnd()
16664 
    oprot.writeFieldStop()
16665 
    oprot.writeStructEnd()
16666 
 
16667 
  def validate(self):
16668 
    return
16669 
 
16670 
 
16671 
  def __repr__(self):
16672 
    L = ['%s=%r' % (key, value)
16673 
      for key, value in self.__dict__.iteritems()]
16674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16675 
 
16676 
  def __eq__(self, other):
16677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16678 
 
16679 
  def __ne__(self, other):
16680 
    return not (self == other)
16681 
 
16682 
class markOrderReturnRequestAuthorized_args:
16683 
  """
16684 
  Attributes:
16685 
   - orderId
16686 
   - isAuthorized
16687 
  """
16688 
 
16689 
  thrift_spec = (
16690 
    None, # 0
16691 
    (1, TType.I64, 'orderId', None, None, ), # 1
16692 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16693 
  )
16694 
 
16695 
  def __init__(self, orderId=None, isAuthorized=None,):
16696 
    self.orderId = orderId
16697 
    self.isAuthorized = isAuthorized
16698 
 
16699 
  def read(self, iprot):
16700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16702 
      return
16703 
    iprot.readStructBegin()
16704 
    while True:
16705 
      (fname, ftype, fid) = iprot.readFieldBegin()
16706 
      if ftype == TType.STOP:
16707 
        break
16708 
      if fid == 1:
16709 
        if ftype == TType.I64:
16710 
          self.orderId = iprot.readI64();
16711 
        else:
16712 
          iprot.skip(ftype)
16713 
      elif fid == 2:
16714 
        if ftype == TType.BOOL:
16715 
          self.isAuthorized = iprot.readBool();
16716 
        else:
16717 
          iprot.skip(ftype)
16718 
      else:
16719 
        iprot.skip(ftype)
16720 
      iprot.readFieldEnd()
16721 
    iprot.readStructEnd()
16722 
 
16723 
  def write(self, oprot):
16724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16726 
      return
16727 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16728 
    if self.orderId is not None:
16729 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16730 
      oprot.writeI64(self.orderId)
16731 
      oprot.writeFieldEnd()
16732 
    if self.isAuthorized is not None:
16733 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16734 
      oprot.writeBool(self.isAuthorized)
16735 
      oprot.writeFieldEnd()
16736 
    oprot.writeFieldStop()
16737 
    oprot.writeStructEnd()
16738 
 
16739 
  def validate(self):
16740 
    return
16741 
 
16742 
 
16743 
  def __repr__(self):
16744 
    L = ['%s=%r' % (key, value)
16745 
      for key, value in self.__dict__.iteritems()]
16746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16747 
 
16748 
  def __eq__(self, other):
16749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16750 
 
16751 
  def __ne__(self, other):
16752 
    return not (self == other)
16753 
 
16754 
class markOrderReturnRequestAuthorized_result:
16755 
  """
16756 
  Attributes:
16757 
   - success
16758 
   - ex
16759 
  """
16760 
 
16761 
  thrift_spec = (
16762 
    (0, TType.BOOL, 'success', None, None, ), # 0
16763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16764 
  )
16765 
 
16766 
  def __init__(self, success=None, ex=None,):
16767 
    self.success = success
16768 
    self.ex = ex
16769 
 
16770 
  def read(self, iprot):
16771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16773 
      return
16774 
    iprot.readStructBegin()
16775 
    while True:
16776 
      (fname, ftype, fid) = iprot.readFieldBegin()
16777 
      if ftype == TType.STOP:
16778 
        break
16779 
      if fid == 0:
16780 
        if ftype == TType.BOOL:
16781 
          self.success = iprot.readBool();
16782 
        else:
16783 
          iprot.skip(ftype)
16784 
      elif fid == 1:
16785 
        if ftype == TType.STRUCT:
16786 
          self.ex = TransactionServiceException()
16787 
          self.ex.read(iprot)
16788 
        else:
16789 
          iprot.skip(ftype)
16790 
      else:
16791 
        iprot.skip(ftype)
16792 
      iprot.readFieldEnd()
16793 
    iprot.readStructEnd()
16794 
 
16795 
  def write(self, oprot):
16796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16798 
      return
16799 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16800 
    if self.success is not None:
16801 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16802 
      oprot.writeBool(self.success)
16803 
      oprot.writeFieldEnd()
16804 
    if self.ex is not None:
16805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16806 
      self.ex.write(oprot)
16807 
      oprot.writeFieldEnd()
16808 
    oprot.writeFieldStop()
16809 
    oprot.writeStructEnd()
16810 
 
16811 
  def validate(self):
16812 
    return
16813 
 
16814 
 
16815 
  def __repr__(self):
16816 
    L = ['%s=%r' % (key, value)
16817 
      for key, value in self.__dict__.iteritems()]
16818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16819 
 
16820 
  def __eq__(self, other):
16821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16822 
 
16823 
  def __ne__(self, other):
16824 
    return not (self == other)
16825 
 
2536 chandransh 16826 
class requestPickupNumber_args:
16827 
  """
16828 
  Attributes:
16829 
   - orderId
4579 rajveer 16830 
   - providerId
2536 chandransh 16831 
  """
16832 
 
16833 
  thrift_spec = (
16834 
    None, # 0
16835 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16836 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16837 
  )
16838 
 
4579 rajveer 16839 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16840 
    self.orderId = orderId
4579 rajveer 16841 
    self.providerId = providerId
2536 chandransh 16842 
 
16843 
  def read(self, iprot):
16844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16846 
      return
16847 
    iprot.readStructBegin()
16848 
    while True:
16849 
      (fname, ftype, fid) = iprot.readFieldBegin()
16850 
      if ftype == TType.STOP:
16851 
        break
16852 
      if fid == 1:
16853 
        if ftype == TType.I64:
16854 
          self.orderId = iprot.readI64();
16855 
        else:
16856 
          iprot.skip(ftype)
4579 rajveer 16857 
      elif fid == 2:
16858 
        if ftype == TType.I64:
16859 
          self.providerId = iprot.readI64();
16860 
        else:
16861 
          iprot.skip(ftype)
2536 chandransh 16862 
      else:
16863 
        iprot.skip(ftype)
16864 
      iprot.readFieldEnd()
16865 
    iprot.readStructEnd()
16866 
 
16867 
  def write(self, oprot):
16868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16870 
      return
16871 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16872 
    if self.orderId is not None:
2536 chandransh 16873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16874 
      oprot.writeI64(self.orderId)
16875 
      oprot.writeFieldEnd()
4579 rajveer 16876 
    if self.providerId is not None:
16877 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16878 
      oprot.writeI64(self.providerId)
16879 
      oprot.writeFieldEnd()
2536 chandransh 16880 
    oprot.writeFieldStop()
16881 
    oprot.writeStructEnd()
16882 
 
3431 rajveer 16883 
  def validate(self):
16884 
    return
16885 
 
16886 
 
2536 chandransh 16887 
  def __repr__(self):
16888 
    L = ['%s=%r' % (key, value)
16889 
      for key, value in self.__dict__.iteritems()]
16890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16891 
 
16892 
  def __eq__(self, other):
16893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16894 
 
16895 
  def __ne__(self, other):
16896 
    return not (self == other)
16897 
 
16898 
class requestPickupNumber_result:
16899 
  """
16900 
  Attributes:
16901 
   - success
16902 
   - ex
16903 
  """
16904 
 
16905 
  thrift_spec = (
16906 
    (0, TType.BOOL, 'success', None, None, ), # 0
16907 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16908 
  )
16909 
 
16910 
  def __init__(self, success=None, ex=None,):
16911 
    self.success = success
16912 
    self.ex = ex
16913 
 
16914 
  def read(self, iprot):
16915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16917 
      return
16918 
    iprot.readStructBegin()
16919 
    while True:
16920 
      (fname, ftype, fid) = iprot.readFieldBegin()
16921 
      if ftype == TType.STOP:
16922 
        break
16923 
      if fid == 0:
16924 
        if ftype == TType.BOOL:
16925 
          self.success = iprot.readBool();
16926 
        else:
16927 
          iprot.skip(ftype)
16928 
      elif fid == 1:
16929 
        if ftype == TType.STRUCT:
16930 
          self.ex = TransactionServiceException()
16931 
          self.ex.read(iprot)
16932 
        else:
16933 
          iprot.skip(ftype)
16934 
      else:
16935 
        iprot.skip(ftype)
16936 
      iprot.readFieldEnd()
16937 
    iprot.readStructEnd()
16938 
 
16939 
  def write(self, oprot):
16940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16942 
      return
16943 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16944 
    if self.success is not None:
2536 chandransh 16945 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16946 
      oprot.writeBool(self.success)
16947 
      oprot.writeFieldEnd()
3431 rajveer 16948 
    if self.ex is not None:
2536 chandransh 16949 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16950 
      self.ex.write(oprot)
16951 
      oprot.writeFieldEnd()
16952 
    oprot.writeFieldStop()
16953 
    oprot.writeStructEnd()
16954 
 
3431 rajveer 16955 
  def validate(self):
16956 
    return
16957 
 
16958 
 
2536 chandransh 16959 
  def __repr__(self):
16960 
    L = ['%s=%r' % (key, value)
16961 
      for key, value in self.__dict__.iteritems()]
16962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16963 
 
16964 
  def __eq__(self, other):
16965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16966 
 
16967 
  def __ne__(self, other):
16968 
    return not (self == other)
16969 
 
16970 
class authorizePickup_args:
16971 
  """
16972 
  Attributes:
16973 
   - orderId
16974 
   - pickupNumber
4602 rajveer 16975 
   - providerId
2536 chandransh 16976 
  """
16977 
 
16978 
  thrift_spec = (
16979 
    None, # 0
16980 
    (1, TType.I64, 'orderId', None, None, ), # 1
16981 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16982 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16983 
  )
16984 
 
4602 rajveer 16985 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16986 
    self.orderId = orderId
16987 
    self.pickupNumber = pickupNumber
4602 rajveer 16988 
    self.providerId = providerId
2536 chandransh 16989 
 
16990 
  def read(self, iprot):
16991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16993 
      return
16994 
    iprot.readStructBegin()
16995 
    while True:
16996 
      (fname, ftype, fid) = iprot.readFieldBegin()
16997 
      if ftype == TType.STOP:
16998 
        break
16999 
      if fid == 1:
17000 
        if ftype == TType.I64:
17001 
          self.orderId = iprot.readI64();
17002 
        else:
17003 
          iprot.skip(ftype)
17004 
      elif fid == 2:
17005 
        if ftype == TType.STRING:
17006 
          self.pickupNumber = iprot.readString();
17007 
        else:
17008 
          iprot.skip(ftype)
4602 rajveer 17009 
      elif fid == 3:
17010 
        if ftype == TType.I64:
17011 
          self.providerId = iprot.readI64();
17012 
        else:
17013 
          iprot.skip(ftype)
2536 chandransh 17014 
      else:
17015 
        iprot.skip(ftype)
17016 
      iprot.readFieldEnd()
17017 
    iprot.readStructEnd()
17018 
 
17019 
  def write(self, oprot):
17020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17022 
      return
17023 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17024 
    if self.orderId is not None:
2536 chandransh 17025 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17026 
      oprot.writeI64(self.orderId)
17027 
      oprot.writeFieldEnd()
3431 rajveer 17028 
    if self.pickupNumber is not None:
2536 chandransh 17029 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17030 
      oprot.writeString(self.pickupNumber)
17031 
      oprot.writeFieldEnd()
4602 rajveer 17032 
    if self.providerId is not None:
17033 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17034 
      oprot.writeI64(self.providerId)
17035 
      oprot.writeFieldEnd()
2536 chandransh 17036 
    oprot.writeFieldStop()
17037 
    oprot.writeStructEnd()
17038 
 
3431 rajveer 17039 
  def validate(self):
17040 
    return
17041 
 
17042 
 
2536 chandransh 17043 
  def __repr__(self):
17044 
    L = ['%s=%r' % (key, value)
17045 
      for key, value in self.__dict__.iteritems()]
17046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17047 
 
17048 
  def __eq__(self, other):
17049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17050 
 
17051 
  def __ne__(self, other):
17052 
    return not (self == other)
17053 
 
17054 
class authorizePickup_result:
17055 
  """
17056 
  Attributes:
17057 
   - success
17058 
   - ex
17059 
  """
17060 
 
17061 
  thrift_spec = (
17062 
    (0, TType.BOOL, 'success', None, None, ), # 0
17063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17064 
  )
17065 
 
17066 
  def __init__(self, success=None, ex=None,):
17067 
    self.success = success
17068 
    self.ex = ex
17069 
 
17070 
  def read(self, iprot):
17071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17073 
      return
17074 
    iprot.readStructBegin()
17075 
    while True:
17076 
      (fname, ftype, fid) = iprot.readFieldBegin()
17077 
      if ftype == TType.STOP:
17078 
        break
17079 
      if fid == 0:
17080 
        if ftype == TType.BOOL:
17081 
          self.success = iprot.readBool();
17082 
        else:
17083 
          iprot.skip(ftype)
17084 
      elif fid == 1:
17085 
        if ftype == TType.STRUCT:
17086 
          self.ex = TransactionServiceException()
17087 
          self.ex.read(iprot)
17088 
        else:
17089 
          iprot.skip(ftype)
17090 
      else:
17091 
        iprot.skip(ftype)
17092 
      iprot.readFieldEnd()
17093 
    iprot.readStructEnd()
17094 
 
17095 
  def write(self, oprot):
17096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17098 
      return
17099 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17100 
    if self.success is not None:
2536 chandransh 17101 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17102 
      oprot.writeBool(self.success)
17103 
      oprot.writeFieldEnd()
3431 rajveer 17104 
    if self.ex is not None:
2536 chandransh 17105 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17106 
      self.ex.write(oprot)
17107 
      oprot.writeFieldEnd()
17108 
    oprot.writeFieldStop()
17109 
    oprot.writeStructEnd()
17110 
 
3431 rajveer 17111 
  def validate(self):
17112 
    return
17113 
 
17114 
 
2536 chandransh 17115 
  def __repr__(self):
17116 
    L = ['%s=%r' % (key, value)
17117 
      for key, value in self.__dict__.iteritems()]
17118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17119 
 
17120 
  def __eq__(self, other):
17121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17122 
 
17123 
  def __ne__(self, other):
17124 
    return not (self == other)
17125 
 
2764 chandransh 17126 
class markDoasAsPickedUp_args:
17127 
  """
17128 
  Attributes:
17129 
   - providerId
17130 
   - pickupDetails
17131 
  """
17132 
 
17133 
  thrift_spec = (
17134 
    None, # 0
17135 
    (1, TType.I64, 'providerId', None, None, ), # 1
17136 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17137 
  )
17138 
 
17139 
  def __init__(self, providerId=None, pickupDetails=None,):
17140 
    self.providerId = providerId
17141 
    self.pickupDetails = pickupDetails
17142 
 
17143 
  def read(self, iprot):
17144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17146 
      return
17147 
    iprot.readStructBegin()
17148 
    while True:
17149 
      (fname, ftype, fid) = iprot.readFieldBegin()
17150 
      if ftype == TType.STOP:
17151 
        break
17152 
      if fid == 1:
17153 
        if ftype == TType.I64:
17154 
          self.providerId = iprot.readI64();
17155 
        else:
17156 
          iprot.skip(ftype)
17157 
      elif fid == 2:
17158 
        if ftype == TType.MAP:
17159 
          self.pickupDetails = {}
6188 rajveer 17160 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17161 
          for _i411 in xrange(_size407):
17162 
            _key412 = iprot.readString();
17163 
            _val413 = iprot.readString();
17164 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17165 
          iprot.readMapEnd()
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      else:
17169 
        iprot.skip(ftype)
17170 
      iprot.readFieldEnd()
17171 
    iprot.readStructEnd()
17172 
 
17173 
  def write(self, oprot):
17174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17176 
      return
17177 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17178 
    if self.providerId is not None:
2764 chandransh 17179 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17180 
      oprot.writeI64(self.providerId)
17181 
      oprot.writeFieldEnd()
3431 rajveer 17182 
    if self.pickupDetails is not None:
2764 chandransh 17183 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17184 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17185 
      for kiter414,viter415 in self.pickupDetails.items():
17186 
        oprot.writeString(kiter414)
17187 
        oprot.writeString(viter415)
2764 chandransh 17188 
      oprot.writeMapEnd()
17189 
      oprot.writeFieldEnd()
17190 
    oprot.writeFieldStop()
17191 
    oprot.writeStructEnd()
17192 
 
3431 rajveer 17193 
  def validate(self):
17194 
    return
17195 
 
17196 
 
2764 chandransh 17197 
  def __repr__(self):
17198 
    L = ['%s=%r' % (key, value)
17199 
      for key, value in self.__dict__.iteritems()]
17200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17201 
 
17202 
  def __eq__(self, other):
17203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17204 
 
17205 
  def __ne__(self, other):
17206 
    return not (self == other)
17207 
 
17208 
class markDoasAsPickedUp_result:
4910 phani.kuma 17209 
 
17210 
  thrift_spec = (
17211 
  )
17212 
 
17213 
  def read(self, iprot):
17214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17216 
      return
17217 
    iprot.readStructBegin()
17218 
    while True:
17219 
      (fname, ftype, fid) = iprot.readFieldBegin()
17220 
      if ftype == TType.STOP:
17221 
        break
17222 
      else:
17223 
        iprot.skip(ftype)
17224 
      iprot.readFieldEnd()
17225 
    iprot.readStructEnd()
17226 
 
17227 
  def write(self, oprot):
17228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17230 
      return
17231 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17232 
    oprot.writeFieldStop()
17233 
    oprot.writeStructEnd()
17234 
 
17235 
  def validate(self):
17236 
    return
17237 
 
17238 
 
17239 
  def __repr__(self):
17240 
    L = ['%s=%r' % (key, value)
17241 
      for key, value in self.__dict__.iteritems()]
17242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17243 
 
17244 
  def __eq__(self, other):
17245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17246 
 
17247 
  def __ne__(self, other):
17248 
    return not (self == other)
17249 
 
17250 
class getDoasNotPickedUp_args:
2764 chandransh 17251 
  """
17252 
  Attributes:
4910 phani.kuma 17253 
   - providerId
17254 
  """
17255 
 
17256 
  thrift_spec = (
17257 
    None, # 0
17258 
    (1, TType.I64, 'providerId', None, None, ), # 1
17259 
  )
17260 
 
17261 
  def __init__(self, providerId=None,):
17262 
    self.providerId = providerId
17263 
 
17264 
  def read(self, iprot):
17265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17267 
      return
17268 
    iprot.readStructBegin()
17269 
    while True:
17270 
      (fname, ftype, fid) = iprot.readFieldBegin()
17271 
      if ftype == TType.STOP:
17272 
        break
17273 
      if fid == 1:
17274 
        if ftype == TType.I64:
17275 
          self.providerId = iprot.readI64();
17276 
        else:
17277 
          iprot.skip(ftype)
17278 
      else:
17279 
        iprot.skip(ftype)
17280 
      iprot.readFieldEnd()
17281 
    iprot.readStructEnd()
17282 
 
17283 
  def write(self, oprot):
17284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17286 
      return
17287 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17288 
    if self.providerId is not None:
17289 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17290 
      oprot.writeI64(self.providerId)
17291 
      oprot.writeFieldEnd()
17292 
    oprot.writeFieldStop()
17293 
    oprot.writeStructEnd()
17294 
 
17295 
  def validate(self):
17296 
    return
17297 
 
17298 
 
17299 
  def __repr__(self):
17300 
    L = ['%s=%r' % (key, value)
17301 
      for key, value in self.__dict__.iteritems()]
17302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17303 
 
17304 
  def __eq__(self, other):
17305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17306 
 
17307 
  def __ne__(self, other):
17308 
    return not (self == other)
17309 
 
17310 
class getDoasNotPickedUp_result:
17311 
  """
17312 
  Attributes:
2764 chandransh 17313 
   - success
17314 
  """
17315 
 
17316 
  thrift_spec = (
17317 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17318 
  )
17319 
 
17320 
  def __init__(self, success=None,):
17321 
    self.success = success
17322 
 
17323 
  def read(self, iprot):
17324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17326 
      return
17327 
    iprot.readStructBegin()
17328 
    while True:
17329 
      (fname, ftype, fid) = iprot.readFieldBegin()
17330 
      if ftype == TType.STOP:
17331 
        break
17332 
      if fid == 0:
17333 
        if ftype == TType.LIST:
17334 
          self.success = []
6188 rajveer 17335 
          (_etype419, _size416) = iprot.readListBegin()
17336 
          for _i420 in xrange(_size416):
17337 
            _elem421 = Order()
17338 
            _elem421.read(iprot)
17339 
            self.success.append(_elem421)
2764 chandransh 17340 
          iprot.readListEnd()
17341 
        else:
17342 
          iprot.skip(ftype)
17343 
      else:
17344 
        iprot.skip(ftype)
17345 
      iprot.readFieldEnd()
17346 
    iprot.readStructEnd()
17347 
 
17348 
  def write(self, oprot):
17349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17351 
      return
4910 phani.kuma 17352 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17353 
    if self.success is not None:
2764 chandransh 17354 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17355 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17356 
      for iter422 in self.success:
17357 
        iter422.write(oprot)
2764 chandransh 17358 
      oprot.writeListEnd()
17359 
      oprot.writeFieldEnd()
17360 
    oprot.writeFieldStop()
17361 
    oprot.writeStructEnd()
17362 
 
3431 rajveer 17363 
  def validate(self):
17364 
    return
17365 
 
17366 
 
2764 chandransh 17367 
  def __repr__(self):
17368 
    L = ['%s=%r' % (key, value)
17369 
      for key, value in self.__dict__.iteritems()]
17370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17371 
 
17372 
  def __eq__(self, other):
17373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17374 
 
17375 
  def __ne__(self, other):
17376 
    return not (self == other)
17377 
 
4741 phani.kuma 17378 
class markReturnOrdersAsPickedUp_args:
17379 
  """
17380 
  Attributes:
17381 
   - providerId
17382 
   - pickupDetails
17383 
  """
17384 
 
17385 
  thrift_spec = (
17386 
    None, # 0
17387 
    (1, TType.I64, 'providerId', None, None, ), # 1
17388 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17389 
  )
17390 
 
17391 
  def __init__(self, providerId=None, pickupDetails=None,):
17392 
    self.providerId = providerId
17393 
    self.pickupDetails = pickupDetails
17394 
 
17395 
  def read(self, iprot):
17396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17398 
      return
17399 
    iprot.readStructBegin()
17400 
    while True:
17401 
      (fname, ftype, fid) = iprot.readFieldBegin()
17402 
      if ftype == TType.STOP:
17403 
        break
17404 
      if fid == 1:
17405 
        if ftype == TType.I64:
17406 
          self.providerId = iprot.readI64();
17407 
        else:
17408 
          iprot.skip(ftype)
17409 
      elif fid == 2:
17410 
        if ftype == TType.MAP:
17411 
          self.pickupDetails = {}
6188 rajveer 17412 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17413 
          for _i427 in xrange(_size423):
17414 
            _key428 = iprot.readString();
17415 
            _val429 = iprot.readString();
17416 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17417 
          iprot.readMapEnd()
17418 
        else:
17419 
          iprot.skip(ftype)
17420 
      else:
17421 
        iprot.skip(ftype)
17422 
      iprot.readFieldEnd()
17423 
    iprot.readStructEnd()
17424 
 
17425 
  def write(self, oprot):
17426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17428 
      return
17429 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17430 
    if self.providerId is not None:
17431 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17432 
      oprot.writeI64(self.providerId)
17433 
      oprot.writeFieldEnd()
17434 
    if self.pickupDetails is not None:
17435 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17436 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17437 
      for kiter430,viter431 in self.pickupDetails.items():
17438 
        oprot.writeString(kiter430)
17439 
        oprot.writeString(viter431)
4741 phani.kuma 17440 
      oprot.writeMapEnd()
17441 
      oprot.writeFieldEnd()
17442 
    oprot.writeFieldStop()
17443 
    oprot.writeStructEnd()
17444 
 
17445 
  def validate(self):
17446 
    return
17447 
 
17448 
 
17449 
  def __repr__(self):
17450 
    L = ['%s=%r' % (key, value)
17451 
      for key, value in self.__dict__.iteritems()]
17452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17453 
 
17454 
  def __eq__(self, other):
17455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17456 
 
17457 
  def __ne__(self, other):
17458 
    return not (self == other)
17459 
 
17460 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17461 
 
17462 
  thrift_spec = (
17463 
  )
17464 
 
17465 
  def read(self, iprot):
17466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17468 
      return
17469 
    iprot.readStructBegin()
17470 
    while True:
17471 
      (fname, ftype, fid) = iprot.readFieldBegin()
17472 
      if ftype == TType.STOP:
17473 
        break
17474 
      else:
17475 
        iprot.skip(ftype)
17476 
      iprot.readFieldEnd()
17477 
    iprot.readStructEnd()
17478 
 
17479 
  def write(self, oprot):
17480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17482 
      return
17483 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17484 
    oprot.writeFieldStop()
17485 
    oprot.writeStructEnd()
17486 
 
17487 
  def validate(self):
17488 
    return
17489 
 
17490 
 
17491 
  def __repr__(self):
17492 
    L = ['%s=%r' % (key, value)
17493 
      for key, value in self.__dict__.iteritems()]
17494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17495 
 
17496 
  def __eq__(self, other):
17497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17498 
 
17499 
  def __ne__(self, other):
17500 
    return not (self == other)
17501 
 
17502 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17503 
  """
17504 
  Attributes:
4910 phani.kuma 17505 
   - providerId
17506 
  """
17507 
 
17508 
  thrift_spec = (
17509 
    None, # 0
17510 
    (1, TType.I64, 'providerId', None, None, ), # 1
17511 
  )
17512 
 
17513 
  def __init__(self, providerId=None,):
17514 
    self.providerId = providerId
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 == 1:
17526 
        if ftype == TType.I64:
17527 
          self.providerId = iprot.readI64();
17528 
        else:
17529 
          iprot.skip(ftype)
17530 
      else:
17531 
        iprot.skip(ftype)
17532 
      iprot.readFieldEnd()
17533 
    iprot.readStructEnd()
17534 
 
17535 
  def write(self, oprot):
17536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17538 
      return
17539 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17540 
    if self.providerId is not None:
17541 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17542 
      oprot.writeI64(self.providerId)
17543 
      oprot.writeFieldEnd()
17544 
    oprot.writeFieldStop()
17545 
    oprot.writeStructEnd()
17546 
 
17547 
  def validate(self):
17548 
    return
17549 
 
17550 
 
17551 
  def __repr__(self):
17552 
    L = ['%s=%r' % (key, value)
17553 
      for key, value in self.__dict__.iteritems()]
17554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17555 
 
17556 
  def __eq__(self, other):
17557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17558 
 
17559 
  def __ne__(self, other):
17560 
    return not (self == other)
17561 
 
17562 
class getReturnOrdersNotPickedUp_result:
17563 
  """
17564 
  Attributes:
4741 phani.kuma 17565 
   - success
17566 
  """
17567 
 
17568 
  thrift_spec = (
17569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17570 
  )
17571 
 
17572 
  def __init__(self, success=None,):
17573 
    self.success = success
17574 
 
17575 
  def read(self, iprot):
17576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17578 
      return
17579 
    iprot.readStructBegin()
17580 
    while True:
17581 
      (fname, ftype, fid) = iprot.readFieldBegin()
17582 
      if ftype == TType.STOP:
17583 
        break
17584 
      if fid == 0:
17585 
        if ftype == TType.LIST:
17586 
          self.success = []
6188 rajveer 17587 
          (_etype435, _size432) = iprot.readListBegin()
17588 
          for _i436 in xrange(_size432):
17589 
            _elem437 = Order()
17590 
            _elem437.read(iprot)
17591 
            self.success.append(_elem437)
4741 phani.kuma 17592 
          iprot.readListEnd()
17593 
        else:
17594 
          iprot.skip(ftype)
17595 
      else:
17596 
        iprot.skip(ftype)
17597 
      iprot.readFieldEnd()
17598 
    iprot.readStructEnd()
17599 
 
17600 
  def write(self, oprot):
17601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17603 
      return
4910 phani.kuma 17604 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17605 
    if self.success is not None:
17606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17608 
      for iter438 in self.success:
17609 
        iter438.write(oprot)
4741 phani.kuma 17610 
      oprot.writeListEnd()
17611 
      oprot.writeFieldEnd()
17612 
    oprot.writeFieldStop()
17613 
    oprot.writeStructEnd()
17614 
 
17615 
  def validate(self):
17616 
    return
17617 
 
17618 
 
17619 
  def __repr__(self):
17620 
    L = ['%s=%r' % (key, value)
17621 
      for key, value in self.__dict__.iteritems()]
17622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17623 
 
17624 
  def __eq__(self, other):
17625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17626 
 
17627 
  def __ne__(self, other):
17628 
    return not (self == other)
17629 
 
2616 chandransh 17630 
class receiveReturn_args:
2591 chandransh 17631 
  """
17632 
  Attributes:
17633 
   - orderId
4479 rajveer 17634 
   - receiveCondition
2591 chandransh 17635 
  """
2536 chandransh 17636 
 
2591 chandransh 17637 
  thrift_spec = (
17638 
    None, # 0
17639 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17640 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17641 
  )
17642 
 
4479 rajveer 17643 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17644 
    self.orderId = orderId
4479 rajveer 17645 
    self.receiveCondition = receiveCondition
2591 chandransh 17646 
 
17647 
  def read(self, iprot):
17648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17650 
      return
17651 
    iprot.readStructBegin()
17652 
    while True:
17653 
      (fname, ftype, fid) = iprot.readFieldBegin()
17654 
      if ftype == TType.STOP:
17655 
        break
17656 
      if fid == 1:
17657 
        if ftype == TType.I64:
17658 
          self.orderId = iprot.readI64();
17659 
        else:
17660 
          iprot.skip(ftype)
4479 rajveer 17661 
      elif fid == 2:
17662 
        if ftype == TType.I64:
17663 
          self.receiveCondition = iprot.readI64();
17664 
        else:
17665 
          iprot.skip(ftype)
2591 chandransh 17666 
      else:
17667 
        iprot.skip(ftype)
17668 
      iprot.readFieldEnd()
17669 
    iprot.readStructEnd()
17670 
 
17671 
  def write(self, oprot):
17672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17674 
      return
2616 chandransh 17675 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17676 
    if self.orderId is not None:
2591 chandransh 17677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17678 
      oprot.writeI64(self.orderId)
17679 
      oprot.writeFieldEnd()
4479 rajveer 17680 
    if self.receiveCondition is not None:
17681 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17682 
      oprot.writeI64(self.receiveCondition)
17683 
      oprot.writeFieldEnd()
2591 chandransh 17684 
    oprot.writeFieldStop()
17685 
    oprot.writeStructEnd()
17686 
 
3431 rajveer 17687 
  def validate(self):
17688 
    return
17689 
 
17690 
 
2591 chandransh 17691 
  def __repr__(self):
17692 
    L = ['%s=%r' % (key, value)
17693 
      for key, value in self.__dict__.iteritems()]
17694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17695 
 
17696 
  def __eq__(self, other):
17697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17698 
 
17699 
  def __ne__(self, other):
17700 
    return not (self == other)
17701 
 
2616 chandransh 17702 
class receiveReturn_result:
2591 chandransh 17703 
  """
17704 
  Attributes:
17705 
   - success
17706 
   - ex
17707 
  """
17708 
 
17709 
  thrift_spec = (
17710 
    (0, TType.BOOL, 'success', None, None, ), # 0
17711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17712 
  )
17713 
 
17714 
  def __init__(self, success=None, ex=None,):
17715 
    self.success = success
17716 
    self.ex = ex
17717 
 
17718 
  def read(self, iprot):
17719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17721 
      return
17722 
    iprot.readStructBegin()
17723 
    while True:
17724 
      (fname, ftype, fid) = iprot.readFieldBegin()
17725 
      if ftype == TType.STOP:
17726 
        break
17727 
      if fid == 0:
17728 
        if ftype == TType.BOOL:
17729 
          self.success = iprot.readBool();
17730 
        else:
17731 
          iprot.skip(ftype)
17732 
      elif fid == 1:
17733 
        if ftype == TType.STRUCT:
17734 
          self.ex = TransactionServiceException()
17735 
          self.ex.read(iprot)
17736 
        else:
17737 
          iprot.skip(ftype)
17738 
      else:
17739 
        iprot.skip(ftype)
17740 
      iprot.readFieldEnd()
17741 
    iprot.readStructEnd()
17742 
 
17743 
  def write(self, oprot):
17744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17746 
      return
2616 chandransh 17747 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17748 
    if self.success is not None:
2591 chandransh 17749 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17750 
      oprot.writeBool(self.success)
17751 
      oprot.writeFieldEnd()
3431 rajveer 17752 
    if self.ex is not None:
2591 chandransh 17753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17754 
      self.ex.write(oprot)
17755 
      oprot.writeFieldEnd()
17756 
    oprot.writeFieldStop()
17757 
    oprot.writeStructEnd()
17758 
 
3431 rajveer 17759 
  def validate(self):
17760 
    return
17761 
 
17762 
 
2591 chandransh 17763 
  def __repr__(self):
17764 
    L = ['%s=%r' % (key, value)
17765 
      for key, value in self.__dict__.iteritems()]
17766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17767 
 
17768 
  def __eq__(self, other):
17769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17770 
 
17771 
  def __ne__(self, other):
17772 
    return not (self == other)
17773 
 
17774 
class validateDoa_args:
17775 
  """
17776 
  Attributes:
17777 
   - orderId
17778 
   - isValid
17779 
  """
17780 
 
17781 
  thrift_spec = (
17782 
    None, # 0
17783 
    (1, TType.I64, 'orderId', None, None, ), # 1
17784 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17785 
  )
17786 
 
17787 
  def __init__(self, orderId=None, isValid=None,):
17788 
    self.orderId = orderId
17789 
    self.isValid = isValid
17790 
 
17791 
  def read(self, iprot):
17792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17794 
      return
17795 
    iprot.readStructBegin()
17796 
    while True:
17797 
      (fname, ftype, fid) = iprot.readFieldBegin()
17798 
      if ftype == TType.STOP:
17799 
        break
17800 
      if fid == 1:
17801 
        if ftype == TType.I64:
17802 
          self.orderId = iprot.readI64();
17803 
        else:
17804 
          iprot.skip(ftype)
17805 
      elif fid == 2:
17806 
        if ftype == TType.BOOL:
17807 
          self.isValid = iprot.readBool();
17808 
        else:
17809 
          iprot.skip(ftype)
17810 
      else:
17811 
        iprot.skip(ftype)
17812 
      iprot.readFieldEnd()
17813 
    iprot.readStructEnd()
17814 
 
17815 
  def write(self, oprot):
17816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17818 
      return
17819 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17820 
    if self.orderId is not None:
2591 chandransh 17821 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17822 
      oprot.writeI64(self.orderId)
17823 
      oprot.writeFieldEnd()
3431 rajveer 17824 
    if self.isValid is not None:
2591 chandransh 17825 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17826 
      oprot.writeBool(self.isValid)
17827 
      oprot.writeFieldEnd()
17828 
    oprot.writeFieldStop()
17829 
    oprot.writeStructEnd()
17830 
 
3431 rajveer 17831 
  def validate(self):
17832 
    return
17833 
 
17834 
 
2591 chandransh 17835 
  def __repr__(self):
17836 
    L = ['%s=%r' % (key, value)
17837 
      for key, value in self.__dict__.iteritems()]
17838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17839 
 
17840 
  def __eq__(self, other):
17841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17842 
 
17843 
  def __ne__(self, other):
17844 
    return not (self == other)
17845 
 
17846 
class validateDoa_result:
17847 
  """
17848 
  Attributes:
17849 
   - success
17850 
   - ex
17851 
  """
17852 
 
17853 
  thrift_spec = (
17854 
    (0, TType.BOOL, 'success', None, None, ), # 0
17855 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17856 
  )
17857 
 
17858 
  def __init__(self, success=None, ex=None,):
17859 
    self.success = success
17860 
    self.ex = ex
17861 
 
17862 
  def read(self, iprot):
17863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17865 
      return
17866 
    iprot.readStructBegin()
17867 
    while True:
17868 
      (fname, ftype, fid) = iprot.readFieldBegin()
17869 
      if ftype == TType.STOP:
17870 
        break
17871 
      if fid == 0:
17872 
        if ftype == TType.BOOL:
17873 
          self.success = iprot.readBool();
17874 
        else:
17875 
          iprot.skip(ftype)
17876 
      elif fid == 1:
17877 
        if ftype == TType.STRUCT:
17878 
          self.ex = TransactionServiceException()
17879 
          self.ex.read(iprot)
17880 
        else:
17881 
          iprot.skip(ftype)
17882 
      else:
17883 
        iprot.skip(ftype)
17884 
      iprot.readFieldEnd()
17885 
    iprot.readStructEnd()
17886 
 
17887 
  def write(self, oprot):
17888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17890 
      return
17891 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17892 
    if self.success is not None:
2591 chandransh 17893 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17894 
      oprot.writeBool(self.success)
17895 
      oprot.writeFieldEnd()
3431 rajveer 17896 
    if self.ex is not None:
2591 chandransh 17897 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17898 
      self.ex.write(oprot)
17899 
      oprot.writeFieldEnd()
17900 
    oprot.writeFieldStop()
17901 
    oprot.writeStructEnd()
17902 
 
3431 rajveer 17903 
  def validate(self):
17904 
    return
17905 
 
17906 
 
2591 chandransh 17907 
  def __repr__(self):
17908 
    L = ['%s=%r' % (key, value)
17909 
      for key, value in self.__dict__.iteritems()]
17910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17911 
 
17912 
  def __eq__(self, other):
17913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17914 
 
17915 
  def __ne__(self, other):
17916 
    return not (self == other)
17917 
 
4495 rajveer 17918 
class validateReturnProduct_args:
17919 
  """
17920 
  Attributes:
17921 
   - orderId
17922 
   - isUsable
17923 
  """
17924 
 
17925 
  thrift_spec = (
17926 
    None, # 0
17927 
    (1, TType.I64, 'orderId', None, None, ), # 1
17928 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17929 
  )
17930 
 
17931 
  def __init__(self, orderId=None, isUsable=None,):
17932 
    self.orderId = orderId
17933 
    self.isUsable = isUsable
17934 
 
17935 
  def read(self, iprot):
17936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17938 
      return
17939 
    iprot.readStructBegin()
17940 
    while True:
17941 
      (fname, ftype, fid) = iprot.readFieldBegin()
17942 
      if ftype == TType.STOP:
17943 
        break
17944 
      if fid == 1:
17945 
        if ftype == TType.I64:
17946 
          self.orderId = iprot.readI64();
17947 
        else:
17948 
          iprot.skip(ftype)
17949 
      elif fid == 2:
17950 
        if ftype == TType.BOOL:
17951 
          self.isUsable = iprot.readBool();
17952 
        else:
17953 
          iprot.skip(ftype)
17954 
      else:
17955 
        iprot.skip(ftype)
17956 
      iprot.readFieldEnd()
17957 
    iprot.readStructEnd()
17958 
 
17959 
  def write(self, oprot):
17960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17962 
      return
17963 
    oprot.writeStructBegin('validateReturnProduct_args')
17964 
    if self.orderId is not None:
17965 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17966 
      oprot.writeI64(self.orderId)
17967 
      oprot.writeFieldEnd()
17968 
    if self.isUsable is not None:
17969 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17970 
      oprot.writeBool(self.isUsable)
17971 
      oprot.writeFieldEnd()
17972 
    oprot.writeFieldStop()
17973 
    oprot.writeStructEnd()
17974 
 
17975 
  def validate(self):
17976 
    return
17977 
 
17978 
 
17979 
  def __repr__(self):
17980 
    L = ['%s=%r' % (key, value)
17981 
      for key, value in self.__dict__.iteritems()]
17982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17983 
 
17984 
  def __eq__(self, other):
17985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17986 
 
17987 
  def __ne__(self, other):
17988 
    return not (self == other)
17989 
 
17990 
class validateReturnProduct_result:
17991 
  """
17992 
  Attributes:
17993 
   - success
17994 
   - ex
17995 
  """
17996 
 
17997 
  thrift_spec = (
17998 
    (0, TType.BOOL, 'success', None, None, ), # 0
17999 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18000 
  )
18001 
 
18002 
  def __init__(self, success=None, ex=None,):
18003 
    self.success = success
18004 
    self.ex = ex
18005 
 
18006 
  def read(self, iprot):
18007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18009 
      return
18010 
    iprot.readStructBegin()
18011 
    while True:
18012 
      (fname, ftype, fid) = iprot.readFieldBegin()
18013 
      if ftype == TType.STOP:
18014 
        break
18015 
      if fid == 0:
18016 
        if ftype == TType.BOOL:
18017 
          self.success = iprot.readBool();
18018 
        else:
18019 
          iprot.skip(ftype)
18020 
      elif fid == 1:
18021 
        if ftype == TType.STRUCT:
18022 
          self.ex = TransactionServiceException()
18023 
          self.ex.read(iprot)
18024 
        else:
18025 
          iprot.skip(ftype)
18026 
      else:
18027 
        iprot.skip(ftype)
18028 
      iprot.readFieldEnd()
18029 
    iprot.readStructEnd()
18030 
 
18031 
  def write(self, oprot):
18032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18034 
      return
18035 
    oprot.writeStructBegin('validateReturnProduct_result')
18036 
    if self.success is not None:
18037 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18038 
      oprot.writeBool(self.success)
18039 
      oprot.writeFieldEnd()
18040 
    if self.ex is not None:
18041 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18042 
      self.ex.write(oprot)
18043 
      oprot.writeFieldEnd()
18044 
    oprot.writeFieldStop()
18045 
    oprot.writeStructEnd()
18046 
 
18047 
  def validate(self):
18048 
    return
18049 
 
18050 
 
18051 
  def __repr__(self):
18052 
    L = ['%s=%r' % (key, value)
18053 
      for key, value in self.__dict__.iteritems()]
18054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18055 
 
18056 
  def __eq__(self, other):
18057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18058 
 
18059 
  def __ne__(self, other):
18060 
    return not (self == other)
18061 
 
2616 chandransh 18062 
class reshipOrder_args:
18063 
  """
18064 
  Attributes:
18065 
   - orderId
18066 
  """
2591 chandransh 18067 
 
2616 chandransh 18068 
  thrift_spec = (
18069 
    None, # 0
18070 
    (1, TType.I64, 'orderId', None, None, ), # 1
18071 
  )
18072 
 
18073 
  def __init__(self, orderId=None,):
18074 
    self.orderId = orderId
18075 
 
18076 
  def read(self, iprot):
18077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18079 
      return
18080 
    iprot.readStructBegin()
18081 
    while True:
18082 
      (fname, ftype, fid) = iprot.readFieldBegin()
18083 
      if ftype == TType.STOP:
18084 
        break
18085 
      if fid == 1:
18086 
        if ftype == TType.I64:
18087 
          self.orderId = iprot.readI64();
18088 
        else:
18089 
          iprot.skip(ftype)
18090 
      else:
18091 
        iprot.skip(ftype)
18092 
      iprot.readFieldEnd()
18093 
    iprot.readStructEnd()
18094 
 
18095 
  def write(self, oprot):
18096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18098 
      return
18099 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18100 
    if self.orderId is not None:
2616 chandransh 18101 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18102 
      oprot.writeI64(self.orderId)
18103 
      oprot.writeFieldEnd()
18104 
    oprot.writeFieldStop()
18105 
    oprot.writeStructEnd()
18106 
 
3431 rajveer 18107 
  def validate(self):
18108 
    return
18109 
 
18110 
 
2616 chandransh 18111 
  def __repr__(self):
18112 
    L = ['%s=%r' % (key, value)
18113 
      for key, value in self.__dict__.iteritems()]
18114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18115 
 
18116 
  def __eq__(self, other):
18117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18118 
 
18119 
  def __ne__(self, other):
18120 
    return not (self == other)
18121 
 
18122 
class reshipOrder_result:
18123 
  """
18124 
  Attributes:
18125 
   - success
18126 
   - ex
18127 
  """
18128 
 
18129 
  thrift_spec = (
18130 
    (0, TType.I64, 'success', None, None, ), # 0
18131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18132 
  )
18133 
 
18134 
  def __init__(self, success=None, ex=None,):
18135 
    self.success = success
18136 
    self.ex = ex
18137 
 
18138 
  def read(self, iprot):
18139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18141 
      return
18142 
    iprot.readStructBegin()
18143 
    while True:
18144 
      (fname, ftype, fid) = iprot.readFieldBegin()
18145 
      if ftype == TType.STOP:
18146 
        break
18147 
      if fid == 0:
18148 
        if ftype == TType.I64:
18149 
          self.success = iprot.readI64();
18150 
        else:
18151 
          iprot.skip(ftype)
18152 
      elif fid == 1:
18153 
        if ftype == TType.STRUCT:
18154 
          self.ex = TransactionServiceException()
18155 
          self.ex.read(iprot)
18156 
        else:
18157 
          iprot.skip(ftype)
18158 
      else:
18159 
        iprot.skip(ftype)
18160 
      iprot.readFieldEnd()
18161 
    iprot.readStructEnd()
18162 
 
18163 
  def write(self, oprot):
18164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18166 
      return
18167 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18168 
    if self.success is not None:
2616 chandransh 18169 
      oprot.writeFieldBegin('success', TType.I64, 0)
18170 
      oprot.writeI64(self.success)
18171 
      oprot.writeFieldEnd()
3431 rajveer 18172 
    if self.ex is not None:
2616 chandransh 18173 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18174 
      self.ex.write(oprot)
18175 
      oprot.writeFieldEnd()
18176 
    oprot.writeFieldStop()
18177 
    oprot.writeStructEnd()
18178 
 
3431 rajveer 18179 
  def validate(self):
18180 
    return
18181 
 
18182 
 
2616 chandransh 18183 
  def __repr__(self):
18184 
    L = ['%s=%r' % (key, value)
18185 
      for key, value in self.__dict__.iteritems()]
18186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18187 
 
18188 
  def __eq__(self, other):
18189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18190 
 
18191 
  def __ne__(self, other):
18192 
    return not (self == other)
18193 
 
18194 
class refundOrder_args:
18195 
  """
18196 
  Attributes:
18197 
   - orderId
3226 chandransh 18198 
   - refundedBy
18199 
   - reason
2616 chandransh 18200 
  """
18201 
 
18202 
  thrift_spec = (
18203 
    None, # 0
18204 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18205 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18206 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18207 
  )
18208 
 
3226 chandransh 18209 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18210 
    self.orderId = orderId
3226 chandransh 18211 
    self.refundedBy = refundedBy
18212 
    self.reason = reason
2616 chandransh 18213 
 
18214 
  def read(self, iprot):
18215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18217 
      return
18218 
    iprot.readStructBegin()
18219 
    while True:
18220 
      (fname, ftype, fid) = iprot.readFieldBegin()
18221 
      if ftype == TType.STOP:
18222 
        break
18223 
      if fid == 1:
18224 
        if ftype == TType.I64:
18225 
          self.orderId = iprot.readI64();
18226 
        else:
18227 
          iprot.skip(ftype)
3226 chandransh 18228 
      elif fid == 2:
18229 
        if ftype == TType.STRING:
18230 
          self.refundedBy = iprot.readString();
18231 
        else:
18232 
          iprot.skip(ftype)
18233 
      elif fid == 3:
18234 
        if ftype == TType.STRING:
18235 
          self.reason = iprot.readString();
18236 
        else:
18237 
          iprot.skip(ftype)
2616 chandransh 18238 
      else:
18239 
        iprot.skip(ftype)
18240 
      iprot.readFieldEnd()
18241 
    iprot.readStructEnd()
18242 
 
18243 
  def write(self, oprot):
18244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18246 
      return
18247 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18248 
    if self.orderId is not None:
2616 chandransh 18249 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18250 
      oprot.writeI64(self.orderId)
18251 
      oprot.writeFieldEnd()
3431 rajveer 18252 
    if self.refundedBy is not None:
3226 chandransh 18253 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18254 
      oprot.writeString(self.refundedBy)
18255 
      oprot.writeFieldEnd()
3431 rajveer 18256 
    if self.reason is not None:
3226 chandransh 18257 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18258 
      oprot.writeString(self.reason)
18259 
      oprot.writeFieldEnd()
2616 chandransh 18260 
    oprot.writeFieldStop()
18261 
    oprot.writeStructEnd()
18262 
 
3431 rajveer 18263 
  def validate(self):
18264 
    return
18265 
 
18266 
 
2616 chandransh 18267 
  def __repr__(self):
18268 
    L = ['%s=%r' % (key, value)
18269 
      for key, value in self.__dict__.iteritems()]
18270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18271 
 
18272 
  def __eq__(self, other):
18273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18274 
 
18275 
  def __ne__(self, other):
18276 
    return not (self == other)
18277 
 
18278 
class refundOrder_result:
18279 
  """
18280 
  Attributes:
18281 
   - success
18282 
   - ex
18283 
  """
18284 
 
18285 
  thrift_spec = (
18286 
    (0, TType.BOOL, 'success', None, None, ), # 0
18287 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18288 
  )
18289 
 
18290 
  def __init__(self, success=None, ex=None,):
18291 
    self.success = success
18292 
    self.ex = ex
18293 
 
18294 
  def read(self, iprot):
18295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18297 
      return
18298 
    iprot.readStructBegin()
18299 
    while True:
18300 
      (fname, ftype, fid) = iprot.readFieldBegin()
18301 
      if ftype == TType.STOP:
18302 
        break
18303 
      if fid == 0:
18304 
        if ftype == TType.BOOL:
18305 
          self.success = iprot.readBool();
18306 
        else:
18307 
          iprot.skip(ftype)
18308 
      elif fid == 1:
18309 
        if ftype == TType.STRUCT:
18310 
          self.ex = TransactionServiceException()
18311 
          self.ex.read(iprot)
18312 
        else:
18313 
          iprot.skip(ftype)
18314 
      else:
18315 
        iprot.skip(ftype)
18316 
      iprot.readFieldEnd()
18317 
    iprot.readStructEnd()
18318 
 
18319 
  def write(self, oprot):
18320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18322 
      return
18323 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18324 
    if self.success is not None:
2616 chandransh 18325 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18326 
      oprot.writeBool(self.success)
18327 
      oprot.writeFieldEnd()
3431 rajveer 18328 
    if self.ex is not None:
2616 chandransh 18329 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18330 
      self.ex.write(oprot)
18331 
      oprot.writeFieldEnd()
18332 
    oprot.writeFieldStop()
18333 
    oprot.writeStructEnd()
18334 
 
3431 rajveer 18335 
  def validate(self):
18336 
    return
18337 
 
18338 
 
2616 chandransh 18339 
  def __repr__(self):
18340 
    L = ['%s=%r' % (key, value)
18341 
      for key, value in self.__dict__.iteritems()]
18342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18343 
 
18344 
  def __eq__(self, other):
18345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18346 
 
18347 
  def __ne__(self, other):
18348 
    return not (self == other)
18349 
 
2690 chandransh 18350 
class getReturnOrders_args:
18351 
  """
18352 
  Attributes:
18353 
   - warehouseId
18354 
   - fromDate
18355 
   - toDate
18356 
  """
2616 chandransh 18357 
 
2690 chandransh 18358 
  thrift_spec = (
18359 
    None, # 0
18360 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18361 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18362 
    (3, TType.I64, 'toDate', None, None, ), # 3
18363 
  )
18364 
 
18365 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18366 
    self.warehouseId = warehouseId
18367 
    self.fromDate = fromDate
18368 
    self.toDate = toDate
18369 
 
18370 
  def read(self, iprot):
18371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18373 
      return
18374 
    iprot.readStructBegin()
18375 
    while True:
18376 
      (fname, ftype, fid) = iprot.readFieldBegin()
18377 
      if ftype == TType.STOP:
18378 
        break
18379 
      if fid == 1:
18380 
        if ftype == TType.I64:
18381 
          self.warehouseId = iprot.readI64();
18382 
        else:
18383 
          iprot.skip(ftype)
18384 
      elif fid == 2:
18385 
        if ftype == TType.I64:
18386 
          self.fromDate = iprot.readI64();
18387 
        else:
18388 
          iprot.skip(ftype)
18389 
      elif fid == 3:
18390 
        if ftype == TType.I64:
18391 
          self.toDate = iprot.readI64();
18392 
        else:
18393 
          iprot.skip(ftype)
18394 
      else:
18395 
        iprot.skip(ftype)
18396 
      iprot.readFieldEnd()
18397 
    iprot.readStructEnd()
18398 
 
18399 
  def write(self, oprot):
18400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18402 
      return
18403 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18404 
    if self.warehouseId is not None:
2690 chandransh 18405 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18406 
      oprot.writeI64(self.warehouseId)
18407 
      oprot.writeFieldEnd()
3431 rajveer 18408 
    if self.fromDate is not None:
2690 chandransh 18409 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18410 
      oprot.writeI64(self.fromDate)
18411 
      oprot.writeFieldEnd()
3431 rajveer 18412 
    if self.toDate is not None:
2690 chandransh 18413 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18414 
      oprot.writeI64(self.toDate)
18415 
      oprot.writeFieldEnd()
18416 
    oprot.writeFieldStop()
18417 
    oprot.writeStructEnd()
18418 
 
3431 rajveer 18419 
  def validate(self):
18420 
    return
18421 
 
18422 
 
2690 chandransh 18423 
  def __repr__(self):
18424 
    L = ['%s=%r' % (key, value)
18425 
      for key, value in self.__dict__.iteritems()]
18426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18427 
 
18428 
  def __eq__(self, other):
18429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18430 
 
18431 
  def __ne__(self, other):
18432 
    return not (self == other)
18433 
 
18434 
class getReturnOrders_result:
18435 
  """
18436 
  Attributes:
18437 
   - success
18438 
  """
18439 
 
18440 
  thrift_spec = (
18441 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18442 
  )
18443 
 
18444 
  def __init__(self, success=None,):
18445 
    self.success = success
18446 
 
18447 
  def read(self, iprot):
18448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18450 
      return
18451 
    iprot.readStructBegin()
18452 
    while True:
18453 
      (fname, ftype, fid) = iprot.readFieldBegin()
18454 
      if ftype == TType.STOP:
18455 
        break
18456 
      if fid == 0:
18457 
        if ftype == TType.LIST:
18458 
          self.success = []
6188 rajveer 18459 
          (_etype442, _size439) = iprot.readListBegin()
18460 
          for _i443 in xrange(_size439):
18461 
            _elem444 = ReturnOrder()
18462 
            _elem444.read(iprot)
18463 
            self.success.append(_elem444)
2690 chandransh 18464 
          iprot.readListEnd()
18465 
        else:
18466 
          iprot.skip(ftype)
18467 
      else:
18468 
        iprot.skip(ftype)
18469 
      iprot.readFieldEnd()
18470 
    iprot.readStructEnd()
18471 
 
18472 
  def write(self, oprot):
18473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18475 
      return
18476 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18477 
    if self.success is not None:
2690 chandransh 18478 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18479 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18480 
      for iter445 in self.success:
18481 
        iter445.write(oprot)
2690 chandransh 18482 
      oprot.writeListEnd()
18483 
      oprot.writeFieldEnd()
18484 
    oprot.writeFieldStop()
18485 
    oprot.writeStructEnd()
18486 
 
3431 rajveer 18487 
  def validate(self):
18488 
    return
18489 
 
18490 
 
2690 chandransh 18491 
  def __repr__(self):
18492 
    L = ['%s=%r' % (key, value)
18493 
      for key, value in self.__dict__.iteritems()]
18494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18495 
 
18496 
  def __eq__(self, other):
18497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18498 
 
18499 
  def __ne__(self, other):
18500 
    return not (self == other)
18501 
 
5481 phani.kuma 18502 
class getAllReturnOrders_args:
18503 
  """
18504 
  Attributes:
18505 
   - onlyNotProcessed
18506 
   - fromDate
18507 
   - toDate
18508 
  """
18509 
 
18510 
  thrift_spec = (
18511 
    None, # 0
18512 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18513 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18514 
    (3, TType.I64, 'toDate', None, None, ), # 3
18515 
  )
18516 
 
18517 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18518 
    self.onlyNotProcessed = onlyNotProcessed
18519 
    self.fromDate = fromDate
18520 
    self.toDate = toDate
18521 
 
18522 
  def read(self, iprot):
18523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18525 
      return
18526 
    iprot.readStructBegin()
18527 
    while True:
18528 
      (fname, ftype, fid) = iprot.readFieldBegin()
18529 
      if ftype == TType.STOP:
18530 
        break
18531 
      if fid == 1:
18532 
        if ftype == TType.BOOL:
18533 
          self.onlyNotProcessed = iprot.readBool();
18534 
        else:
18535 
          iprot.skip(ftype)
18536 
      elif fid == 2:
18537 
        if ftype == TType.I64:
18538 
          self.fromDate = iprot.readI64();
18539 
        else:
18540 
          iprot.skip(ftype)
18541 
      elif fid == 3:
18542 
        if ftype == TType.I64:
18543 
          self.toDate = iprot.readI64();
18544 
        else:
18545 
          iprot.skip(ftype)
18546 
      else:
18547 
        iprot.skip(ftype)
18548 
      iprot.readFieldEnd()
18549 
    iprot.readStructEnd()
18550 
 
18551 
  def write(self, oprot):
18552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18554 
      return
18555 
    oprot.writeStructBegin('getAllReturnOrders_args')
18556 
    if self.onlyNotProcessed is not None:
18557 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18558 
      oprot.writeBool(self.onlyNotProcessed)
18559 
      oprot.writeFieldEnd()
18560 
    if self.fromDate is not None:
18561 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18562 
      oprot.writeI64(self.fromDate)
18563 
      oprot.writeFieldEnd()
18564 
    if self.toDate is not None:
18565 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18566 
      oprot.writeI64(self.toDate)
18567 
      oprot.writeFieldEnd()
18568 
    oprot.writeFieldStop()
18569 
    oprot.writeStructEnd()
18570 
 
18571 
  def validate(self):
18572 
    return
18573 
 
18574 
 
18575 
  def __repr__(self):
18576 
    L = ['%s=%r' % (key, value)
18577 
      for key, value in self.__dict__.iteritems()]
18578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18579 
 
18580 
  def __eq__(self, other):
18581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18582 
 
18583 
  def __ne__(self, other):
18584 
    return not (self == other)
18585 
 
18586 
class getAllReturnOrders_result:
18587 
  """
18588 
  Attributes:
18589 
   - success
18590 
  """
18591 
 
18592 
  thrift_spec = (
18593 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18594 
  )
18595 
 
18596 
  def __init__(self, success=None,):
18597 
    self.success = success
18598 
 
18599 
  def read(self, iprot):
18600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18602 
      return
18603 
    iprot.readStructBegin()
18604 
    while True:
18605 
      (fname, ftype, fid) = iprot.readFieldBegin()
18606 
      if ftype == TType.STOP:
18607 
        break
18608 
      if fid == 0:
18609 
        if ftype == TType.LIST:
18610 
          self.success = []
6188 rajveer 18611 
          (_etype449, _size446) = iprot.readListBegin()
18612 
          for _i450 in xrange(_size446):
18613 
            _elem451 = ReturnOrder()
18614 
            _elem451.read(iprot)
18615 
            self.success.append(_elem451)
5481 phani.kuma 18616 
          iprot.readListEnd()
18617 
        else:
18618 
          iprot.skip(ftype)
18619 
      else:
18620 
        iprot.skip(ftype)
18621 
      iprot.readFieldEnd()
18622 
    iprot.readStructEnd()
18623 
 
18624 
  def write(self, oprot):
18625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18627 
      return
18628 
    oprot.writeStructBegin('getAllReturnOrders_result')
18629 
    if self.success is not None:
18630 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18631 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18632 
      for iter452 in self.success:
18633 
        iter452.write(oprot)
5481 phani.kuma 18634 
      oprot.writeListEnd()
18635 
      oprot.writeFieldEnd()
18636 
    oprot.writeFieldStop()
18637 
    oprot.writeStructEnd()
18638 
 
18639 
  def validate(self):
18640 
    return
18641 
 
18642 
 
18643 
  def __repr__(self):
18644 
    L = ['%s=%r' % (key, value)
18645 
      for key, value in self.__dict__.iteritems()]
18646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18647 
 
18648 
  def __eq__(self, other):
18649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18650 
 
18651 
  def __ne__(self, other):
18652 
    return not (self == other)
18653 
 
2700 chandransh 18654 
class getReturnOrder_args:
18655 
  """
18656 
  Attributes:
18657 
   - id
18658 
  """
18659 
 
18660 
  thrift_spec = (
18661 
    None, # 0
18662 
    (1, TType.I64, 'id', None, None, ), # 1
18663 
  )
18664 
 
18665 
  def __init__(self, id=None,):
18666 
    self.id = id
18667 
 
18668 
  def read(self, iprot):
18669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18671 
      return
18672 
    iprot.readStructBegin()
18673 
    while True:
18674 
      (fname, ftype, fid) = iprot.readFieldBegin()
18675 
      if ftype == TType.STOP:
18676 
        break
18677 
      if fid == 1:
18678 
        if ftype == TType.I64:
18679 
          self.id = iprot.readI64();
18680 
        else:
18681 
          iprot.skip(ftype)
18682 
      else:
18683 
        iprot.skip(ftype)
18684 
      iprot.readFieldEnd()
18685 
    iprot.readStructEnd()
18686 
 
18687 
  def write(self, oprot):
18688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18690 
      return
18691 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18692 
    if self.id is not None:
2700 chandransh 18693 
      oprot.writeFieldBegin('id', TType.I64, 1)
18694 
      oprot.writeI64(self.id)
18695 
      oprot.writeFieldEnd()
18696 
    oprot.writeFieldStop()
18697 
    oprot.writeStructEnd()
18698 
 
3431 rajveer 18699 
  def validate(self):
18700 
    return
18701 
 
18702 
 
2700 chandransh 18703 
  def __repr__(self):
18704 
    L = ['%s=%r' % (key, value)
18705 
      for key, value in self.__dict__.iteritems()]
18706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18707 
 
18708 
  def __eq__(self, other):
18709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18710 
 
18711 
  def __ne__(self, other):
18712 
    return not (self == other)
18713 
 
18714 
class getReturnOrder_result:
18715 
  """
18716 
  Attributes:
18717 
   - success
18718 
   - ex
18719 
  """
18720 
 
18721 
  thrift_spec = (
18722 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18724 
  )
18725 
 
18726 
  def __init__(self, success=None, ex=None,):
18727 
    self.success = success
18728 
    self.ex = ex
18729 
 
18730 
  def read(self, iprot):
18731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18733 
      return
18734 
    iprot.readStructBegin()
18735 
    while True:
18736 
      (fname, ftype, fid) = iprot.readFieldBegin()
18737 
      if ftype == TType.STOP:
18738 
        break
18739 
      if fid == 0:
18740 
        if ftype == TType.STRUCT:
18741 
          self.success = ReturnOrder()
18742 
          self.success.read(iprot)
18743 
        else:
18744 
          iprot.skip(ftype)
18745 
      elif fid == 1:
18746 
        if ftype == TType.STRUCT:
18747 
          self.ex = TransactionServiceException()
18748 
          self.ex.read(iprot)
18749 
        else:
18750 
          iprot.skip(ftype)
18751 
      else:
18752 
        iprot.skip(ftype)
18753 
      iprot.readFieldEnd()
18754 
    iprot.readStructEnd()
18755 
 
18756 
  def write(self, oprot):
18757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18759 
      return
18760 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18761 
    if self.success is not None:
2700 chandransh 18762 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18763 
      self.success.write(oprot)
18764 
      oprot.writeFieldEnd()
3431 rajveer 18765 
    if self.ex is not None:
2700 chandransh 18766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18767 
      self.ex.write(oprot)
18768 
      oprot.writeFieldEnd()
18769 
    oprot.writeFieldStop()
18770 
    oprot.writeStructEnd()
18771 
 
3431 rajveer 18772 
  def validate(self):
18773 
    return
18774 
 
18775 
 
2700 chandransh 18776 
  def __repr__(self):
18777 
    L = ['%s=%r' % (key, value)
18778 
      for key, value in self.__dict__.iteritems()]
18779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18780 
 
18781 
  def __eq__(self, other):
18782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18783 
 
18784 
  def __ne__(self, other):
18785 
    return not (self == other)
18786 
 
2690 chandransh 18787 
class processReturn_args:
18788 
  """
18789 
  Attributes:
18790 
   - returnOrderId
18791 
  """
18792 
 
18793 
  thrift_spec = (
18794 
    None, # 0
18795 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18796 
  )
18797 
 
18798 
  def __init__(self, returnOrderId=None,):
18799 
    self.returnOrderId = returnOrderId
18800 
 
18801 
  def read(self, iprot):
18802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18804 
      return
18805 
    iprot.readStructBegin()
18806 
    while True:
18807 
      (fname, ftype, fid) = iprot.readFieldBegin()
18808 
      if ftype == TType.STOP:
18809 
        break
18810 
      if fid == 1:
18811 
        if ftype == TType.I64:
18812 
          self.returnOrderId = iprot.readI64();
18813 
        else:
18814 
          iprot.skip(ftype)
18815 
      else:
18816 
        iprot.skip(ftype)
18817 
      iprot.readFieldEnd()
18818 
    iprot.readStructEnd()
18819 
 
18820 
  def write(self, oprot):
18821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18823 
      return
18824 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18825 
    if self.returnOrderId is not None:
2690 chandransh 18826 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18827 
      oprot.writeI64(self.returnOrderId)
18828 
      oprot.writeFieldEnd()
18829 
    oprot.writeFieldStop()
18830 
    oprot.writeStructEnd()
18831 
 
3431 rajveer 18832 
  def validate(self):
18833 
    return
18834 
 
18835 
 
2690 chandransh 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 
 
18847 
class processReturn_result:
18848 
  """
18849 
  Attributes:
18850 
   - ex
18851 
  """
18852 
 
18853 
  thrift_spec = (
18854 
    None, # 0
18855 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18856 
  )
18857 
 
18858 
  def __init__(self, ex=None,):
18859 
    self.ex = ex
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.STRUCT:
18872 
          self.ex = TransactionServiceException()
18873 
          self.ex.read(iprot)
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      else:
18877 
        iprot.skip(ftype)
18878 
      iprot.readFieldEnd()
18879 
    iprot.readStructEnd()
18880 
 
18881 
  def write(self, oprot):
18882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18884 
      return
18885 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18886 
    if self.ex is not None:
2690 chandransh 18887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18888 
      self.ex.write(oprot)
18889 
      oprot.writeFieldEnd()
18890 
    oprot.writeFieldStop()
18891 
    oprot.writeStructEnd()
18892 
 
3431 rajveer 18893 
  def validate(self):
18894 
    return
18895 
 
18896 
 
2690 chandransh 18897 
  def __repr__(self):
18898 
    L = ['%s=%r' % (key, value)
18899 
      for key, value in self.__dict__.iteritems()]
18900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18901 
 
18902 
  def __eq__(self, other):
18903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18904 
 
18905 
  def __ne__(self, other):
18906 
    return not (self == other)
18907 
 
3451 chandransh 18908 
class updateWeight_args:
18909 
  """
18910 
  Attributes:
18911 
   - orderId
18912 
   - weight
18913 
  """
18914 
 
18915 
  thrift_spec = (
18916 
    None, # 0
18917 
    (1, TType.I64, 'orderId', None, None, ), # 1
18918 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18919 
  )
18920 
 
18921 
  def __init__(self, orderId=None, weight=None,):
18922 
    self.orderId = orderId
18923 
    self.weight = weight
18924 
 
18925 
  def read(self, iprot):
18926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18928 
      return
18929 
    iprot.readStructBegin()
18930 
    while True:
18931 
      (fname, ftype, fid) = iprot.readFieldBegin()
18932 
      if ftype == TType.STOP:
18933 
        break
18934 
      if fid == 1:
18935 
        if ftype == TType.I64:
18936 
          self.orderId = iprot.readI64();
18937 
        else:
18938 
          iprot.skip(ftype)
18939 
      elif fid == 2:
18940 
        if ftype == TType.DOUBLE:
18941 
          self.weight = iprot.readDouble();
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('updateWeight_args')
18954 
    if self.orderId is not None:
18955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18956 
      oprot.writeI64(self.orderId)
18957 
      oprot.writeFieldEnd()
18958 
    if self.weight is not None:
18959 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18960 
      oprot.writeDouble(self.weight)
18961 
      oprot.writeFieldEnd()
18962 
    oprot.writeFieldStop()
18963 
    oprot.writeStructEnd()
18964 
 
18965 
  def validate(self):
18966 
    return
18967 
 
18968 
 
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 
 
18980 
class updateWeight_result:
18981 
  """
18982 
  Attributes:
18983 
   - success
18984 
   - ex
18985 
  """
18986 
 
18987 
  thrift_spec = (
18988 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18990 
  )
18991 
 
18992 
  def __init__(self, success=None, ex=None,):
18993 
    self.success = success
18994 
    self.ex = ex
18995 
 
18996 
  def read(self, iprot):
18997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18999 
      return
19000 
    iprot.readStructBegin()
19001 
    while True:
19002 
      (fname, ftype, fid) = iprot.readFieldBegin()
19003 
      if ftype == TType.STOP:
19004 
        break
19005 
      if fid == 0:
19006 
        if ftype == TType.STRUCT:
19007 
          self.success = Order()
19008 
          self.success.read(iprot)
19009 
        else:
19010 
          iprot.skip(ftype)
19011 
      elif fid == 1:
19012 
        if ftype == TType.STRUCT:
19013 
          self.ex = TransactionServiceException()
19014 
          self.ex.read(iprot)
19015 
        else:
19016 
          iprot.skip(ftype)
19017 
      else:
19018 
        iprot.skip(ftype)
19019 
      iprot.readFieldEnd()
19020 
    iprot.readStructEnd()
19021 
 
19022 
  def write(self, oprot):
19023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19025 
      return
19026 
    oprot.writeStructBegin('updateWeight_result')
19027 
    if self.success is not None:
19028 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19029 
      self.success.write(oprot)
19030 
      oprot.writeFieldEnd()
19031 
    if self.ex is not None:
19032 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19033 
      self.ex.write(oprot)
19034 
      oprot.writeFieldEnd()
19035 
    oprot.writeFieldStop()
19036 
    oprot.writeStructEnd()
19037 
 
19038 
  def validate(self):
19039 
    return
19040 
 
19041 
 
19042 
  def __repr__(self):
19043 
    L = ['%s=%r' % (key, value)
19044 
      for key, value in self.__dict__.iteritems()]
19045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19046 
 
19047 
  def __eq__(self, other):
19048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19049 
 
19050 
  def __ne__(self, other):
19051 
    return not (self == other)
3469 chandransh 19052 
 
19053 
class changeItem_args:
19054 
  """
19055 
  Attributes:
19056 
   - orderId
19057 
   - itemId
19058 
  """
19059 
 
19060 
  thrift_spec = (
19061 
    None, # 0
19062 
    (1, TType.I64, 'orderId', None, None, ), # 1
19063 
    (2, TType.I64, 'itemId', None, None, ), # 2
19064 
  )
19065 
 
19066 
  def __init__(self, orderId=None, itemId=None,):
19067 
    self.orderId = orderId
19068 
    self.itemId = itemId
19069 
 
19070 
  def read(self, iprot):
19071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19073 
      return
19074 
    iprot.readStructBegin()
19075 
    while True:
19076 
      (fname, ftype, fid) = iprot.readFieldBegin()
19077 
      if ftype == TType.STOP:
19078 
        break
19079 
      if fid == 1:
19080 
        if ftype == TType.I64:
19081 
          self.orderId = iprot.readI64();
19082 
        else:
19083 
          iprot.skip(ftype)
19084 
      elif fid == 2:
19085 
        if ftype == TType.I64:
19086 
          self.itemId = iprot.readI64();
19087 
        else:
19088 
          iprot.skip(ftype)
19089 
      else:
19090 
        iprot.skip(ftype)
19091 
      iprot.readFieldEnd()
19092 
    iprot.readStructEnd()
19093 
 
19094 
  def write(self, oprot):
19095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19097 
      return
19098 
    oprot.writeStructBegin('changeItem_args')
19099 
    if self.orderId is not None:
19100 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19101 
      oprot.writeI64(self.orderId)
19102 
      oprot.writeFieldEnd()
19103 
    if self.itemId is not None:
19104 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19105 
      oprot.writeI64(self.itemId)
19106 
      oprot.writeFieldEnd()
19107 
    oprot.writeFieldStop()
19108 
    oprot.writeStructEnd()
19109 
 
19110 
  def validate(self):
19111 
    return
19112 
 
19113 
 
19114 
  def __repr__(self):
19115 
    L = ['%s=%r' % (key, value)
19116 
      for key, value in self.__dict__.iteritems()]
19117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19118 
 
19119 
  def __eq__(self, other):
19120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19121 
 
19122 
  def __ne__(self, other):
19123 
    return not (self == other)
19124 
 
19125 
class changeItem_result:
19126 
  """
19127 
  Attributes:
19128 
   - success
19129 
   - ex
19130 
  """
19131 
 
19132 
  thrift_spec = (
19133 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19134 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19135 
  )
19136 
 
19137 
  def __init__(self, success=None, ex=None,):
19138 
    self.success = success
19139 
    self.ex = ex
19140 
 
19141 
  def read(self, iprot):
19142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19144 
      return
19145 
    iprot.readStructBegin()
19146 
    while True:
19147 
      (fname, ftype, fid) = iprot.readFieldBegin()
19148 
      if ftype == TType.STOP:
19149 
        break
19150 
      if fid == 0:
19151 
        if ftype == TType.STRUCT:
19152 
          self.success = Order()
19153 
          self.success.read(iprot)
19154 
        else:
19155 
          iprot.skip(ftype)
19156 
      elif fid == 1:
19157 
        if ftype == TType.STRUCT:
19158 
          self.ex = TransactionServiceException()
19159 
          self.ex.read(iprot)
19160 
        else:
19161 
          iprot.skip(ftype)
19162 
      else:
19163 
        iprot.skip(ftype)
19164 
      iprot.readFieldEnd()
19165 
    iprot.readStructEnd()
19166 
 
19167 
  def write(self, oprot):
19168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19170 
      return
19171 
    oprot.writeStructBegin('changeItem_result')
19172 
    if self.success is not None:
19173 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19174 
      self.success.write(oprot)
19175 
      oprot.writeFieldEnd()
19176 
    if self.ex is not None:
19177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19178 
      self.ex.write(oprot)
19179 
      oprot.writeFieldEnd()
19180 
    oprot.writeFieldStop()
19181 
    oprot.writeStructEnd()
19182 
 
19183 
  def validate(self):
19184 
    return
19185 
 
19186 
 
19187 
  def __repr__(self):
19188 
    L = ['%s=%r' % (key, value)
19189 
      for key, value in self.__dict__.iteritems()]
19190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19191 
 
19192 
  def __eq__(self, other):
19193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19194 
 
19195 
  def __ne__(self, other):
19196 
    return not (self == other)
19197 
 
19198 
class shiftToWarehouse_args:
19199 
  """
19200 
  Attributes:
19201 
   - orderId
19202 
   - warehouseId
19203 
  """
19204 
 
19205 
  thrift_spec = (
19206 
    None, # 0
19207 
    (1, TType.I64, 'orderId', None, None, ), # 1
19208 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19209 
  )
19210 
 
19211 
  def __init__(self, orderId=None, warehouseId=None,):
19212 
    self.orderId = orderId
19213 
    self.warehouseId = warehouseId
19214 
 
19215 
  def read(self, iprot):
19216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19218 
      return
19219 
    iprot.readStructBegin()
19220 
    while True:
19221 
      (fname, ftype, fid) = iprot.readFieldBegin()
19222 
      if ftype == TType.STOP:
19223 
        break
19224 
      if fid == 1:
19225 
        if ftype == TType.I64:
19226 
          self.orderId = iprot.readI64();
19227 
        else:
19228 
          iprot.skip(ftype)
19229 
      elif fid == 2:
19230 
        if ftype == TType.I64:
19231 
          self.warehouseId = iprot.readI64();
19232 
        else:
19233 
          iprot.skip(ftype)
19234 
      else:
19235 
        iprot.skip(ftype)
19236 
      iprot.readFieldEnd()
19237 
    iprot.readStructEnd()
19238 
 
19239 
  def write(self, oprot):
19240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19242 
      return
19243 
    oprot.writeStructBegin('shiftToWarehouse_args')
19244 
    if self.orderId is not None:
19245 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19246 
      oprot.writeI64(self.orderId)
19247 
      oprot.writeFieldEnd()
19248 
    if self.warehouseId is not None:
19249 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19250 
      oprot.writeI64(self.warehouseId)
19251 
      oprot.writeFieldEnd()
19252 
    oprot.writeFieldStop()
19253 
    oprot.writeStructEnd()
19254 
 
19255 
  def validate(self):
19256 
    return
19257 
 
19258 
 
19259 
  def __repr__(self):
19260 
    L = ['%s=%r' % (key, value)
19261 
      for key, value in self.__dict__.iteritems()]
19262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19263 
 
19264 
  def __eq__(self, other):
19265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19266 
 
19267 
  def __ne__(self, other):
19268 
    return not (self == other)
19269 
 
19270 
class shiftToWarehouse_result:
19271 
  """
19272 
  Attributes:
19273 
   - success
19274 
   - ex
19275 
  """
19276 
 
19277 
  thrift_spec = (
19278 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19280 
  )
19281 
 
19282 
  def __init__(self, success=None, ex=None,):
19283 
    self.success = success
19284 
    self.ex = ex
19285 
 
19286 
  def read(self, iprot):
19287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19289 
      return
19290 
    iprot.readStructBegin()
19291 
    while True:
19292 
      (fname, ftype, fid) = iprot.readFieldBegin()
19293 
      if ftype == TType.STOP:
19294 
        break
19295 
      if fid == 0:
19296 
        if ftype == TType.STRUCT:
19297 
          self.success = Order()
19298 
          self.success.read(iprot)
19299 
        else:
19300 
          iprot.skip(ftype)
19301 
      elif fid == 1:
19302 
        if ftype == TType.STRUCT:
19303 
          self.ex = TransactionServiceException()
19304 
          self.ex.read(iprot)
19305 
        else:
19306 
          iprot.skip(ftype)
19307 
      else:
19308 
        iprot.skip(ftype)
19309 
      iprot.readFieldEnd()
19310 
    iprot.readStructEnd()
19311 
 
19312 
  def write(self, oprot):
19313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19315 
      return
19316 
    oprot.writeStructBegin('shiftToWarehouse_result')
19317 
    if self.success is not None:
19318 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19319 
      self.success.write(oprot)
19320 
      oprot.writeFieldEnd()
19321 
    if self.ex is not None:
19322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19323 
      self.ex.write(oprot)
19324 
      oprot.writeFieldEnd()
19325 
    oprot.writeFieldStop()
19326 
    oprot.writeStructEnd()
19327 
 
19328 
  def validate(self):
19329 
    return
19330 
 
19331 
 
19332 
  def __repr__(self):
19333 
    L = ['%s=%r' % (key, value)
19334 
      for key, value in self.__dict__.iteritems()]
19335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19336 
 
19337 
  def __eq__(self, other):
19338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19339 
 
19340 
  def __ne__(self, other):
19341 
    return not (self == other)
3553 chandransh 19342 
 
19343 
class addDelayReason_args:
19344 
  """
19345 
  Attributes:
19346 
   - orderId
19347 
   - delayReason
3986 chandransh 19348 
   - furtherDelay
4647 rajveer 19349 
   - delayReasonText
3553 chandransh 19350 
  """
19351 
 
19352 
  thrift_spec = (
19353 
    None, # 0
19354 
    (1, TType.I64, 'orderId', None, None, ), # 1
19355 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19356 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19357 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19358 
  )
19359 
 
4647 rajveer 19360 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19361 
    self.orderId = orderId
19362 
    self.delayReason = delayReason
3986 chandransh 19363 
    self.furtherDelay = furtherDelay
4647 rajveer 19364 
    self.delayReasonText = delayReasonText
3553 chandransh 19365 
 
19366 
  def read(self, iprot):
19367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19369 
      return
19370 
    iprot.readStructBegin()
19371 
    while True:
19372 
      (fname, ftype, fid) = iprot.readFieldBegin()
19373 
      if ftype == TType.STOP:
19374 
        break
19375 
      if fid == 1:
19376 
        if ftype == TType.I64:
19377 
          self.orderId = iprot.readI64();
19378 
        else:
19379 
          iprot.skip(ftype)
19380 
      elif fid == 2:
19381 
        if ftype == TType.I32:
19382 
          self.delayReason = iprot.readI32();
19383 
        else:
19384 
          iprot.skip(ftype)
3986 chandransh 19385 
      elif fid == 3:
19386 
        if ftype == TType.I64:
19387 
          self.furtherDelay = iprot.readI64();
19388 
        else:
19389 
          iprot.skip(ftype)
4647 rajveer 19390 
      elif fid == 4:
19391 
        if ftype == TType.STRING:
19392 
          self.delayReasonText = iprot.readString();
19393 
        else:
19394 
          iprot.skip(ftype)
3553 chandransh 19395 
      else:
19396 
        iprot.skip(ftype)
19397 
      iprot.readFieldEnd()
19398 
    iprot.readStructEnd()
19399 
 
19400 
  def write(self, oprot):
19401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19403 
      return
19404 
    oprot.writeStructBegin('addDelayReason_args')
19405 
    if self.orderId is not None:
19406 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19407 
      oprot.writeI64(self.orderId)
19408 
      oprot.writeFieldEnd()
19409 
    if self.delayReason is not None:
19410 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19411 
      oprot.writeI32(self.delayReason)
19412 
      oprot.writeFieldEnd()
3986 chandransh 19413 
    if self.furtherDelay is not None:
19414 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19415 
      oprot.writeI64(self.furtherDelay)
19416 
      oprot.writeFieldEnd()
4647 rajveer 19417 
    if self.delayReasonText is not None:
19418 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19419 
      oprot.writeString(self.delayReasonText)
19420 
      oprot.writeFieldEnd()
3553 chandransh 19421 
    oprot.writeFieldStop()
19422 
    oprot.writeStructEnd()
19423 
 
19424 
  def validate(self):
19425 
    return
19426 
 
19427 
 
19428 
  def __repr__(self):
19429 
    L = ['%s=%r' % (key, value)
19430 
      for key, value in self.__dict__.iteritems()]
19431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19432 
 
19433 
  def __eq__(self, other):
19434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19435 
 
19436 
  def __ne__(self, other):
19437 
    return not (self == other)
19438 
 
19439 
class addDelayReason_result:
19440 
  """
19441 
  Attributes:
19442 
   - success
19443 
   - ex
19444 
  """
19445 
 
19446 
  thrift_spec = (
19447 
    (0, TType.BOOL, 'success', None, None, ), # 0
19448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19449 
  )
19450 
 
19451 
  def __init__(self, success=None, ex=None,):
19452 
    self.success = success
19453 
    self.ex = ex
19454 
 
19455 
  def read(self, iprot):
19456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19458 
      return
19459 
    iprot.readStructBegin()
19460 
    while True:
19461 
      (fname, ftype, fid) = iprot.readFieldBegin()
19462 
      if ftype == TType.STOP:
19463 
        break
19464 
      if fid == 0:
19465 
        if ftype == TType.BOOL:
19466 
          self.success = iprot.readBool();
19467 
        else:
19468 
          iprot.skip(ftype)
19469 
      elif fid == 1:
19470 
        if ftype == TType.STRUCT:
19471 
          self.ex = TransactionServiceException()
19472 
          self.ex.read(iprot)
19473 
        else:
19474 
          iprot.skip(ftype)
19475 
      else:
19476 
        iprot.skip(ftype)
19477 
      iprot.readFieldEnd()
19478 
    iprot.readStructEnd()
19479 
 
19480 
  def write(self, oprot):
19481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19483 
      return
19484 
    oprot.writeStructBegin('addDelayReason_result')
19485 
    if self.success is not None:
19486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19487 
      oprot.writeBool(self.success)
19488 
      oprot.writeFieldEnd()
19489 
    if self.ex is not None:
19490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19491 
      self.ex.write(oprot)
19492 
      oprot.writeFieldEnd()
19493 
    oprot.writeFieldStop()
19494 
    oprot.writeStructEnd()
19495 
 
19496 
  def validate(self):
19497 
    return
19498 
 
19499 
 
19500 
  def __repr__(self):
19501 
    L = ['%s=%r' % (key, value)
19502 
      for key, value in self.__dict__.iteritems()]
19503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19504 
 
19505 
  def __eq__(self, other):
19506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19507 
 
19508 
  def __ne__(self, other):
19509 
    return not (self == other)
3956 chandransh 19510 
 
19511 
class reconcileCodCollection_args:
19512 
  """
19513 
  Attributes:
19514 
   - collectedAmountMap
19515 
   - xferBy
19516 
   - xferTxnId
19517 
   - xferDate
19518 
  """
19519 
 
19520 
  thrift_spec = (
19521 
    None, # 0
19522 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19523 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19524 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19525 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19526 
  )
19527 
 
19528 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19529 
    self.collectedAmountMap = collectedAmountMap
19530 
    self.xferBy = xferBy
19531 
    self.xferTxnId = xferTxnId
19532 
    self.xferDate = xferDate
19533 
 
19534 
  def read(self, iprot):
19535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19537 
      return
19538 
    iprot.readStructBegin()
19539 
    while True:
19540 
      (fname, ftype, fid) = iprot.readFieldBegin()
19541 
      if ftype == TType.STOP:
19542 
        break
19543 
      if fid == 1:
19544 
        if ftype == TType.MAP:
19545 
          self.collectedAmountMap = {}
6188 rajveer 19546 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19547 
          for _i457 in xrange(_size453):
19548 
            _key458 = iprot.readString();
19549 
            _val459 = iprot.readDouble();
19550 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19551 
          iprot.readMapEnd()
19552 
        else:
19553 
          iprot.skip(ftype)
19554 
      elif fid == 2:
19555 
        if ftype == TType.STRING:
19556 
          self.xferBy = iprot.readString();
19557 
        else:
19558 
          iprot.skip(ftype)
19559 
      elif fid == 3:
19560 
        if ftype == TType.STRING:
19561 
          self.xferTxnId = iprot.readString();
19562 
        else:
19563 
          iprot.skip(ftype)
19564 
      elif fid == 4:
19565 
        if ftype == TType.I64:
19566 
          self.xferDate = iprot.readI64();
19567 
        else:
19568 
          iprot.skip(ftype)
19569 
      else:
19570 
        iprot.skip(ftype)
19571 
      iprot.readFieldEnd()
19572 
    iprot.readStructEnd()
19573 
 
19574 
  def write(self, oprot):
19575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19577 
      return
19578 
    oprot.writeStructBegin('reconcileCodCollection_args')
19579 
    if self.collectedAmountMap is not None:
19580 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19581 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19582 
      for kiter460,viter461 in self.collectedAmountMap.items():
19583 
        oprot.writeString(kiter460)
19584 
        oprot.writeDouble(viter461)
3956 chandransh 19585 
      oprot.writeMapEnd()
19586 
      oprot.writeFieldEnd()
19587 
    if self.xferBy is not None:
19588 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19589 
      oprot.writeString(self.xferBy)
19590 
      oprot.writeFieldEnd()
19591 
    if self.xferTxnId is not None:
19592 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19593 
      oprot.writeString(self.xferTxnId)
19594 
      oprot.writeFieldEnd()
19595 
    if self.xferDate is not None:
19596 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19597 
      oprot.writeI64(self.xferDate)
19598 
      oprot.writeFieldEnd()
19599 
    oprot.writeFieldStop()
19600 
    oprot.writeStructEnd()
19601 
 
19602 
  def validate(self):
19603 
    return
19604 
 
19605 
 
19606 
  def __repr__(self):
19607 
    L = ['%s=%r' % (key, value)
19608 
      for key, value in self.__dict__.iteritems()]
19609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19610 
 
19611 
  def __eq__(self, other):
19612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19613 
 
19614 
  def __ne__(self, other):
19615 
    return not (self == other)
19616 
 
19617 
class reconcileCodCollection_result:
19618 
  """
19619 
  Attributes:
19620 
   - success
19621 
   - ex
19622 
  """
19623 
 
19624 
  thrift_spec = (
19625 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19626 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19627 
  )
19628 
 
19629 
  def __init__(self, success=None, ex=None,):
19630 
    self.success = success
19631 
    self.ex = ex
19632 
 
19633 
  def read(self, iprot):
19634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19636 
      return
19637 
    iprot.readStructBegin()
19638 
    while True:
19639 
      (fname, ftype, fid) = iprot.readFieldBegin()
19640 
      if ftype == TType.STOP:
19641 
        break
19642 
      if fid == 0:
19643 
        if ftype == TType.MAP:
19644 
          self.success = {}
6188 rajveer 19645 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19646 
          for _i466 in xrange(_size462):
19647 
            _key467 = iprot.readString();
19648 
            _val468 = iprot.readString();
19649 
            self.success[_key467] = _val468
3956 chandransh 19650 
          iprot.readMapEnd()
19651 
        else:
19652 
          iprot.skip(ftype)
19653 
      elif fid == 1:
19654 
        if ftype == TType.STRUCT:
19655 
          self.ex = TransactionServiceException()
19656 
          self.ex.read(iprot)
19657 
        else:
19658 
          iprot.skip(ftype)
19659 
      else:
19660 
        iprot.skip(ftype)
19661 
      iprot.readFieldEnd()
19662 
    iprot.readStructEnd()
19663 
 
19664 
  def write(self, oprot):
19665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19667 
      return
19668 
    oprot.writeStructBegin('reconcileCodCollection_result')
19669 
    if self.success is not None:
19670 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19671 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19672 
      for kiter469,viter470 in self.success.items():
19673 
        oprot.writeString(kiter469)
19674 
        oprot.writeString(viter470)
3956 chandransh 19675 
      oprot.writeMapEnd()
19676 
      oprot.writeFieldEnd()
19677 
    if self.ex is not None:
19678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19679 
      self.ex.write(oprot)
19680 
      oprot.writeFieldEnd()
19681 
    oprot.writeFieldStop()
19682 
    oprot.writeStructEnd()
19683 
 
19684 
  def validate(self):
19685 
    return
19686 
 
19687 
 
19688 
  def __repr__(self):
19689 
    L = ['%s=%r' % (key, value)
19690 
      for key, value in self.__dict__.iteritems()]
19691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19692 
 
19693 
  def __eq__(self, other):
19694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19695 
 
19696 
  def __ne__(self, other):
19697 
    return not (self == other)
4008 mandeep.dh 19698 
 
19699 
class getTransactionsRequiringExtraProcessing_args:
19700 
  """
19701 
  Attributes:
19702 
   - category
19703 
  """
19704 
 
19705 
  thrift_spec = (
19706 
    None, # 0
19707 
    (1, TType.I32, 'category', None, None, ), # 1
19708 
  )
19709 
 
19710 
  def __init__(self, category=None,):
19711 
    self.category = category
19712 
 
19713 
  def read(self, iprot):
19714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19716 
      return
19717 
    iprot.readStructBegin()
19718 
    while True:
19719 
      (fname, ftype, fid) = iprot.readFieldBegin()
19720 
      if ftype == TType.STOP:
19721 
        break
19722 
      if fid == 1:
19723 
        if ftype == TType.I32:
19724 
          self.category = iprot.readI32();
19725 
        else:
19726 
          iprot.skip(ftype)
19727 
      else:
19728 
        iprot.skip(ftype)
19729 
      iprot.readFieldEnd()
19730 
    iprot.readStructEnd()
19731 
 
19732 
  def write(self, oprot):
19733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19735 
      return
19736 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19737 
    if self.category is not None:
19738 
      oprot.writeFieldBegin('category', TType.I32, 1)
19739 
      oprot.writeI32(self.category)
19740 
      oprot.writeFieldEnd()
19741 
    oprot.writeFieldStop()
19742 
    oprot.writeStructEnd()
19743 
 
19744 
  def validate(self):
19745 
    return
19746 
 
19747 
 
19748 
  def __repr__(self):
19749 
    L = ['%s=%r' % (key, value)
19750 
      for key, value in self.__dict__.iteritems()]
19751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19752 
 
19753 
  def __eq__(self, other):
19754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19755 
 
19756 
  def __ne__(self, other):
19757 
    return not (self == other)
19758 
 
19759 
class getTransactionsRequiringExtraProcessing_result:
19760 
  """
19761 
  Attributes:
19762 
   - success
19763 
  """
19764 
 
19765 
  thrift_spec = (
19766 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19767 
  )
19768 
 
19769 
  def __init__(self, success=None,):
19770 
    self.success = success
19771 
 
19772 
  def read(self, iprot):
19773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19775 
      return
19776 
    iprot.readStructBegin()
19777 
    while True:
19778 
      (fname, ftype, fid) = iprot.readFieldBegin()
19779 
      if ftype == TType.STOP:
19780 
        break
19781 
      if fid == 0:
19782 
        if ftype == TType.LIST:
19783 
          self.success = []
6188 rajveer 19784 
          (_etype474, _size471) = iprot.readListBegin()
19785 
          for _i475 in xrange(_size471):
19786 
            _elem476 = iprot.readI64();
19787 
            self.success.append(_elem476)
4008 mandeep.dh 19788 
          iprot.readListEnd()
19789 
        else:
19790 
          iprot.skip(ftype)
19791 
      else:
19792 
        iprot.skip(ftype)
19793 
      iprot.readFieldEnd()
19794 
    iprot.readStructEnd()
19795 
 
19796 
  def write(self, oprot):
19797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19799 
      return
19800 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19801 
    if self.success is not None:
19802 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19803 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19804 
      for iter477 in self.success:
19805 
        oprot.writeI64(iter477)
4008 mandeep.dh 19806 
      oprot.writeListEnd()
19807 
      oprot.writeFieldEnd()
19808 
    oprot.writeFieldStop()
19809 
    oprot.writeStructEnd()
19810 
 
19811 
  def validate(self):
19812 
    return
19813 
 
19814 
 
19815 
  def __repr__(self):
19816 
    L = ['%s=%r' % (key, value)
19817 
      for key, value in self.__dict__.iteritems()]
19818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19819 
 
19820 
  def __eq__(self, other):
19821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19822 
 
19823 
  def __ne__(self, other):
19824 
    return not (self == other)
19825 
 
19826 
class markTransactionAsProcessed_args:
19827 
  """
19828 
  Attributes:
19829 
   - transactionId
19830 
   - category
19831 
  """
19832 
 
19833 
  thrift_spec = (
19834 
    None, # 0
19835 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19836 
    (2, TType.I32, 'category', None, None, ), # 2
19837 
  )
19838 
 
19839 
  def __init__(self, transactionId=None, category=None,):
19840 
    self.transactionId = transactionId
19841 
    self.category = category
19842 
 
19843 
  def read(self, iprot):
19844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19846 
      return
19847 
    iprot.readStructBegin()
19848 
    while True:
19849 
      (fname, ftype, fid) = iprot.readFieldBegin()
19850 
      if ftype == TType.STOP:
19851 
        break
19852 
      if fid == 1:
19853 
        if ftype == TType.I64:
19854 
          self.transactionId = iprot.readI64();
19855 
        else:
19856 
          iprot.skip(ftype)
19857 
      elif fid == 2:
19858 
        if ftype == TType.I32:
19859 
          self.category = iprot.readI32();
19860 
        else:
19861 
          iprot.skip(ftype)
19862 
      else:
19863 
        iprot.skip(ftype)
19864 
      iprot.readFieldEnd()
19865 
    iprot.readStructEnd()
19866 
 
19867 
  def write(self, oprot):
19868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19870 
      return
19871 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19872 
    if self.transactionId is not None:
19873 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19874 
      oprot.writeI64(self.transactionId)
19875 
      oprot.writeFieldEnd()
19876 
    if self.category is not None:
19877 
      oprot.writeFieldBegin('category', TType.I32, 2)
19878 
      oprot.writeI32(self.category)
19879 
      oprot.writeFieldEnd()
19880 
    oprot.writeFieldStop()
19881 
    oprot.writeStructEnd()
19882 
 
19883 
  def validate(self):
19884 
    return
19885 
 
19886 
 
19887 
  def __repr__(self):
19888 
    L = ['%s=%r' % (key, value)
19889 
      for key, value in self.__dict__.iteritems()]
19890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19891 
 
19892 
  def __eq__(self, other):
19893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19894 
 
19895 
  def __ne__(self, other):
19896 
    return not (self == other)
19897 
 
19898 
class markTransactionAsProcessed_result:
19899 
 
19900 
  thrift_spec = (
19901 
  )
19902 
 
19903 
  def read(self, iprot):
19904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19906 
      return
19907 
    iprot.readStructBegin()
19908 
    while True:
19909 
      (fname, ftype, fid) = iprot.readFieldBegin()
19910 
      if ftype == TType.STOP:
19911 
        break
19912 
      else:
19913 
        iprot.skip(ftype)
19914 
      iprot.readFieldEnd()
19915 
    iprot.readStructEnd()
19916 
 
19917 
  def write(self, oprot):
19918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19920 
      return
19921 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19922 
    oprot.writeFieldStop()
19923 
    oprot.writeStructEnd()
19924 
 
19925 
  def validate(self):
19926 
    return
19927 
 
19928 
 
19929 
  def __repr__(self):
19930 
    L = ['%s=%r' % (key, value)
19931 
      for key, value in self.__dict__.iteritems()]
19932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19933 
 
19934 
  def __eq__(self, other):
19935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19936 
 
19937 
  def __ne__(self, other):
19938 
    return not (self == other)
4018 chandransh 19939 
 
19940 
class getItemWiseRiskyOrdersCount_args:
19941 
 
19942 
  thrift_spec = (
19943 
  )
19944 
 
19945 
  def read(self, iprot):
19946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19948 
      return
19949 
    iprot.readStructBegin()
19950 
    while True:
19951 
      (fname, ftype, fid) = iprot.readFieldBegin()
19952 
      if ftype == TType.STOP:
19953 
        break
19954 
      else:
19955 
        iprot.skip(ftype)
19956 
      iprot.readFieldEnd()
19957 
    iprot.readStructEnd()
19958 
 
19959 
  def write(self, oprot):
19960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19962 
      return
19963 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19964 
    oprot.writeFieldStop()
19965 
    oprot.writeStructEnd()
19966 
 
19967 
  def validate(self):
19968 
    return
19969 
 
19970 
 
19971 
  def __repr__(self):
19972 
    L = ['%s=%r' % (key, value)
19973 
      for key, value in self.__dict__.iteritems()]
19974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19975 
 
19976 
  def __eq__(self, other):
19977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19978 
 
19979 
  def __ne__(self, other):
19980 
    return not (self == other)
19981 
 
19982 
class getItemWiseRiskyOrdersCount_result:
19983 
  """
19984 
  Attributes:
19985 
   - success
19986 
  """
19987 
 
19988 
  thrift_spec = (
19989 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19990 
  )
19991 
 
19992 
  def __init__(self, success=None,):
19993 
    self.success = success
19994 
 
19995 
  def read(self, iprot):
19996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19998 
      return
19999 
    iprot.readStructBegin()
20000 
    while True:
20001 
      (fname, ftype, fid) = iprot.readFieldBegin()
20002 
      if ftype == TType.STOP:
20003 
        break
20004 
      if fid == 0:
20005 
        if ftype == TType.MAP:
20006 
          self.success = {}
6188 rajveer 20007 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20008 
          for _i482 in xrange(_size478):
20009 
            _key483 = iprot.readI64();
20010 
            _val484 = iprot.readI64();
20011 
            self.success[_key483] = _val484
4018 chandransh 20012 
          iprot.readMapEnd()
20013 
        else:
20014 
          iprot.skip(ftype)
20015 
      else:
20016 
        iprot.skip(ftype)
20017 
      iprot.readFieldEnd()
20018 
    iprot.readStructEnd()
20019 
 
20020 
  def write(self, oprot):
20021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20023 
      return
20024 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20025 
    if self.success is not None:
20026 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20027 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20028 
      for kiter485,viter486 in self.success.items():
20029 
        oprot.writeI64(kiter485)
20030 
        oprot.writeI64(viter486)
4018 chandransh 20031 
      oprot.writeMapEnd()
20032 
      oprot.writeFieldEnd()
20033 
    oprot.writeFieldStop()
20034 
    oprot.writeStructEnd()
20035 
 
20036 
  def validate(self):
20037 
    return
20038 
 
20039 
 
20040 
  def __repr__(self):
20041 
    L = ['%s=%r' % (key, value)
20042 
      for key, value in self.__dict__.iteritems()]
20043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20044 
 
20045 
  def __eq__(self, other):
20046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20047 
 
20048 
  def __ne__(self, other):
20049 
    return not (self == other)
4247 rajveer 20050 
 
4295 varun.gupt 20051 
class getOrdersForItemIds_args:
20052 
  """
20053 
  Attributes:
20054 
   - itemIds
20055 
  """
20056 
 
20057 
  thrift_spec = (
20058 
    None, # 0
20059 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20060 
  )
20061 
 
20062 
  def __init__(self, itemIds=None,):
20063 
    self.itemIds = itemIds
20064 
 
20065 
  def read(self, iprot):
20066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20068 
      return
20069 
    iprot.readStructBegin()
20070 
    while True:
20071 
      (fname, ftype, fid) = iprot.readFieldBegin()
20072 
      if ftype == TType.STOP:
20073 
        break
20074 
      if fid == 1:
20075 
        if ftype == TType.LIST:
20076 
          self.itemIds = []
6188 rajveer 20077 
          (_etype490, _size487) = iprot.readListBegin()
20078 
          for _i491 in xrange(_size487):
20079 
            _elem492 = iprot.readI64();
20080 
            self.itemIds.append(_elem492)
4295 varun.gupt 20081 
          iprot.readListEnd()
20082 
        else:
20083 
          iprot.skip(ftype)
20084 
      else:
20085 
        iprot.skip(ftype)
20086 
      iprot.readFieldEnd()
20087 
    iprot.readStructEnd()
20088 
 
20089 
  def write(self, oprot):
20090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20092 
      return
20093 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20094 
    if self.itemIds is not None:
20095 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20096 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20097 
      for iter493 in self.itemIds:
20098 
        oprot.writeI64(iter493)
4295 varun.gupt 20099 
      oprot.writeListEnd()
20100 
      oprot.writeFieldEnd()
20101 
    oprot.writeFieldStop()
20102 
    oprot.writeStructEnd()
20103 
 
20104 
  def validate(self):
20105 
    return
20106 
 
20107 
 
20108 
  def __repr__(self):
20109 
    L = ['%s=%r' % (key, value)
20110 
      for key, value in self.__dict__.iteritems()]
20111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20112 
 
20113 
  def __eq__(self, other):
20114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20115 
 
20116 
  def __ne__(self, other):
20117 
    return not (self == other)
20118 
 
20119 
class getOrdersForItemIds_result:
20120 
  """
20121 
  Attributes:
20122 
   - success
20123 
  """
20124 
 
20125 
  thrift_spec = (
20126 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20127 
  )
20128 
 
20129 
  def __init__(self, success=None,):
20130 
    self.success = success
20131 
 
20132 
  def read(self, iprot):
20133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20135 
      return
20136 
    iprot.readStructBegin()
20137 
    while True:
20138 
      (fname, ftype, fid) = iprot.readFieldBegin()
20139 
      if ftype == TType.STOP:
20140 
        break
20141 
      if fid == 0:
20142 
        if ftype == TType.LIST:
20143 
          self.success = []
6188 rajveer 20144 
          (_etype497, _size494) = iprot.readListBegin()
20145 
          for _i498 in xrange(_size494):
20146 
            _elem499 = Order()
20147 
            _elem499.read(iprot)
20148 
            self.success.append(_elem499)
4295 varun.gupt 20149 
          iprot.readListEnd()
20150 
        else:
20151 
          iprot.skip(ftype)
20152 
      else:
20153 
        iprot.skip(ftype)
20154 
      iprot.readFieldEnd()
20155 
    iprot.readStructEnd()
20156 
 
20157 
  def write(self, oprot):
20158 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20159 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20160 
      return
20161 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20162 
    if self.success is not None:
20163 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20164 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20165 
      for iter500 in self.success:
20166 
        iter500.write(oprot)
4295 varun.gupt 20167 
      oprot.writeListEnd()
20168 
      oprot.writeFieldEnd()
20169 
    oprot.writeFieldStop()
20170 
    oprot.writeStructEnd()
20171 
 
20172 
  def validate(self):
20173 
    return
20174 
 
20175 
 
20176 
  def __repr__(self):
20177 
    L = ['%s=%r' % (key, value)
20178 
      for key, value in self.__dict__.iteritems()]
20179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20180 
 
20181 
  def __eq__(self, other):
20182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20183 
 
20184 
  def __ne__(self, other):
20185 
    return not (self == other)
20186 
 
4247 rajveer 20187 
class markOrderCancellationRequestReceived_args:
20188 
  """
20189 
  Attributes:
20190 
   - orderId
20191 
  """
20192 
 
20193 
  thrift_spec = (
20194 
    None, # 0
20195 
    (1, TType.I64, 'orderId', None, None, ), # 1
20196 
  )
20197 
 
20198 
  def __init__(self, orderId=None,):
20199 
    self.orderId = orderId
20200 
 
20201 
  def read(self, iprot):
20202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20204 
      return
20205 
    iprot.readStructBegin()
20206 
    while True:
20207 
      (fname, ftype, fid) = iprot.readFieldBegin()
20208 
      if ftype == TType.STOP:
20209 
        break
20210 
      if fid == 1:
20211 
        if ftype == TType.I64:
20212 
          self.orderId = iprot.readI64();
20213 
        else:
20214 
          iprot.skip(ftype)
20215 
      else:
20216 
        iprot.skip(ftype)
20217 
      iprot.readFieldEnd()
20218 
    iprot.readStructEnd()
20219 
 
20220 
  def write(self, oprot):
20221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20223 
      return
20224 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20225 
    if self.orderId is not None:
20226 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20227 
      oprot.writeI64(self.orderId)
20228 
      oprot.writeFieldEnd()
20229 
    oprot.writeFieldStop()
20230 
    oprot.writeStructEnd()
20231 
 
20232 
  def validate(self):
20233 
    return
20234 
 
20235 
 
20236 
  def __repr__(self):
20237 
    L = ['%s=%r' % (key, value)
20238 
      for key, value in self.__dict__.iteritems()]
20239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20240 
 
20241 
  def __eq__(self, other):
20242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20243 
 
20244 
  def __ne__(self, other):
20245 
    return not (self == other)
20246 
 
20247 
class markOrderCancellationRequestReceived_result:
20248 
  """
20249 
  Attributes:
20250 
   - ex
20251 
  """
20252 
 
20253 
  thrift_spec = (
20254 
    None, # 0
20255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20256 
  )
20257 
 
20258 
  def __init__(self, ex=None,):
20259 
    self.ex = ex
20260 
 
20261 
  def read(self, iprot):
20262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20264 
      return
20265 
    iprot.readStructBegin()
20266 
    while True:
20267 
      (fname, ftype, fid) = iprot.readFieldBegin()
20268 
      if ftype == TType.STOP:
20269 
        break
20270 
      if fid == 1:
20271 
        if ftype == TType.STRUCT:
20272 
          self.ex = TransactionServiceException()
20273 
          self.ex.read(iprot)
20274 
        else:
20275 
          iprot.skip(ftype)
20276 
      else:
20277 
        iprot.skip(ftype)
20278 
      iprot.readFieldEnd()
20279 
    iprot.readStructEnd()
20280 
 
20281 
  def write(self, oprot):
20282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20284 
      return
20285 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20286 
    if self.ex is not None:
20287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20288 
      self.ex.write(oprot)
20289 
      oprot.writeFieldEnd()
20290 
    oprot.writeFieldStop()
20291 
    oprot.writeStructEnd()
20292 
 
20293 
  def validate(self):
20294 
    return
20295 
 
20296 
 
20297 
  def __repr__(self):
20298 
    L = ['%s=%r' % (key, value)
20299 
      for key, value in self.__dict__.iteritems()]
20300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20301 
 
20302 
  def __eq__(self, other):
20303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20304 
 
20305 
  def __ne__(self, other):
20306 
    return not (self == other)
20307 
 
20308 
class markOrderCancellationRequestConfirmed_args:
20309 
  """
20310 
  Attributes:
20311 
   - orderId
20312 
  """
20313 
 
20314 
  thrift_spec = (
20315 
    None, # 0
20316 
    (1, TType.I64, 'orderId', None, None, ), # 1
20317 
  )
20318 
 
20319 
  def __init__(self, orderId=None,):
20320 
    self.orderId = orderId
20321 
 
20322 
  def read(self, iprot):
20323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20325 
      return
20326 
    iprot.readStructBegin()
20327 
    while True:
20328 
      (fname, ftype, fid) = iprot.readFieldBegin()
20329 
      if ftype == TType.STOP:
20330 
        break
20331 
      if fid == 1:
20332 
        if ftype == TType.I64:
20333 
          self.orderId = iprot.readI64();
20334 
        else:
20335 
          iprot.skip(ftype)
20336 
      else:
20337 
        iprot.skip(ftype)
20338 
      iprot.readFieldEnd()
20339 
    iprot.readStructEnd()
20340 
 
20341 
  def write(self, oprot):
20342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20344 
      return
20345 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20346 
    if self.orderId is not None:
20347 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20348 
      oprot.writeI64(self.orderId)
20349 
      oprot.writeFieldEnd()
20350 
    oprot.writeFieldStop()
20351 
    oprot.writeStructEnd()
20352 
 
20353 
  def validate(self):
20354 
    return
20355 
 
20356 
 
20357 
  def __repr__(self):
20358 
    L = ['%s=%r' % (key, value)
20359 
      for key, value in self.__dict__.iteritems()]
20360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20361 
 
20362 
  def __eq__(self, other):
20363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20364 
 
20365 
  def __ne__(self, other):
20366 
    return not (self == other)
20367 
 
20368 
class markOrderCancellationRequestConfirmed_result:
20369 
  """
20370 
  Attributes:
20371 
   - ex
20372 
  """
20373 
 
20374 
  thrift_spec = (
20375 
    None, # 0
20376 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20377 
  )
20378 
 
20379 
  def __init__(self, ex=None,):
20380 
    self.ex = ex
20381 
 
20382 
  def read(self, iprot):
20383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20385 
      return
20386 
    iprot.readStructBegin()
20387 
    while True:
20388 
      (fname, ftype, fid) = iprot.readFieldBegin()
20389 
      if ftype == TType.STOP:
20390 
        break
20391 
      if fid == 1:
20392 
        if ftype == TType.STRUCT:
20393 
          self.ex = TransactionServiceException()
20394 
          self.ex.read(iprot)
20395 
        else:
20396 
          iprot.skip(ftype)
20397 
      else:
20398 
        iprot.skip(ftype)
20399 
      iprot.readFieldEnd()
20400 
    iprot.readStructEnd()
20401 
 
20402 
  def write(self, oprot):
20403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20405 
      return
20406 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20407 
    if self.ex is not None:
20408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20409 
      self.ex.write(oprot)
20410 
      oprot.writeFieldEnd()
20411 
    oprot.writeFieldStop()
20412 
    oprot.writeStructEnd()
20413 
 
20414 
  def validate(self):
20415 
    return
20416 
 
20417 
 
20418 
  def __repr__(self):
20419 
    L = ['%s=%r' % (key, value)
20420 
      for key, value in self.__dict__.iteritems()]
20421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20422 
 
20423 
  def __eq__(self, other):
20424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20425 
 
20426 
  def __ne__(self, other):
20427 
    return not (self == other)
20428 
 
20429 
class markOrderCancellationRequestDenied_args:
20430 
  """
20431 
  Attributes:
20432 
   - orderId
20433 
  """
20434 
 
20435 
  thrift_spec = (
20436 
    None, # 0
20437 
    (1, TType.I64, 'orderId', None, None, ), # 1
20438 
  )
20439 
 
20440 
  def __init__(self, orderId=None,):
20441 
    self.orderId = orderId
20442 
 
20443 
  def read(self, iprot):
20444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20446 
      return
20447 
    iprot.readStructBegin()
20448 
    while True:
20449 
      (fname, ftype, fid) = iprot.readFieldBegin()
20450 
      if ftype == TType.STOP:
20451 
        break
20452 
      if fid == 1:
20453 
        if ftype == TType.I64:
20454 
          self.orderId = iprot.readI64();
20455 
        else:
20456 
          iprot.skip(ftype)
20457 
      else:
20458 
        iprot.skip(ftype)
20459 
      iprot.readFieldEnd()
20460 
    iprot.readStructEnd()
20461 
 
20462 
  def write(self, oprot):
20463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20465 
      return
20466 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20467 
    if self.orderId is not None:
20468 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20469 
      oprot.writeI64(self.orderId)
20470 
      oprot.writeFieldEnd()
20471 
    oprot.writeFieldStop()
20472 
    oprot.writeStructEnd()
20473 
 
20474 
  def validate(self):
20475 
    return
20476 
 
20477 
 
20478 
  def __repr__(self):
20479 
    L = ['%s=%r' % (key, value)
20480 
      for key, value in self.__dict__.iteritems()]
20481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20482 
 
20483 
  def __eq__(self, other):
20484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20485 
 
20486 
  def __ne__(self, other):
20487 
    return not (self == other)
20488 
 
20489 
class markOrderCancellationRequestDenied_result:
20490 
  """
20491 
  Attributes:
20492 
   - ex
20493 
  """
20494 
 
20495 
  thrift_spec = (
20496 
    None, # 0
20497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20498 
  )
20499 
 
20500 
  def __init__(self, ex=None,):
20501 
    self.ex = ex
20502 
 
20503 
  def read(self, iprot):
20504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20506 
      return
20507 
    iprot.readStructBegin()
20508 
    while True:
20509 
      (fname, ftype, fid) = iprot.readFieldBegin()
20510 
      if ftype == TType.STOP:
20511 
        break
20512 
      if fid == 1:
20513 
        if ftype == TType.STRUCT:
20514 
          self.ex = TransactionServiceException()
20515 
          self.ex.read(iprot)
20516 
        else:
20517 
          iprot.skip(ftype)
20518 
      else:
20519 
        iprot.skip(ftype)
20520 
      iprot.readFieldEnd()
20521 
    iprot.readStructEnd()
20522 
 
20523 
  def write(self, oprot):
20524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20526 
      return
20527 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20528 
    if self.ex is not None:
20529 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20530 
      self.ex.write(oprot)
20531 
      oprot.writeFieldEnd()
20532 
    oprot.writeFieldStop()
20533 
    oprot.writeStructEnd()
20534 
 
20535 
  def validate(self):
20536 
    return
20537 
 
20538 
 
20539 
  def __repr__(self):
20540 
    L = ['%s=%r' % (key, value)
20541 
      for key, value in self.__dict__.iteritems()]
20542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20543 
 
20544 
  def __eq__(self, other):
20545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20546 
 
20547 
  def __ne__(self, other):
20548 
    return not (self == other)
20549 
 
4258 rajveer 20550 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20551 
  """
20552 
  Attributes:
4258 rajveer 20553 
   - transactionId
4247 rajveer 20554 
  """
20555 
 
20556 
  thrift_spec = (
20557 
    None, # 0
4258 rajveer 20558 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20559 
  )
20560 
 
4258 rajveer 20561 
  def __init__(self, transactionId=None,):
20562 
    self.transactionId = transactionId
4247 rajveer 20563 
 
20564 
  def read(self, iprot):
20565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20567 
      return
20568 
    iprot.readStructBegin()
20569 
    while True:
20570 
      (fname, ftype, fid) = iprot.readFieldBegin()
20571 
      if ftype == TType.STOP:
20572 
        break
20573 
      if fid == 1:
20574 
        if ftype == TType.I64:
4258 rajveer 20575 
          self.transactionId = iprot.readI64();
4247 rajveer 20576 
        else:
20577 
          iprot.skip(ftype)
20578 
      else:
20579 
        iprot.skip(ftype)
20580 
      iprot.readFieldEnd()
20581 
    iprot.readStructEnd()
20582 
 
20583 
  def write(self, oprot):
20584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20586 
      return
4258 rajveer 20587 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20588 
    if self.transactionId is not None:
20589 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20590 
      oprot.writeI64(self.transactionId)
4247 rajveer 20591 
      oprot.writeFieldEnd()
20592 
    oprot.writeFieldStop()
20593 
    oprot.writeStructEnd()
20594 
 
20595 
  def validate(self):
20596 
    return
20597 
 
20598 
 
20599 
  def __repr__(self):
20600 
    L = ['%s=%r' % (key, value)
20601 
      for key, value in self.__dict__.iteritems()]
20602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20603 
 
20604 
  def __eq__(self, other):
20605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20606 
 
20607 
  def __ne__(self, other):
20608 
    return not (self == other)
20609 
 
4258 rajveer 20610 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20611 
  """
20612 
  Attributes:
20613 
   - ex
20614 
  """
20615 
 
20616 
  thrift_spec = (
20617 
    None, # 0
20618 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20619 
  )
20620 
 
20621 
  def __init__(self, ex=None,):
20622 
    self.ex = ex
20623 
 
20624 
  def read(self, iprot):
20625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20627 
      return
20628 
    iprot.readStructBegin()
20629 
    while True:
20630 
      (fname, ftype, fid) = iprot.readFieldBegin()
20631 
      if ftype == TType.STOP:
20632 
        break
20633 
      if fid == 1:
20634 
        if ftype == TType.STRUCT:
20635 
          self.ex = TransactionServiceException()
20636 
          self.ex.read(iprot)
20637 
        else:
20638 
          iprot.skip(ftype)
20639 
      else:
20640 
        iprot.skip(ftype)
20641 
      iprot.readFieldEnd()
20642 
    iprot.readStructEnd()
20643 
 
20644 
  def write(self, oprot):
20645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20647 
      return
4258 rajveer 20648 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20649 
    if self.ex is not None:
20650 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20651 
      self.ex.write(oprot)
20652 
      oprot.writeFieldEnd()
20653 
    oprot.writeFieldStop()
20654 
    oprot.writeStructEnd()
20655 
 
20656 
  def validate(self):
20657 
    return
20658 
 
20659 
 
20660 
  def __repr__(self):
20661 
    L = ['%s=%r' % (key, value)
20662 
      for key, value in self.__dict__.iteritems()]
20663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20664 
 
20665 
  def __eq__(self, other):
20666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20667 
 
20668 
  def __ne__(self, other):
20669 
    return not (self == other)
4259 anupam.sin 20670 
 
20671 
class refundTransaction_args:
20672 
  """
20673 
  Attributes:
20674 
   - transactionId
20675 
   - refundedBy
20676 
   - reason
20677 
  """
20678 
 
20679 
  thrift_spec = (
20680 
    None, # 0
20681 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20682 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20683 
    (3, TType.STRING, 'reason', None, None, ), # 3
20684 
  )
20685 
 
20686 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20687 
    self.transactionId = transactionId
20688 
    self.refundedBy = refundedBy
20689 
    self.reason = reason
20690 
 
20691 
  def read(self, iprot):
20692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20694 
      return
20695 
    iprot.readStructBegin()
20696 
    while True:
20697 
      (fname, ftype, fid) = iprot.readFieldBegin()
20698 
      if ftype == TType.STOP:
20699 
        break
20700 
      if fid == 1:
20701 
        if ftype == TType.I64:
20702 
          self.transactionId = iprot.readI64();
20703 
        else:
20704 
          iprot.skip(ftype)
20705 
      elif fid == 2:
20706 
        if ftype == TType.STRING:
20707 
          self.refundedBy = iprot.readString();
20708 
        else:
20709 
          iprot.skip(ftype)
20710 
      elif fid == 3:
20711 
        if ftype == TType.STRING:
20712 
          self.reason = iprot.readString();
20713 
        else:
20714 
          iprot.skip(ftype)
20715 
      else:
20716 
        iprot.skip(ftype)
20717 
      iprot.readFieldEnd()
20718 
    iprot.readStructEnd()
20719 
 
20720 
  def write(self, oprot):
20721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20723 
      return
20724 
    oprot.writeStructBegin('refundTransaction_args')
20725 
    if self.transactionId is not None:
20726 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20727 
      oprot.writeI64(self.transactionId)
20728 
      oprot.writeFieldEnd()
20729 
    if self.refundedBy is not None:
20730 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20731 
      oprot.writeString(self.refundedBy)
20732 
      oprot.writeFieldEnd()
20733 
    if self.reason is not None:
20734 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20735 
      oprot.writeString(self.reason)
20736 
      oprot.writeFieldEnd()
20737 
    oprot.writeFieldStop()
20738 
    oprot.writeStructEnd()
20739 
 
20740 
  def validate(self):
20741 
    return
20742 
 
20743 
 
20744 
  def __repr__(self):
20745 
    L = ['%s=%r' % (key, value)
20746 
      for key, value in self.__dict__.iteritems()]
20747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20748 
 
20749 
  def __eq__(self, other):
20750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20751 
 
20752 
  def __ne__(self, other):
20753 
    return not (self == other)
20754 
 
20755 
class refundTransaction_result:
20756 
  """
20757 
  Attributes:
20758 
   - ex
20759 
  """
20760 
 
20761 
  thrift_spec = (
20762 
    None, # 0
20763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20764 
  )
20765 
 
20766 
  def __init__(self, ex=None,):
20767 
    self.ex = ex
20768 
 
20769 
  def read(self, iprot):
20770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20772 
      return
20773 
    iprot.readStructBegin()
20774 
    while True:
20775 
      (fname, ftype, fid) = iprot.readFieldBegin()
20776 
      if ftype == TType.STOP:
20777 
        break
20778 
      if fid == 1:
20779 
        if ftype == TType.STRUCT:
20780 
          self.ex = TransactionServiceException()
20781 
          self.ex.read(iprot)
20782 
        else:
20783 
          iprot.skip(ftype)
20784 
      else:
20785 
        iprot.skip(ftype)
20786 
      iprot.readFieldEnd()
20787 
    iprot.readStructEnd()
20788 
 
20789 
  def write(self, oprot):
20790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20792 
      return
20793 
    oprot.writeStructBegin('refundTransaction_result')
20794 
    if self.ex is not None:
20795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20796 
      self.ex.write(oprot)
20797 
      oprot.writeFieldEnd()
20798 
    oprot.writeFieldStop()
20799 
    oprot.writeStructEnd()
20800 
 
20801 
  def validate(self):
20802 
    return
20803 
 
20804 
 
20805 
  def __repr__(self):
20806 
    L = ['%s=%r' % (key, value)
20807 
      for key, value in self.__dict__.iteritems()]
20808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20809 
 
20810 
  def __eq__(self, other):
20811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20812 
 
20813 
  def __ne__(self, other):
20814 
    return not (self == other)
4285 rajveer 20815 
 
4324 mandeep.dh 20816 
class updateShipmentAddress_args:
20817 
  """
20818 
  Attributes:
20819 
   - orderId
20820 
   - addressId
20821 
  """
20822 
 
20823 
  thrift_spec = (
20824 
    None, # 0
20825 
    (1, TType.I64, 'orderId', None, None, ), # 1
20826 
    (2, TType.I64, 'addressId', None, None, ), # 2
20827 
  )
20828 
 
20829 
  def __init__(self, orderId=None, addressId=None,):
20830 
    self.orderId = orderId
20831 
    self.addressId = addressId
20832 
 
20833 
  def read(self, iprot):
20834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20836 
      return
20837 
    iprot.readStructBegin()
20838 
    while True:
20839 
      (fname, ftype, fid) = iprot.readFieldBegin()
20840 
      if ftype == TType.STOP:
20841 
        break
20842 
      if fid == 1:
20843 
        if ftype == TType.I64:
20844 
          self.orderId = iprot.readI64();
20845 
        else:
20846 
          iprot.skip(ftype)
20847 
      elif fid == 2:
20848 
        if ftype == TType.I64:
20849 
          self.addressId = iprot.readI64();
20850 
        else:
20851 
          iprot.skip(ftype)
20852 
      else:
20853 
        iprot.skip(ftype)
20854 
      iprot.readFieldEnd()
20855 
    iprot.readStructEnd()
20856 
 
20857 
  def write(self, oprot):
20858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20860 
      return
20861 
    oprot.writeStructBegin('updateShipmentAddress_args')
20862 
    if self.orderId is not None:
20863 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20864 
      oprot.writeI64(self.orderId)
20865 
      oprot.writeFieldEnd()
20866 
    if self.addressId is not None:
20867 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20868 
      oprot.writeI64(self.addressId)
20869 
      oprot.writeFieldEnd()
20870 
    oprot.writeFieldStop()
20871 
    oprot.writeStructEnd()
20872 
 
20873 
  def validate(self):
20874 
    return
20875 
 
20876 
 
20877 
  def __repr__(self):
20878 
    L = ['%s=%r' % (key, value)
20879 
      for key, value in self.__dict__.iteritems()]
20880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20881 
 
20882 
  def __eq__(self, other):
20883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20884 
 
20885 
  def __ne__(self, other):
20886 
    return not (self == other)
20887 
 
20888 
class updateShipmentAddress_result:
20889 
  """
20890 
  Attributes:
20891 
   - ex
20892 
  """
20893 
 
20894 
  thrift_spec = (
20895 
    None, # 0
20896 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20897 
  )
20898 
 
20899 
  def __init__(self, ex=None,):
20900 
    self.ex = ex
20901 
 
20902 
  def read(self, iprot):
20903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20905 
      return
20906 
    iprot.readStructBegin()
20907 
    while True:
20908 
      (fname, ftype, fid) = iprot.readFieldBegin()
20909 
      if ftype == TType.STOP:
20910 
        break
20911 
      if fid == 1:
20912 
        if ftype == TType.STRUCT:
20913 
          self.ex = TransactionServiceException()
20914 
          self.ex.read(iprot)
20915 
        else:
20916 
          iprot.skip(ftype)
20917 
      else:
20918 
        iprot.skip(ftype)
20919 
      iprot.readFieldEnd()
20920 
    iprot.readStructEnd()
20921 
 
20922 
  def write(self, oprot):
20923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20925 
      return
20926 
    oprot.writeStructBegin('updateShipmentAddress_result')
20927 
    if self.ex is not None:
20928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20929 
      self.ex.write(oprot)
20930 
      oprot.writeFieldEnd()
20931 
    oprot.writeFieldStop()
20932 
    oprot.writeStructEnd()
20933 
 
20934 
  def validate(self):
20935 
    return
20936 
 
20937 
 
20938 
  def __repr__(self):
20939 
    L = ['%s=%r' % (key, value)
20940 
      for key, value in self.__dict__.iteritems()]
20941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20942 
 
20943 
  def __eq__(self, other):
20944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20945 
 
20946 
  def __ne__(self, other):
20947 
    return not (self == other)
20948 
 
4285 rajveer 20949 
class acceptOrdersForItemId_args:
20950 
  """
20951 
  Attributes:
20952 
   - itemId
20953 
   - inventory
20954 
  """
20955 
 
20956 
  thrift_spec = (
20957 
    None, # 0
20958 
    (1, TType.I64, 'itemId', None, None, ), # 1
20959 
    (2, TType.I64, 'inventory', None, None, ), # 2
20960 
  )
20961 
 
20962 
  def __init__(self, itemId=None, inventory=None,):
20963 
    self.itemId = itemId
20964 
    self.inventory = inventory
20965 
 
20966 
  def read(self, iprot):
20967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20969 
      return
20970 
    iprot.readStructBegin()
20971 
    while True:
20972 
      (fname, ftype, fid) = iprot.readFieldBegin()
20973 
      if ftype == TType.STOP:
20974 
        break
20975 
      if fid == 1:
20976 
        if ftype == TType.I64:
20977 
          self.itemId = iprot.readI64();
20978 
        else:
20979 
          iprot.skip(ftype)
20980 
      elif fid == 2:
20981 
        if ftype == TType.I64:
20982 
          self.inventory = iprot.readI64();
20983 
        else:
20984 
          iprot.skip(ftype)
20985 
      else:
20986 
        iprot.skip(ftype)
20987 
      iprot.readFieldEnd()
20988 
    iprot.readStructEnd()
20989 
 
20990 
  def write(self, oprot):
20991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20993 
      return
20994 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20995 
    if self.itemId is not None:
20996 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20997 
      oprot.writeI64(self.itemId)
20998 
      oprot.writeFieldEnd()
20999 
    if self.inventory is not None:
21000 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21001 
      oprot.writeI64(self.inventory)
21002 
      oprot.writeFieldEnd()
21003 
    oprot.writeFieldStop()
21004 
    oprot.writeStructEnd()
21005 
 
21006 
  def validate(self):
21007 
    return
21008 
 
21009 
 
21010 
  def __repr__(self):
21011 
    L = ['%s=%r' % (key, value)
21012 
      for key, value in self.__dict__.iteritems()]
21013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21014 
 
21015 
  def __eq__(self, other):
21016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21017 
 
21018 
  def __ne__(self, other):
21019 
    return not (self == other)
21020 
 
21021 
class acceptOrdersForItemId_result:
21022 
  """
21023 
  Attributes:
21024 
   - success
21025 
   - ex
21026 
  """
21027 
 
21028 
  thrift_spec = (
21029 
    (0, TType.BOOL, 'success', None, None, ), # 0
21030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21031 
  )
21032 
 
21033 
  def __init__(self, success=None, ex=None,):
21034 
    self.success = success
21035 
    self.ex = ex
21036 
 
21037 
  def read(self, iprot):
21038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21040 
      return
21041 
    iprot.readStructBegin()
21042 
    while True:
21043 
      (fname, ftype, fid) = iprot.readFieldBegin()
21044 
      if ftype == TType.STOP:
21045 
        break
21046 
      if fid == 0:
21047 
        if ftype == TType.BOOL:
21048 
          self.success = iprot.readBool();
21049 
        else:
21050 
          iprot.skip(ftype)
21051 
      elif fid == 1:
21052 
        if ftype == TType.STRUCT:
21053 
          self.ex = TransactionServiceException()
21054 
          self.ex.read(iprot)
21055 
        else:
21056 
          iprot.skip(ftype)
21057 
      else:
21058 
        iprot.skip(ftype)
21059 
      iprot.readFieldEnd()
21060 
    iprot.readStructEnd()
21061 
 
21062 
  def write(self, oprot):
21063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21065 
      return
21066 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21067 
    if self.success is not None:
21068 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21069 
      oprot.writeBool(self.success)
21070 
      oprot.writeFieldEnd()
21071 
    if self.ex is not None:
21072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21073 
      self.ex.write(oprot)
21074 
      oprot.writeFieldEnd()
21075 
    oprot.writeFieldStop()
21076 
    oprot.writeStructEnd()
21077 
 
21078 
  def validate(self):
21079 
    return
21080 
 
21081 
 
21082 
  def __repr__(self):
21083 
    L = ['%s=%r' % (key, value)
21084 
      for key, value in self.__dict__.iteritems()]
21085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21086 
 
21087 
  def __eq__(self, other):
21088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21089 
 
21090 
  def __ne__(self, other):
21091 
    return not (self == other)
4303 rajveer 21092 
 
21093 
class markOrdersAsPORaised_args:
21094 
  """
21095 
  Attributes:
21096 
   - vendorId
21097 
   - itemId
21098 
   - quantity
21099 
   - estimate
4369 rajveer 21100 
   - isReminder
4303 rajveer 21101 
  """
21102 
 
21103 
  thrift_spec = (
21104 
    None, # 0
21105 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21106 
    (2, TType.I64, 'itemId', None, None, ), # 2
21107 
    (3, TType.I64, 'quantity', None, None, ), # 3
21108 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21109 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21110 
  )
21111 
 
4369 rajveer 21112 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21113 
    self.vendorId = vendorId
21114 
    self.itemId = itemId
21115 
    self.quantity = quantity
21116 
    self.estimate = estimate
4369 rajveer 21117 
    self.isReminder = isReminder
4303 rajveer 21118 
 
21119 
  def read(self, iprot):
21120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21122 
      return
21123 
    iprot.readStructBegin()
21124 
    while True:
21125 
      (fname, ftype, fid) = iprot.readFieldBegin()
21126 
      if ftype == TType.STOP:
21127 
        break
21128 
      if fid == 1:
21129 
        if ftype == TType.I64:
21130 
          self.vendorId = iprot.readI64();
21131 
        else:
21132 
          iprot.skip(ftype)
21133 
      elif fid == 2:
21134 
        if ftype == TType.I64:
21135 
          self.itemId = iprot.readI64();
21136 
        else:
21137 
          iprot.skip(ftype)
21138 
      elif fid == 3:
21139 
        if ftype == TType.I64:
21140 
          self.quantity = iprot.readI64();
21141 
        else:
21142 
          iprot.skip(ftype)
21143 
      elif fid == 4:
21144 
        if ftype == TType.I64:
21145 
          self.estimate = iprot.readI64();
21146 
        else:
21147 
          iprot.skip(ftype)
4369 rajveer 21148 
      elif fid == 5:
21149 
        if ftype == TType.BOOL:
21150 
          self.isReminder = iprot.readBool();
21151 
        else:
21152 
          iprot.skip(ftype)
4303 rajveer 21153 
      else:
21154 
        iprot.skip(ftype)
21155 
      iprot.readFieldEnd()
21156 
    iprot.readStructEnd()
21157 
 
21158 
  def write(self, oprot):
21159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21161 
      return
21162 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21163 
    if self.vendorId is not None:
21164 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21165 
      oprot.writeI64(self.vendorId)
21166 
      oprot.writeFieldEnd()
21167 
    if self.itemId is not None:
21168 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21169 
      oprot.writeI64(self.itemId)
21170 
      oprot.writeFieldEnd()
21171 
    if self.quantity is not None:
21172 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21173 
      oprot.writeI64(self.quantity)
21174 
      oprot.writeFieldEnd()
21175 
    if self.estimate is not None:
21176 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21177 
      oprot.writeI64(self.estimate)
21178 
      oprot.writeFieldEnd()
4369 rajveer 21179 
    if self.isReminder is not None:
21180 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21181 
      oprot.writeBool(self.isReminder)
21182 
      oprot.writeFieldEnd()
4303 rajveer 21183 
    oprot.writeFieldStop()
21184 
    oprot.writeStructEnd()
21185 
 
21186 
  def validate(self):
21187 
    return
21188 
 
21189 
 
21190 
  def __repr__(self):
21191 
    L = ['%s=%r' % (key, value)
21192 
      for key, value in self.__dict__.iteritems()]
21193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21194 
 
21195 
  def __eq__(self, other):
21196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21197 
 
21198 
  def __ne__(self, other):
21199 
    return not (self == other)
21200 
 
21201 
class markOrdersAsPORaised_result:
21202 
  """
21203 
  Attributes:
21204 
   - ex
21205 
  """
21206 
 
21207 
  thrift_spec = (
21208 
    None, # 0
21209 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21210 
  )
21211 
 
21212 
  def __init__(self, ex=None,):
21213 
    self.ex = ex
21214 
 
21215 
  def read(self, iprot):
21216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21218 
      return
21219 
    iprot.readStructBegin()
21220 
    while True:
21221 
      (fname, ftype, fid) = iprot.readFieldBegin()
21222 
      if ftype == TType.STOP:
21223 
        break
21224 
      if fid == 1:
21225 
        if ftype == TType.STRUCT:
21226 
          self.ex = TransactionServiceException()
21227 
          self.ex.read(iprot)
21228 
        else:
21229 
          iprot.skip(ftype)
21230 
      else:
21231 
        iprot.skip(ftype)
21232 
      iprot.readFieldEnd()
21233 
    iprot.readStructEnd()
21234 
 
21235 
  def write(self, oprot):
21236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21238 
      return
21239 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21240 
    if self.ex is not None:
21241 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21242 
      self.ex.write(oprot)
21243 
      oprot.writeFieldEnd()
21244 
    oprot.writeFieldStop()
21245 
    oprot.writeStructEnd()
21246 
 
21247 
  def validate(self):
21248 
    return
21249 
 
21250 
 
21251 
  def __repr__(self):
21252 
    L = ['%s=%r' % (key, value)
21253 
      for key, value in self.__dict__.iteritems()]
21254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21255 
 
21256 
  def __eq__(self, other):
21257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21258 
 
21259 
  def __ne__(self, other):
21260 
    return not (self == other)
21261 
 
21262 
class markOrdersAsReversalInitiated_args:
21263 
  """
21264 
  Attributes:
21265 
   - vendorId
21266 
   - itemId
21267 
   - quantity
21268 
   - estimate
4369 rajveer 21269 
   - isReminder
4303 rajveer 21270 
  """
21271 
 
21272 
  thrift_spec = (
21273 
    None, # 0
21274 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21275 
    (2, TType.I64, 'itemId', None, None, ), # 2
21276 
    (3, TType.I64, 'quantity', None, None, ), # 3
21277 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21278 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21279 
  )
21280 
 
4369 rajveer 21281 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21282 
    self.vendorId = vendorId
21283 
    self.itemId = itemId
21284 
    self.quantity = quantity
21285 
    self.estimate = estimate
4369 rajveer 21286 
    self.isReminder = isReminder
4303 rajveer 21287 
 
21288 
  def read(self, iprot):
21289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21291 
      return
21292 
    iprot.readStructBegin()
21293 
    while True:
21294 
      (fname, ftype, fid) = iprot.readFieldBegin()
21295 
      if ftype == TType.STOP:
21296 
        break
21297 
      if fid == 1:
21298 
        if ftype == TType.I64:
21299 
          self.vendorId = iprot.readI64();
21300 
        else:
21301 
          iprot.skip(ftype)
21302 
      elif fid == 2:
21303 
        if ftype == TType.I64:
21304 
          self.itemId = iprot.readI64();
21305 
        else:
21306 
          iprot.skip(ftype)
21307 
      elif fid == 3:
21308 
        if ftype == TType.I64:
21309 
          self.quantity = iprot.readI64();
21310 
        else:
21311 
          iprot.skip(ftype)
21312 
      elif fid == 4:
21313 
        if ftype == TType.I64:
21314 
          self.estimate = iprot.readI64();
21315 
        else:
21316 
          iprot.skip(ftype)
4369 rajveer 21317 
      elif fid == 5:
21318 
        if ftype == TType.BOOL:
21319 
          self.isReminder = iprot.readBool();
21320 
        else:
21321 
          iprot.skip(ftype)
4303 rajveer 21322 
      else:
21323 
        iprot.skip(ftype)
21324 
      iprot.readFieldEnd()
21325 
    iprot.readStructEnd()
21326 
 
21327 
  def write(self, oprot):
21328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21330 
      return
21331 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21332 
    if self.vendorId is not None:
21333 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21334 
      oprot.writeI64(self.vendorId)
21335 
      oprot.writeFieldEnd()
21336 
    if self.itemId is not None:
21337 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21338 
      oprot.writeI64(self.itemId)
21339 
      oprot.writeFieldEnd()
21340 
    if self.quantity is not None:
21341 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21342 
      oprot.writeI64(self.quantity)
21343 
      oprot.writeFieldEnd()
21344 
    if self.estimate is not None:
21345 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21346 
      oprot.writeI64(self.estimate)
21347 
      oprot.writeFieldEnd()
4369 rajveer 21348 
    if self.isReminder is not None:
21349 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21350 
      oprot.writeBool(self.isReminder)
21351 
      oprot.writeFieldEnd()
4303 rajveer 21352 
    oprot.writeFieldStop()
21353 
    oprot.writeStructEnd()
21354 
 
21355 
  def validate(self):
21356 
    return
21357 
 
21358 
 
21359 
  def __repr__(self):
21360 
    L = ['%s=%r' % (key, value)
21361 
      for key, value in self.__dict__.iteritems()]
21362 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21363 
 
21364 
  def __eq__(self, other):
21365 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21366 
 
21367 
  def __ne__(self, other):
21368 
    return not (self == other)
21369 
 
21370 
class markOrdersAsReversalInitiated_result:
21371 
  """
21372 
  Attributes:
21373 
   - ex
21374 
  """
21375 
 
21376 
  thrift_spec = (
21377 
    None, # 0
21378 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21379 
  )
21380 
 
21381 
  def __init__(self, ex=None,):
21382 
    self.ex = ex
21383 
 
21384 
  def read(self, iprot):
21385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21387 
      return
21388 
    iprot.readStructBegin()
21389 
    while True:
21390 
      (fname, ftype, fid) = iprot.readFieldBegin()
21391 
      if ftype == TType.STOP:
21392 
        break
21393 
      if fid == 1:
21394 
        if ftype == TType.STRUCT:
21395 
          self.ex = TransactionServiceException()
21396 
          self.ex.read(iprot)
21397 
        else:
21398 
          iprot.skip(ftype)
21399 
      else:
21400 
        iprot.skip(ftype)
21401 
      iprot.readFieldEnd()
21402 
    iprot.readStructEnd()
21403 
 
21404 
  def write(self, oprot):
21405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21407 
      return
21408 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21409 
    if self.ex is not None:
21410 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21411 
      self.ex.write(oprot)
21412 
      oprot.writeFieldEnd()
21413 
    oprot.writeFieldStop()
21414 
    oprot.writeStructEnd()
21415 
 
21416 
  def validate(self):
21417 
    return
21418 
 
21419 
 
21420 
  def __repr__(self):
21421 
    L = ['%s=%r' % (key, value)
21422 
      for key, value in self.__dict__.iteritems()]
21423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21424 
 
21425 
  def __eq__(self, other):
21426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21427 
 
21428 
  def __ne__(self, other):
21429 
    return not (self == other)
21430 
 
21431 
class markOrdersAsNotAvailabke_args:
21432 
  """
21433 
  Attributes:
21434 
   - vendorId
21435 
   - itemId
21436 
   - quantity
21437 
   - estimate
4369 rajveer 21438 
   - isReminder
4303 rajveer 21439 
  """
21440 
 
21441 
  thrift_spec = (
21442 
    None, # 0
21443 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21444 
    (2, TType.I64, 'itemId', None, None, ), # 2
21445 
    (3, TType.I64, 'quantity', None, None, ), # 3
21446 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21447 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21448 
  )
21449 
 
4369 rajveer 21450 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21451 
    self.vendorId = vendorId
21452 
    self.itemId = itemId
21453 
    self.quantity = quantity
21454 
    self.estimate = estimate
4369 rajveer 21455 
    self.isReminder = isReminder
4303 rajveer 21456 
 
21457 
  def read(self, iprot):
21458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21460 
      return
21461 
    iprot.readStructBegin()
21462 
    while True:
21463 
      (fname, ftype, fid) = iprot.readFieldBegin()
21464 
      if ftype == TType.STOP:
21465 
        break
21466 
      if fid == 1:
21467 
        if ftype == TType.I64:
21468 
          self.vendorId = iprot.readI64();
21469 
        else:
21470 
          iprot.skip(ftype)
21471 
      elif fid == 2:
21472 
        if ftype == TType.I64:
21473 
          self.itemId = iprot.readI64();
21474 
        else:
21475 
          iprot.skip(ftype)
21476 
      elif fid == 3:
21477 
        if ftype == TType.I64:
21478 
          self.quantity = iprot.readI64();
21479 
        else:
21480 
          iprot.skip(ftype)
21481 
      elif fid == 4:
21482 
        if ftype == TType.I64:
21483 
          self.estimate = iprot.readI64();
21484 
        else:
21485 
          iprot.skip(ftype)
4369 rajveer 21486 
      elif fid == 5:
21487 
        if ftype == TType.BOOL:
21488 
          self.isReminder = iprot.readBool();
21489 
        else:
21490 
          iprot.skip(ftype)
4303 rajveer 21491 
      else:
21492 
        iprot.skip(ftype)
21493 
      iprot.readFieldEnd()
21494 
    iprot.readStructEnd()
21495 
 
21496 
  def write(self, oprot):
21497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21499 
      return
21500 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21501 
    if self.vendorId is not None:
21502 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21503 
      oprot.writeI64(self.vendorId)
21504 
      oprot.writeFieldEnd()
21505 
    if self.itemId is not None:
21506 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21507 
      oprot.writeI64(self.itemId)
21508 
      oprot.writeFieldEnd()
21509 
    if self.quantity is not None:
21510 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21511 
      oprot.writeI64(self.quantity)
21512 
      oprot.writeFieldEnd()
21513 
    if self.estimate is not None:
21514 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21515 
      oprot.writeI64(self.estimate)
21516 
      oprot.writeFieldEnd()
4369 rajveer 21517 
    if self.isReminder is not None:
21518 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21519 
      oprot.writeBool(self.isReminder)
21520 
      oprot.writeFieldEnd()
4303 rajveer 21521 
    oprot.writeFieldStop()
21522 
    oprot.writeStructEnd()
21523 
 
21524 
  def validate(self):
21525 
    return
21526 
 
21527 
 
21528 
  def __repr__(self):
21529 
    L = ['%s=%r' % (key, value)
21530 
      for key, value in self.__dict__.iteritems()]
21531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21532 
 
21533 
  def __eq__(self, other):
21534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21535 
 
21536 
  def __ne__(self, other):
21537 
    return not (self == other)
21538 
 
21539 
class markOrdersAsNotAvailabke_result:
21540 
  """
21541 
  Attributes:
21542 
   - ex
21543 
  """
21544 
 
21545 
  thrift_spec = (
21546 
    None, # 0
21547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21548 
  )
21549 
 
21550 
  def __init__(self, ex=None,):
21551 
    self.ex = ex
21552 
 
21553 
  def read(self, iprot):
21554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21556 
      return
21557 
    iprot.readStructBegin()
21558 
    while True:
21559 
      (fname, ftype, fid) = iprot.readFieldBegin()
21560 
      if ftype == TType.STOP:
21561 
        break
21562 
      if fid == 1:
21563 
        if ftype == TType.STRUCT:
21564 
          self.ex = TransactionServiceException()
21565 
          self.ex.read(iprot)
21566 
        else:
21567 
          iprot.skip(ftype)
21568 
      else:
21569 
        iprot.skip(ftype)
21570 
      iprot.readFieldEnd()
21571 
    iprot.readStructEnd()
21572 
 
21573 
  def write(self, oprot):
21574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21576 
      return
21577 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21578 
    if self.ex is not None:
21579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21580 
      self.ex.write(oprot)
21581 
      oprot.writeFieldEnd()
21582 
    oprot.writeFieldStop()
21583 
    oprot.writeStructEnd()
21584 
 
21585 
  def validate(self):
21586 
    return
21587 
 
21588 
 
21589 
  def __repr__(self):
21590 
    L = ['%s=%r' % (key, value)
21591 
      for key, value in self.__dict__.iteritems()]
21592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21593 
 
21594 
  def __eq__(self, other):
21595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21596 
 
21597 
  def __ne__(self, other):
21598 
    return not (self == other)
4369 rajveer 21599 
 
21600 
class markOrdersAsTimeout_args:
21601 
  """
21602 
  Attributes:
21603 
   - vendorId
21604 
  """
21605 
 
21606 
  thrift_spec = (
21607 
    None, # 0
21608 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21609 
  )
21610 
 
21611 
  def __init__(self, vendorId=None,):
21612 
    self.vendorId = vendorId
21613 
 
21614 
  def read(self, iprot):
21615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21617 
      return
21618 
    iprot.readStructBegin()
21619 
    while True:
21620 
      (fname, ftype, fid) = iprot.readFieldBegin()
21621 
      if ftype == TType.STOP:
21622 
        break
21623 
      if fid == 1:
21624 
        if ftype == TType.I64:
21625 
          self.vendorId = iprot.readI64();
21626 
        else:
21627 
          iprot.skip(ftype)
21628 
      else:
21629 
        iprot.skip(ftype)
21630 
      iprot.readFieldEnd()
21631 
    iprot.readStructEnd()
21632 
 
21633 
  def write(self, oprot):
21634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21636 
      return
21637 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21638 
    if self.vendorId is not None:
21639 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21640 
      oprot.writeI64(self.vendorId)
21641 
      oprot.writeFieldEnd()
21642 
    oprot.writeFieldStop()
21643 
    oprot.writeStructEnd()
21644 
 
21645 
  def validate(self):
21646 
    return
21647 
 
21648 
 
21649 
  def __repr__(self):
21650 
    L = ['%s=%r' % (key, value)
21651 
      for key, value in self.__dict__.iteritems()]
21652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21653 
 
21654 
  def __eq__(self, other):
21655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21656 
 
21657 
  def __ne__(self, other):
21658 
    return not (self == other)
21659 
 
21660 
class markOrdersAsTimeout_result:
21661 
  """
21662 
  Attributes:
21663 
   - success
21664 
   - ex
21665 
  """
21666 
 
21667 
  thrift_spec = (
21668 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21669 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21670 
  )
21671 
 
21672 
  def __init__(self, success=None, ex=None,):
21673 
    self.success = success
21674 
    self.ex = ex
21675 
 
21676 
  def read(self, iprot):
21677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21679 
      return
21680 
    iprot.readStructBegin()
21681 
    while True:
21682 
      (fname, ftype, fid) = iprot.readFieldBegin()
21683 
      if ftype == TType.STOP:
21684 
        break
21685 
      if fid == 0:
21686 
        if ftype == TType.MAP:
21687 
          self.success = {}
6188 rajveer 21688 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21689 
          for _i505 in xrange(_size501):
21690 
            _key506 = iprot.readI32();
21691 
            _val507 = TimeoutSummary()
21692 
            _val507.read(iprot)
21693 
            self.success[_key506] = _val507
4369 rajveer 21694 
          iprot.readMapEnd()
21695 
        else:
21696 
          iprot.skip(ftype)
21697 
      elif fid == 1:
21698 
        if ftype == TType.STRUCT:
21699 
          self.ex = TransactionServiceException()
21700 
          self.ex.read(iprot)
21701 
        else:
21702 
          iprot.skip(ftype)
21703 
      else:
21704 
        iprot.skip(ftype)
21705 
      iprot.readFieldEnd()
21706 
    iprot.readStructEnd()
21707 
 
21708 
  def write(self, oprot):
21709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21711 
      return
21712 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21713 
    if self.success is not None:
21714 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21715 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21716 
      for kiter508,viter509 in self.success.items():
21717 
        oprot.writeI32(kiter508)
21718 
        viter509.write(oprot)
4369 rajveer 21719 
      oprot.writeMapEnd()
21720 
      oprot.writeFieldEnd()
21721 
    if self.ex is not None:
21722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21723 
      self.ex.write(oprot)
21724 
      oprot.writeFieldEnd()
21725 
    oprot.writeFieldStop()
21726 
    oprot.writeStructEnd()
21727 
 
21728 
  def validate(self):
21729 
    return
21730 
 
21731 
 
21732 
  def __repr__(self):
21733 
    L = ['%s=%r' % (key, value)
21734 
      for key, value in self.__dict__.iteritems()]
21735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21736 
 
21737 
  def __eq__(self, other):
21738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21739 
 
21740 
  def __ne__(self, other):
21741 
    return not (self == other)
4386 anupam.sin 21742 
 
4662 rajveer 21743 
class markOrderAsLostInTransit_args:
21744 
  """
21745 
  Attributes:
21746 
   - orderId
21747 
  """
21748 
 
21749 
  thrift_spec = (
21750 
    None, # 0
21751 
    (1, TType.I64, 'orderId', None, None, ), # 1
21752 
  )
21753 
 
21754 
  def __init__(self, orderId=None,):
21755 
    self.orderId = orderId
21756 
 
21757 
  def read(self, iprot):
21758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21760 
      return
21761 
    iprot.readStructBegin()
21762 
    while True:
21763 
      (fname, ftype, fid) = iprot.readFieldBegin()
21764 
      if ftype == TType.STOP:
21765 
        break
21766 
      if fid == 1:
21767 
        if ftype == TType.I64:
21768 
          self.orderId = iprot.readI64();
21769 
        else:
21770 
          iprot.skip(ftype)
21771 
      else:
21772 
        iprot.skip(ftype)
21773 
      iprot.readFieldEnd()
21774 
    iprot.readStructEnd()
21775 
 
21776 
  def write(self, oprot):
21777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21779 
      return
21780 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21781 
    if self.orderId is not None:
21782 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21783 
      oprot.writeI64(self.orderId)
21784 
      oprot.writeFieldEnd()
21785 
    oprot.writeFieldStop()
21786 
    oprot.writeStructEnd()
21787 
 
21788 
  def validate(self):
21789 
    return
21790 
 
21791 
 
21792 
  def __repr__(self):
21793 
    L = ['%s=%r' % (key, value)
21794 
      for key, value in self.__dict__.iteritems()]
21795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21796 
 
21797 
  def __eq__(self, other):
21798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21799 
 
21800 
  def __ne__(self, other):
21801 
    return not (self == other)
21802 
 
21803 
class markOrderAsLostInTransit_result:
21804 
  """
21805 
  Attributes:
21806 
   - success
21807 
   - ex
21808 
  """
21809 
 
21810 
  thrift_spec = (
21811 
    (0, TType.BOOL, 'success', None, None, ), # 0
21812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21813 
  )
21814 
 
21815 
  def __init__(self, success=None, ex=None,):
21816 
    self.success = success
21817 
    self.ex = ex
21818 
 
21819 
  def read(self, iprot):
21820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21822 
      return
21823 
    iprot.readStructBegin()
21824 
    while True:
21825 
      (fname, ftype, fid) = iprot.readFieldBegin()
21826 
      if ftype == TType.STOP:
21827 
        break
21828 
      if fid == 0:
21829 
        if ftype == TType.BOOL:
21830 
          self.success = iprot.readBool();
21831 
        else:
21832 
          iprot.skip(ftype)
21833 
      elif fid == 1:
21834 
        if ftype == TType.STRUCT:
21835 
          self.ex = TransactionServiceException()
21836 
          self.ex.read(iprot)
21837 
        else:
21838 
          iprot.skip(ftype)
21839 
      else:
21840 
        iprot.skip(ftype)
21841 
      iprot.readFieldEnd()
21842 
    iprot.readStructEnd()
21843 
 
21844 
  def write(self, oprot):
21845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21847 
      return
21848 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21849 
    if self.success is not None:
21850 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21851 
      oprot.writeBool(self.success)
21852 
      oprot.writeFieldEnd()
21853 
    if self.ex is not None:
21854 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21855 
      self.ex.write(oprot)
21856 
      oprot.writeFieldEnd()
21857 
    oprot.writeFieldStop()
21858 
    oprot.writeStructEnd()
21859 
 
21860 
  def validate(self):
21861 
    return
21862 
 
21863 
 
21864 
  def __repr__(self):
21865 
    L = ['%s=%r' % (key, value)
21866 
      for key, value in self.__dict__.iteritems()]
21867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21868 
 
21869 
  def __eq__(self, other):
21870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21871 
 
21872 
  def __ne__(self, other):
21873 
    return not (self == other)
21874 
 
4386 anupam.sin 21875 
class getOrderForAwb_args:
21876 
  """
21877 
  Attributes:
21878 
   - awb
21879 
  """
21880 
 
21881 
  thrift_spec = (
21882 
    None, # 0
21883 
    (1, TType.STRING, 'awb', None, None, ), # 1
21884 
  )
21885 
 
21886 
  def __init__(self, awb=None,):
21887 
    self.awb = awb
21888 
 
21889 
  def read(self, iprot):
21890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21892 
      return
21893 
    iprot.readStructBegin()
21894 
    while True:
21895 
      (fname, ftype, fid) = iprot.readFieldBegin()
21896 
      if ftype == TType.STOP:
21897 
        break
21898 
      if fid == 1:
21899 
        if ftype == TType.STRING:
21900 
          self.awb = iprot.readString();
21901 
        else:
21902 
          iprot.skip(ftype)
21903 
      else:
21904 
        iprot.skip(ftype)
21905 
      iprot.readFieldEnd()
21906 
    iprot.readStructEnd()
21907 
 
21908 
  def write(self, oprot):
21909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21911 
      return
21912 
    oprot.writeStructBegin('getOrderForAwb_args')
21913 
    if self.awb is not None:
21914 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21915 
      oprot.writeString(self.awb)
21916 
      oprot.writeFieldEnd()
21917 
    oprot.writeFieldStop()
21918 
    oprot.writeStructEnd()
21919 
 
21920 
  def validate(self):
21921 
    return
21922 
 
21923 
 
21924 
  def __repr__(self):
21925 
    L = ['%s=%r' % (key, value)
21926 
      for key, value in self.__dict__.iteritems()]
21927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21928 
 
21929 
  def __eq__(self, other):
21930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21931 
 
21932 
  def __ne__(self, other):
21933 
    return not (self == other)
21934 
 
21935 
class getOrderForAwb_result:
21936 
  """
21937 
  Attributes:
21938 
   - success
21939 
   - ex
21940 
  """
21941 
 
21942 
  thrift_spec = (
21943 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21944 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21945 
  )
21946 
 
21947 
  def __init__(self, success=None, ex=None,):
21948 
    self.success = success
21949 
    self.ex = ex
21950 
 
21951 
  def read(self, iprot):
21952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21954 
      return
21955 
    iprot.readStructBegin()
21956 
    while True:
21957 
      (fname, ftype, fid) = iprot.readFieldBegin()
21958 
      if ftype == TType.STOP:
21959 
        break
21960 
      if fid == 0:
21961 
        if ftype == TType.STRUCT:
21962 
          self.success = Order()
21963 
          self.success.read(iprot)
21964 
        else:
21965 
          iprot.skip(ftype)
21966 
      elif fid == 1:
21967 
        if ftype == TType.STRUCT:
21968 
          self.ex = TransactionServiceException()
21969 
          self.ex.read(iprot)
21970 
        else:
21971 
          iprot.skip(ftype)
21972 
      else:
21973 
        iprot.skip(ftype)
21974 
      iprot.readFieldEnd()
21975 
    iprot.readStructEnd()
21976 
 
21977 
  def write(self, oprot):
21978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21980 
      return
21981 
    oprot.writeStructBegin('getOrderForAwb_result')
21982 
    if self.success is not None:
21983 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21984 
      self.success.write(oprot)
21985 
      oprot.writeFieldEnd()
21986 
    if self.ex is not None:
21987 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21988 
      self.ex.write(oprot)
21989 
      oprot.writeFieldEnd()
21990 
    oprot.writeFieldStop()
21991 
    oprot.writeStructEnd()
21992 
 
21993 
  def validate(self):
21994 
    return
21995 
 
21996 
 
21997 
  def __repr__(self):
21998 
    L = ['%s=%r' % (key, value)
21999 
      for key, value in self.__dict__.iteritems()]
22000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22001 
 
22002 
  def __eq__(self, other):
22003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22004 
 
22005 
  def __ne__(self, other):
22006 
    return not (self == other)
4506 phani.kuma 22007 
 
22008 
class getOrdersForProviderForStatus_args:
22009 
  """
22010 
  Attributes:
22011 
   - logistics_provider_id
4910 phani.kuma 22012 
   - order_status_list
4506 phani.kuma 22013 
  """
22014 
 
22015 
  thrift_spec = (
22016 
    None, # 0
22017 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22018 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22019 
  )
22020 
 
4910 phani.kuma 22021 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22022 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22023 
    self.order_status_list = order_status_list
4506 phani.kuma 22024 
 
22025 
  def read(self, iprot):
22026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22028 
      return
22029 
    iprot.readStructBegin()
22030 
    while True:
22031 
      (fname, ftype, fid) = iprot.readFieldBegin()
22032 
      if ftype == TType.STOP:
22033 
        break
22034 
      if fid == 1:
22035 
        if ftype == TType.I64:
22036 
          self.logistics_provider_id = iprot.readI64();
22037 
        else:
22038 
          iprot.skip(ftype)
22039 
      elif fid == 2:
4910 phani.kuma 22040 
        if ftype == TType.LIST:
22041 
          self.order_status_list = []
6188 rajveer 22042 
          (_etype513, _size510) = iprot.readListBegin()
22043 
          for _i514 in xrange(_size510):
22044 
            _elem515 = iprot.readI32();
22045 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22046 
          iprot.readListEnd()
4506 phani.kuma 22047 
        else:
22048 
          iprot.skip(ftype)
22049 
      else:
22050 
        iprot.skip(ftype)
22051 
      iprot.readFieldEnd()
22052 
    iprot.readStructEnd()
22053 
 
22054 
  def write(self, oprot):
22055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22057 
      return
22058 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22059 
    if self.logistics_provider_id is not None:
22060 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22061 
      oprot.writeI64(self.logistics_provider_id)
22062 
      oprot.writeFieldEnd()
4910 phani.kuma 22063 
    if self.order_status_list is not None:
22064 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22065 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22066 
      for iter516 in self.order_status_list:
22067 
        oprot.writeI32(iter516)
4910 phani.kuma 22068 
      oprot.writeListEnd()
4506 phani.kuma 22069 
      oprot.writeFieldEnd()
22070 
    oprot.writeFieldStop()
22071 
    oprot.writeStructEnd()
22072 
 
22073 
  def validate(self):
22074 
    return
22075 
 
22076 
 
22077 
  def __repr__(self):
22078 
    L = ['%s=%r' % (key, value)
22079 
      for key, value in self.__dict__.iteritems()]
22080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22081 
 
22082 
  def __eq__(self, other):
22083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22084 
 
22085 
  def __ne__(self, other):
22086 
    return not (self == other)
22087 
 
22088 
class getOrdersForProviderForStatus_result:
22089 
  """
22090 
  Attributes:
22091 
   - success
22092 
   - ex
22093 
  """
22094 
 
22095 
  thrift_spec = (
22096 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22098 
  )
22099 
 
22100 
  def __init__(self, success=None, ex=None,):
22101 
    self.success = success
22102 
    self.ex = ex
22103 
 
22104 
  def read(self, iprot):
22105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22107 
      return
22108 
    iprot.readStructBegin()
22109 
    while True:
22110 
      (fname, ftype, fid) = iprot.readFieldBegin()
22111 
      if ftype == TType.STOP:
22112 
        break
22113 
      if fid == 0:
22114 
        if ftype == TType.LIST:
22115 
          self.success = []
6188 rajveer 22116 
          (_etype520, _size517) = iprot.readListBegin()
22117 
          for _i521 in xrange(_size517):
22118 
            _elem522 = Order()
22119 
            _elem522.read(iprot)
22120 
            self.success.append(_elem522)
4506 phani.kuma 22121 
          iprot.readListEnd()
22122 
        else:
22123 
          iprot.skip(ftype)
22124 
      elif fid == 1:
22125 
        if ftype == TType.STRUCT:
22126 
          self.ex = TransactionServiceException()
22127 
          self.ex.read(iprot)
22128 
        else:
22129 
          iprot.skip(ftype)
22130 
      else:
22131 
        iprot.skip(ftype)
22132 
      iprot.readFieldEnd()
22133 
    iprot.readStructEnd()
22134 
 
22135 
  def write(self, oprot):
22136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22138 
      return
22139 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22140 
    if self.success is not None:
22141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22143 
      for iter523 in self.success:
22144 
        iter523.write(oprot)
4506 phani.kuma 22145 
      oprot.writeListEnd()
22146 
      oprot.writeFieldEnd()
22147 
    if self.ex is not None:
22148 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22149 
      self.ex.write(oprot)
22150 
      oprot.writeFieldEnd()
22151 
    oprot.writeFieldStop()
22152 
    oprot.writeStructEnd()
22153 
 
22154 
  def validate(self):
22155 
    return
22156 
 
22157 
 
22158 
  def __repr__(self):
22159 
    L = ['%s=%r' % (key, value)
22160 
      for key, value in self.__dict__.iteritems()]
22161 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22162 
 
22163 
  def __eq__(self, other):
22164 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22165 
 
22166 
  def __ne__(self, other):
22167 
    return not (self == other)
4600 varun.gupt 22168 
 
22169 
class getBilledOrdersForVendor_args:
22170 
  """
22171 
  Attributes:
22172 
   - vendorId
22173 
   - billingDateFrom
22174 
   - billingDateTo
22175 
  """
22176 
 
22177 
  thrift_spec = (
22178 
    None, # 0
22179 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22180 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22181 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22182 
  )
22183 
 
22184 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22185 
    self.vendorId = vendorId
22186 
    self.billingDateFrom = billingDateFrom
22187 
    self.billingDateTo = billingDateTo
22188 
 
22189 
  def read(self, iprot):
22190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22192 
      return
22193 
    iprot.readStructBegin()
22194 
    while True:
22195 
      (fname, ftype, fid) = iprot.readFieldBegin()
22196 
      if ftype == TType.STOP:
22197 
        break
22198 
      if fid == 1:
22199 
        if ftype == TType.I64:
22200 
          self.vendorId = iprot.readI64();
22201 
        else:
22202 
          iprot.skip(ftype)
22203 
      elif fid == 2:
22204 
        if ftype == TType.I64:
22205 
          self.billingDateFrom = iprot.readI64();
22206 
        else:
22207 
          iprot.skip(ftype)
22208 
      elif fid == 3:
22209 
        if ftype == TType.I64:
22210 
          self.billingDateTo = iprot.readI64();
22211 
        else:
22212 
          iprot.skip(ftype)
22213 
      else:
22214 
        iprot.skip(ftype)
22215 
      iprot.readFieldEnd()
22216 
    iprot.readStructEnd()
22217 
 
22218 
  def write(self, oprot):
22219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22221 
      return
22222 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22223 
    if self.vendorId is not None:
22224 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22225 
      oprot.writeI64(self.vendorId)
22226 
      oprot.writeFieldEnd()
22227 
    if self.billingDateFrom is not None:
22228 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22229 
      oprot.writeI64(self.billingDateFrom)
22230 
      oprot.writeFieldEnd()
22231 
    if self.billingDateTo is not None:
22232 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22233 
      oprot.writeI64(self.billingDateTo)
22234 
      oprot.writeFieldEnd()
22235 
    oprot.writeFieldStop()
22236 
    oprot.writeStructEnd()
22237 
 
22238 
  def validate(self):
22239 
    return
22240 
 
22241 
 
22242 
  def __repr__(self):
22243 
    L = ['%s=%r' % (key, value)
22244 
      for key, value in self.__dict__.iteritems()]
22245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22246 
 
22247 
  def __eq__(self, other):
22248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22249 
 
22250 
  def __ne__(self, other):
22251 
    return not (self == other)
22252 
 
22253 
class getBilledOrdersForVendor_result:
22254 
  """
22255 
  Attributes:
22256 
   - success
22257 
   - ex
22258 
  """
22259 
 
22260 
  thrift_spec = (
22261 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22263 
  )
22264 
 
22265 
  def __init__(self, success=None, ex=None,):
22266 
    self.success = success
22267 
    self.ex = ex
22268 
 
22269 
  def read(self, iprot):
22270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22272 
      return
22273 
    iprot.readStructBegin()
22274 
    while True:
22275 
      (fname, ftype, fid) = iprot.readFieldBegin()
22276 
      if ftype == TType.STOP:
22277 
        break
22278 
      if fid == 0:
22279 
        if ftype == TType.LIST:
22280 
          self.success = []
6188 rajveer 22281 
          (_etype527, _size524) = iprot.readListBegin()
22282 
          for _i528 in xrange(_size524):
22283 
            _elem529 = Order()
22284 
            _elem529.read(iprot)
22285 
            self.success.append(_elem529)
4600 varun.gupt 22286 
          iprot.readListEnd()
22287 
        else:
22288 
          iprot.skip(ftype)
22289 
      elif fid == 1:
22290 
        if ftype == TType.STRUCT:
22291 
          self.ex = TransactionServiceException()
22292 
          self.ex.read(iprot)
22293 
        else:
22294 
          iprot.skip(ftype)
22295 
      else:
22296 
        iprot.skip(ftype)
22297 
      iprot.readFieldEnd()
22298 
    iprot.readStructEnd()
22299 
 
22300 
  def write(self, oprot):
22301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22303 
      return
22304 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22305 
    if self.success is not None:
22306 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22307 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22308 
      for iter530 in self.success:
22309 
        iter530.write(oprot)
4600 varun.gupt 22310 
      oprot.writeListEnd()
22311 
      oprot.writeFieldEnd()
22312 
    if self.ex is not None:
22313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22314 
      self.ex.write(oprot)
22315 
      oprot.writeFieldEnd()
22316 
    oprot.writeFieldStop()
22317 
    oprot.writeStructEnd()
22318 
 
22319 
  def validate(self):
22320 
    return
22321 
 
22322 
 
22323 
  def __repr__(self):
22324 
    L = ['%s=%r' % (key, value)
22325 
      for key, value in self.__dict__.iteritems()]
22326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22327 
 
22328 
  def __eq__(self, other):
22329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22330 
 
22331 
  def __ne__(self, other):
22332 
    return not (self == other)
22333 
 
4607 rajveer 22334 
class getSlippedSippingDateOrders_args:
22335 
 
22336 
  thrift_spec = (
22337 
  )
22338 
 
22339 
  def read(self, iprot):
22340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22342 
      return
22343 
    iprot.readStructBegin()
22344 
    while True:
22345 
      (fname, ftype, fid) = iprot.readFieldBegin()
22346 
      if ftype == TType.STOP:
22347 
        break
22348 
      else:
22349 
        iprot.skip(ftype)
22350 
      iprot.readFieldEnd()
22351 
    iprot.readStructEnd()
22352 
 
22353 
  def write(self, oprot):
22354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22356 
      return
22357 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22358 
    oprot.writeFieldStop()
22359 
    oprot.writeStructEnd()
22360 
 
22361 
  def validate(self):
22362 
    return
22363 
 
22364 
 
22365 
  def __repr__(self):
22366 
    L = ['%s=%r' % (key, value)
22367 
      for key, value in self.__dict__.iteritems()]
22368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22369 
 
22370 
  def __eq__(self, other):
22371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22372 
 
22373 
  def __ne__(self, other):
22374 
    return not (self == other)
22375 
 
22376 
class getSlippedSippingDateOrders_result:
22377 
  """
22378 
  Attributes:
22379 
   - success
22380 
   - ex
22381 
  """
22382 
 
22383 
  thrift_spec = (
22384 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22385 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22386 
  )
22387 
 
22388 
  def __init__(self, success=None, ex=None,):
22389 
    self.success = success
22390 
    self.ex = ex
22391 
 
22392 
  def read(self, iprot):
22393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22395 
      return
22396 
    iprot.readStructBegin()
22397 
    while True:
22398 
      (fname, ftype, fid) = iprot.readFieldBegin()
22399 
      if ftype == TType.STOP:
22400 
        break
22401 
      if fid == 0:
22402 
        if ftype == TType.LIST:
22403 
          self.success = []
6188 rajveer 22404 
          (_etype534, _size531) = iprot.readListBegin()
22405 
          for _i535 in xrange(_size531):
22406 
            _elem536 = Order()
22407 
            _elem536.read(iprot)
22408 
            self.success.append(_elem536)
4607 rajveer 22409 
          iprot.readListEnd()
22410 
        else:
22411 
          iprot.skip(ftype)
22412 
      elif fid == 1:
22413 
        if ftype == TType.STRUCT:
22414 
          self.ex = TransactionServiceException()
22415 
          self.ex.read(iprot)
22416 
        else:
22417 
          iprot.skip(ftype)
22418 
      else:
22419 
        iprot.skip(ftype)
22420 
      iprot.readFieldEnd()
22421 
    iprot.readStructEnd()
22422 
 
22423 
  def write(self, oprot):
22424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22426 
      return
22427 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22428 
    if self.success is not None:
22429 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22430 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22431 
      for iter537 in self.success:
22432 
        iter537.write(oprot)
4607 rajveer 22433 
      oprot.writeListEnd()
22434 
      oprot.writeFieldEnd()
22435 
    if self.ex is not None:
22436 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22437 
      self.ex.write(oprot)
22438 
      oprot.writeFieldEnd()
22439 
    oprot.writeFieldStop()
22440 
    oprot.writeStructEnd()
22441 
 
22442 
  def validate(self):
22443 
    return
22444 
 
22445 
 
22446 
  def __repr__(self):
22447 
    L = ['%s=%r' % (key, value)
22448 
      for key, value in self.__dict__.iteritems()]
22449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22450 
 
22451 
  def __eq__(self, other):
22452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22453 
 
22454 
  def __ne__(self, other):
22455 
    return not (self == other)
22456 
 
4709 rajveer 22457 
class getCancelledOrders_args:
22458 
  """
22459 
  Attributes:
22460 
   - cancelDateFrom
22461 
   - cancelDateTo
22462 
  """
22463 
 
22464 
  thrift_spec = (
22465 
    None, # 0
22466 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22467 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22468 
  )
22469 
 
22470 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22471 
    self.cancelDateFrom = cancelDateFrom
22472 
    self.cancelDateTo = cancelDateTo
22473 
 
22474 
  def read(self, iprot):
22475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22477 
      return
22478 
    iprot.readStructBegin()
22479 
    while True:
22480 
      (fname, ftype, fid) = iprot.readFieldBegin()
22481 
      if ftype == TType.STOP:
22482 
        break
22483 
      if fid == 1:
22484 
        if ftype == TType.I64:
22485 
          self.cancelDateFrom = iprot.readI64();
22486 
        else:
22487 
          iprot.skip(ftype)
22488 
      elif fid == 2:
22489 
        if ftype == TType.I64:
22490 
          self.cancelDateTo = iprot.readI64();
22491 
        else:
22492 
          iprot.skip(ftype)
22493 
      else:
22494 
        iprot.skip(ftype)
22495 
      iprot.readFieldEnd()
22496 
    iprot.readStructEnd()
22497 
 
22498 
  def write(self, oprot):
22499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22501 
      return
22502 
    oprot.writeStructBegin('getCancelledOrders_args')
22503 
    if self.cancelDateFrom is not None:
22504 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22505 
      oprot.writeI64(self.cancelDateFrom)
22506 
      oprot.writeFieldEnd()
22507 
    if self.cancelDateTo is not None:
22508 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22509 
      oprot.writeI64(self.cancelDateTo)
22510 
      oprot.writeFieldEnd()
22511 
    oprot.writeFieldStop()
22512 
    oprot.writeStructEnd()
22513 
 
22514 
  def validate(self):
22515 
    return
22516 
 
22517 
 
22518 
  def __repr__(self):
22519 
    L = ['%s=%r' % (key, value)
22520 
      for key, value in self.__dict__.iteritems()]
22521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22522 
 
22523 
  def __eq__(self, other):
22524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22525 
 
22526 
  def __ne__(self, other):
22527 
    return not (self == other)
22528 
 
22529 
class getCancelledOrders_result:
22530 
  """
22531 
  Attributes:
22532 
   - success
22533 
   - ex
22534 
  """
22535 
 
22536 
  thrift_spec = (
22537 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22538 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22539 
  )
22540 
 
22541 
  def __init__(self, success=None, ex=None,):
22542 
    self.success = success
22543 
    self.ex = ex
22544 
 
22545 
  def read(self, iprot):
22546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22548 
      return
22549 
    iprot.readStructBegin()
22550 
    while True:
22551 
      (fname, ftype, fid) = iprot.readFieldBegin()
22552 
      if ftype == TType.STOP:
22553 
        break
22554 
      if fid == 0:
22555 
        if ftype == TType.LIST:
22556 
          self.success = []
6188 rajveer 22557 
          (_etype541, _size538) = iprot.readListBegin()
22558 
          for _i542 in xrange(_size538):
22559 
            _elem543 = Order()
22560 
            _elem543.read(iprot)
22561 
            self.success.append(_elem543)
4709 rajveer 22562 
          iprot.readListEnd()
22563 
        else:
22564 
          iprot.skip(ftype)
22565 
      elif fid == 1:
22566 
        if ftype == TType.STRUCT:
22567 
          self.ex = TransactionServiceException()
22568 
          self.ex.read(iprot)
22569 
        else:
22570 
          iprot.skip(ftype)
22571 
      else:
22572 
        iprot.skip(ftype)
22573 
      iprot.readFieldEnd()
22574 
    iprot.readStructEnd()
22575 
 
22576 
  def write(self, oprot):
22577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22579 
      return
22580 
    oprot.writeStructBegin('getCancelledOrders_result')
22581 
    if self.success is not None:
22582 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22583 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22584 
      for iter544 in self.success:
22585 
        iter544.write(oprot)
4709 rajveer 22586 
      oprot.writeListEnd()
22587 
      oprot.writeFieldEnd()
22588 
    if self.ex is not None:
22589 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22590 
      self.ex.write(oprot)
22591 
      oprot.writeFieldEnd()
22592 
    oprot.writeFieldStop()
22593 
    oprot.writeStructEnd()
22594 
 
22595 
  def validate(self):
22596 
    return
22597 
 
22598 
 
22599 
  def __repr__(self):
22600 
    L = ['%s=%r' % (key, value)
22601 
      for key, value in self.__dict__.iteritems()]
22602 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22603 
 
22604 
  def __eq__(self, other):
22605 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22606 
 
22607 
  def __ne__(self, other):
22608 
    return not (self == other)
22609 
 
4600 varun.gupt 22610 
class saveBluedartSettlements_args:
22611 
  """
22612 
  Attributes:
22613 
   - mapAWBAndAmount
22614 
  """
22615 
 
22616 
  thrift_spec = (
22617 
    None, # 0
22618 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22619 
  )
22620 
 
22621 
  def __init__(self, mapAWBAndAmount=None,):
22622 
    self.mapAWBAndAmount = mapAWBAndAmount
22623 
 
22624 
  def read(self, iprot):
22625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22627 
      return
22628 
    iprot.readStructBegin()
22629 
    while True:
22630 
      (fname, ftype, fid) = iprot.readFieldBegin()
22631 
      if ftype == TType.STOP:
22632 
        break
22633 
      if fid == 1:
22634 
        if ftype == TType.MAP:
22635 
          self.mapAWBAndAmount = {}
6188 rajveer 22636 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22637 
          for _i549 in xrange(_size545):
22638 
            _key550 = iprot.readI64();
22639 
            _val551 = iprot.readDouble();
22640 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22641 
          iprot.readMapEnd()
22642 
        else:
22643 
          iprot.skip(ftype)
22644 
      else:
22645 
        iprot.skip(ftype)
22646 
      iprot.readFieldEnd()
22647 
    iprot.readStructEnd()
22648 
 
22649 
  def write(self, oprot):
22650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22652 
      return
22653 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22654 
    if self.mapAWBAndAmount is not None:
22655 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22656 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22657 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22658 
        oprot.writeI64(kiter552)
22659 
        oprot.writeDouble(viter553)
4600 varun.gupt 22660 
      oprot.writeMapEnd()
22661 
      oprot.writeFieldEnd()
22662 
    oprot.writeFieldStop()
22663 
    oprot.writeStructEnd()
22664 
 
22665 
  def validate(self):
22666 
    return
22667 
 
22668 
 
22669 
  def __repr__(self):
22670 
    L = ['%s=%r' % (key, value)
22671 
      for key, value in self.__dict__.iteritems()]
22672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22673 
 
22674 
  def __eq__(self, other):
22675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22676 
 
22677 
  def __ne__(self, other):
22678 
    return not (self == other)
22679 
 
22680 
class saveBluedartSettlements_result:
22681 
  """
22682 
  Attributes:
22683 
   - ex
22684 
  """
22685 
 
22686 
  thrift_spec = (
22687 
    None, # 0
22688 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22689 
  )
22690 
 
22691 
  def __init__(self, ex=None,):
22692 
    self.ex = ex
22693 
 
22694 
  def read(self, iprot):
22695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22697 
      return
22698 
    iprot.readStructBegin()
22699 
    while True:
22700 
      (fname, ftype, fid) = iprot.readFieldBegin()
22701 
      if ftype == TType.STOP:
22702 
        break
22703 
      if fid == 1:
22704 
        if ftype == TType.STRUCT:
22705 
          self.ex = TransactionServiceException()
22706 
          self.ex.read(iprot)
22707 
        else:
22708 
          iprot.skip(ftype)
22709 
      else:
22710 
        iprot.skip(ftype)
22711 
      iprot.readFieldEnd()
22712 
    iprot.readStructEnd()
22713 
 
22714 
  def write(self, oprot):
22715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22717 
      return
22718 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22719 
    if self.ex is not None:
22720 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22721 
      self.ex.write(oprot)
22722 
      oprot.writeFieldEnd()
22723 
    oprot.writeFieldStop()
22724 
    oprot.writeStructEnd()
22725 
 
22726 
  def validate(self):
22727 
    return
22728 
 
22729 
 
22730 
  def __repr__(self):
22731 
    L = ['%s=%r' % (key, value)
22732 
      for key, value in self.__dict__.iteritems()]
22733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22734 
 
22735 
  def __eq__(self, other):
22736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22737 
 
22738 
  def __ne__(self, other):
22739 
    return not (self == other)
22740 
 
22741 
class savePaymentSettlements_args:
22742 
  """
22743 
  Attributes:
22744 
   - settlementDate
22745 
   - paymentGatewayId
4905 varun.gupt 22746 
   - referenceId
4600 varun.gupt 22747 
   - serviceTax
22748 
   - otherCharges
22749 
   - netCollection
22750 
  """
22751 
 
22752 
  thrift_spec = (
22753 
    None, # 0
22754 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22755 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22756 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22757 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22758 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22759 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22760 
  )
22761 
 
4905 varun.gupt 22762 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22763 
    self.settlementDate = settlementDate
22764 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22765 
    self.referenceId = referenceId
4600 varun.gupt 22766 
    self.serviceTax = serviceTax
22767 
    self.otherCharges = otherCharges
22768 
    self.netCollection = netCollection
22769 
 
22770 
  def read(self, iprot):
22771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22773 
      return
22774 
    iprot.readStructBegin()
22775 
    while True:
22776 
      (fname, ftype, fid) = iprot.readFieldBegin()
22777 
      if ftype == TType.STOP:
22778 
        break
22779 
      if fid == 1:
22780 
        if ftype == TType.I64:
22781 
          self.settlementDate = iprot.readI64();
22782 
        else:
22783 
          iprot.skip(ftype)
22784 
      elif fid == 2:
22785 
        if ftype == TType.I64:
22786 
          self.paymentGatewayId = iprot.readI64();
22787 
        else:
22788 
          iprot.skip(ftype)
22789 
      elif fid == 3:
22790 
        if ftype == TType.I64:
4905 varun.gupt 22791 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22792 
        else:
22793 
          iprot.skip(ftype)
22794 
      elif fid == 4:
22795 
        if ftype == TType.DOUBLE:
22796 
          self.serviceTax = iprot.readDouble();
22797 
        else:
22798 
          iprot.skip(ftype)
22799 
      elif fid == 5:
22800 
        if ftype == TType.DOUBLE:
22801 
          self.otherCharges = iprot.readDouble();
22802 
        else:
22803 
          iprot.skip(ftype)
22804 
      elif fid == 6:
22805 
        if ftype == TType.DOUBLE:
22806 
          self.netCollection = iprot.readDouble();
22807 
        else:
22808 
          iprot.skip(ftype)
22809 
      else:
22810 
        iprot.skip(ftype)
22811 
      iprot.readFieldEnd()
22812 
    iprot.readStructEnd()
22813 
 
22814 
  def write(self, oprot):
22815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22817 
      return
22818 
    oprot.writeStructBegin('savePaymentSettlements_args')
22819 
    if self.settlementDate is not None:
22820 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22821 
      oprot.writeI64(self.settlementDate)
22822 
      oprot.writeFieldEnd()
22823 
    if self.paymentGatewayId is not None:
22824 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22825 
      oprot.writeI64(self.paymentGatewayId)
22826 
      oprot.writeFieldEnd()
4905 varun.gupt 22827 
    if self.referenceId is not None:
22828 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22829 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22830 
      oprot.writeFieldEnd()
22831 
    if self.serviceTax is not None:
22832 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22833 
      oprot.writeDouble(self.serviceTax)
22834 
      oprot.writeFieldEnd()
22835 
    if self.otherCharges is not None:
22836 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22837 
      oprot.writeDouble(self.otherCharges)
22838 
      oprot.writeFieldEnd()
22839 
    if self.netCollection is not None:
22840 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22841 
      oprot.writeDouble(self.netCollection)
22842 
      oprot.writeFieldEnd()
22843 
    oprot.writeFieldStop()
22844 
    oprot.writeStructEnd()
22845 
 
22846 
  def validate(self):
22847 
    return
22848 
 
22849 
 
22850 
  def __repr__(self):
22851 
    L = ['%s=%r' % (key, value)
22852 
      for key, value in self.__dict__.iteritems()]
22853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22854 
 
22855 
  def __eq__(self, other):
22856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22857 
 
22858 
  def __ne__(self, other):
22859 
    return not (self == other)
22860 
 
22861 
class savePaymentSettlements_result:
22862 
  """
22863 
  Attributes:
22864 
   - ex
22865 
  """
22866 
 
22867 
  thrift_spec = (
22868 
    None, # 0
22869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22870 
  )
22871 
 
22872 
  def __init__(self, ex=None,):
22873 
    self.ex = ex
22874 
 
22875 
  def read(self, iprot):
22876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22878 
      return
22879 
    iprot.readStructBegin()
22880 
    while True:
22881 
      (fname, ftype, fid) = iprot.readFieldBegin()
22882 
      if ftype == TType.STOP:
22883 
        break
22884 
      if fid == 1:
22885 
        if ftype == TType.STRUCT:
22886 
          self.ex = TransactionServiceException()
22887 
          self.ex.read(iprot)
22888 
        else:
22889 
          iprot.skip(ftype)
22890 
      else:
22891 
        iprot.skip(ftype)
22892 
      iprot.readFieldEnd()
22893 
    iprot.readStructEnd()
22894 
 
22895 
  def write(self, oprot):
22896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22898 
      return
22899 
    oprot.writeStructBegin('savePaymentSettlements_result')
22900 
    if self.ex is not None:
22901 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22902 
      self.ex.write(oprot)
22903 
      oprot.writeFieldEnd()
22904 
    oprot.writeFieldStop()
22905 
    oprot.writeStructEnd()
22906 
 
22907 
  def validate(self):
22908 
    return
22909 
 
22910 
 
22911 
  def __repr__(self):
22912 
    L = ['%s=%r' % (key, value)
22913 
      for key, value in self.__dict__.iteritems()]
22914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22915 
 
22916 
  def __eq__(self, other):
22917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22918 
 
22919 
  def __ne__(self, other):
22920 
    return not (self == other)
22921 
 
22922 
class saveEBSSettlementSummary_args:
22923 
  """
22924 
  Attributes:
22925 
   - settlementId
22926 
   - settlementDate
22927 
   - transactionDateFrom
22928 
   - transactionDateTo
22929 
   - amount
22930 
  """
22931 
 
22932 
  thrift_spec = (
22933 
    None, # 0
22934 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22935 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22936 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22937 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22938 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22939 
  )
22940 
 
22941 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22942 
    self.settlementId = settlementId
22943 
    self.settlementDate = settlementDate
22944 
    self.transactionDateFrom = transactionDateFrom
22945 
    self.transactionDateTo = transactionDateTo
22946 
    self.amount = amount
22947 
 
22948 
  def read(self, iprot):
22949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22951 
      return
22952 
    iprot.readStructBegin()
22953 
    while True:
22954 
      (fname, ftype, fid) = iprot.readFieldBegin()
22955 
      if ftype == TType.STOP:
22956 
        break
22957 
      if fid == 1:
22958 
        if ftype == TType.I64:
22959 
          self.settlementId = iprot.readI64();
22960 
        else:
22961 
          iprot.skip(ftype)
22962 
      elif fid == 2:
22963 
        if ftype == TType.I64:
22964 
          self.settlementDate = iprot.readI64();
22965 
        else:
22966 
          iprot.skip(ftype)
22967 
      elif fid == 3:
22968 
        if ftype == TType.I64:
22969 
          self.transactionDateFrom = iprot.readI64();
22970 
        else:
22971 
          iprot.skip(ftype)
22972 
      elif fid == 4:
22973 
        if ftype == TType.I64:
22974 
          self.transactionDateTo = iprot.readI64();
22975 
        else:
22976 
          iprot.skip(ftype)
22977 
      elif fid == 5:
22978 
        if ftype == TType.DOUBLE:
22979 
          self.amount = iprot.readDouble();
22980 
        else:
22981 
          iprot.skip(ftype)
22982 
      else:
22983 
        iprot.skip(ftype)
22984 
      iprot.readFieldEnd()
22985 
    iprot.readStructEnd()
22986 
 
22987 
  def write(self, oprot):
22988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22990 
      return
22991 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22992 
    if self.settlementId is not None:
22993 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22994 
      oprot.writeI64(self.settlementId)
22995 
      oprot.writeFieldEnd()
22996 
    if self.settlementDate is not None:
22997 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22998 
      oprot.writeI64(self.settlementDate)
22999 
      oprot.writeFieldEnd()
23000 
    if self.transactionDateFrom is not None:
23001 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23002 
      oprot.writeI64(self.transactionDateFrom)
23003 
      oprot.writeFieldEnd()
23004 
    if self.transactionDateTo is not None:
23005 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23006 
      oprot.writeI64(self.transactionDateTo)
23007 
      oprot.writeFieldEnd()
23008 
    if self.amount is not None:
23009 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23010 
      oprot.writeDouble(self.amount)
23011 
      oprot.writeFieldEnd()
23012 
    oprot.writeFieldStop()
23013 
    oprot.writeStructEnd()
23014 
 
23015 
  def validate(self):
23016 
    return
23017 
 
23018 
 
23019 
  def __repr__(self):
23020 
    L = ['%s=%r' % (key, value)
23021 
      for key, value in self.__dict__.iteritems()]
23022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23023 
 
23024 
  def __eq__(self, other):
23025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23026 
 
23027 
  def __ne__(self, other):
23028 
    return not (self == other)
23029 
 
23030 
class saveEBSSettlementSummary_result:
23031 
  """
23032 
  Attributes:
23033 
   - ex
23034 
  """
23035 
 
23036 
  thrift_spec = (
23037 
    None, # 0
23038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23039 
  )
23040 
 
23041 
  def __init__(self, ex=None,):
23042 
    self.ex = ex
23043 
 
23044 
  def read(self, iprot):
23045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23047 
      return
23048 
    iprot.readStructBegin()
23049 
    while True:
23050 
      (fname, ftype, fid) = iprot.readFieldBegin()
23051 
      if ftype == TType.STOP:
23052 
        break
23053 
      if fid == 1:
23054 
        if ftype == TType.STRUCT:
23055 
          self.ex = TransactionServiceException()
23056 
          self.ex.read(iprot)
23057 
        else:
23058 
          iprot.skip(ftype)
23059 
      else:
23060 
        iprot.skip(ftype)
23061 
      iprot.readFieldEnd()
23062 
    iprot.readStructEnd()
23063 
 
23064 
  def write(self, oprot):
23065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23067 
      return
23068 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23069 
    if self.ex is not None:
23070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23071 
      self.ex.write(oprot)
23072 
      oprot.writeFieldEnd()
23073 
    oprot.writeFieldStop()
23074 
    oprot.writeStructEnd()
23075 
 
23076 
  def validate(self):
23077 
    return
23078 
 
23079 
 
23080 
  def __repr__(self):
23081 
    L = ['%s=%r' % (key, value)
23082 
      for key, value in self.__dict__.iteritems()]
23083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23084 
 
23085 
  def __eq__(self, other):
23086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23087 
 
23088 
  def __ne__(self, other):
23089 
    return not (self == other)
23090 
 
5386 phani.kuma 23091 
class getSettlementForPrepaid_args:
4600 varun.gupt 23092 
  """
23093 
  Attributes:
5189 varun.gupt 23094 
   - referenceId
23095 
   - isRefund
4600 varun.gupt 23096 
  """
23097 
 
23098 
  thrift_spec = (
23099 
    None, # 0
5189 varun.gupt 23100 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23101 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23102 
  )
23103 
 
5386 phani.kuma 23104 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23105 
    self.referenceId = referenceId
23106 
    self.isRefund = isRefund
4600 varun.gupt 23107 
 
23108 
  def read(self, iprot):
23109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23111 
      return
23112 
    iprot.readStructBegin()
23113 
    while True:
23114 
      (fname, ftype, fid) = iprot.readFieldBegin()
23115 
      if ftype == TType.STOP:
23116 
        break
23117 
      if fid == 1:
23118 
        if ftype == TType.I64:
5189 varun.gupt 23119 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23120 
        else:
23121 
          iprot.skip(ftype)
5189 varun.gupt 23122 
      elif fid == 2:
23123 
        if ftype == TType.BOOL:
23124 
          self.isRefund = iprot.readBool();
23125 
        else:
23126 
          iprot.skip(ftype)
4600 varun.gupt 23127 
      else:
23128 
        iprot.skip(ftype)
23129 
      iprot.readFieldEnd()
23130 
    iprot.readStructEnd()
23131 
 
23132 
  def write(self, oprot):
23133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23135 
      return
5386 phani.kuma 23136 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23137 
    if self.referenceId is not None:
23138 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23139 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23140 
      oprot.writeFieldEnd()
5386 phani.kuma 23141 
    if self.isRefund is not None:
23142 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23143 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23144 
      oprot.writeFieldEnd()
5386 phani.kuma 23145 
    oprot.writeFieldStop()
23146 
    oprot.writeStructEnd()
23147 
 
23148 
  def validate(self):
23149 
    return
23150 
 
23151 
 
23152 
  def __repr__(self):
23153 
    L = ['%s=%r' % (key, value)
23154 
      for key, value in self.__dict__.iteritems()]
23155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23156 
 
23157 
  def __eq__(self, other):
23158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23159 
 
23160 
  def __ne__(self, other):
23161 
    return not (self == other)
23162 
 
23163 
class getSettlementForPrepaid_result:
23164 
  """
23165 
  Attributes:
23166 
   - success
23167 
   - ex
23168 
  """
23169 
 
23170 
  thrift_spec = (
23171 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23173 
  )
23174 
 
23175 
  def __init__(self, success=None, ex=None,):
23176 
    self.success = success
23177 
    self.ex = ex
23178 
 
23179 
  def read(self, iprot):
23180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23182 
      return
23183 
    iprot.readStructBegin()
23184 
    while True:
23185 
      (fname, ftype, fid) = iprot.readFieldBegin()
23186 
      if ftype == TType.STOP:
23187 
        break
23188 
      if fid == 0:
23189 
        if ftype == TType.STRUCT:
23190 
          self.success = PaymentSettlement()
23191 
          self.success.read(iprot)
23192 
        else:
23193 
          iprot.skip(ftype)
23194 
      elif fid == 1:
23195 
        if ftype == TType.STRUCT:
23196 
          self.ex = TransactionServiceException()
23197 
          self.ex.read(iprot)
23198 
        else:
23199 
          iprot.skip(ftype)
23200 
      else:
23201 
        iprot.skip(ftype)
23202 
      iprot.readFieldEnd()
23203 
    iprot.readStructEnd()
23204 
 
23205 
  def write(self, oprot):
23206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23208 
      return
23209 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23210 
    if self.success is not None:
23211 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23212 
      self.success.write(oprot)
23213 
      oprot.writeFieldEnd()
23214 
    if self.ex is not None:
23215 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23216 
      self.ex.write(oprot)
23217 
      oprot.writeFieldEnd()
23218 
    oprot.writeFieldStop()
23219 
    oprot.writeStructEnd()
23220 
 
23221 
  def validate(self):
23222 
    return
23223 
 
23224 
 
23225 
  def __repr__(self):
23226 
    L = ['%s=%r' % (key, value)
23227 
      for key, value in self.__dict__.iteritems()]
23228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23229 
 
23230 
  def __eq__(self, other):
23231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23232 
 
23233 
  def __ne__(self, other):
23234 
    return not (self == other)
23235 
 
23236 
class getSettlementForCod_args:
23237 
  """
23238 
  Attributes:
23239 
   - orderId
23240 
   - isRefund
23241 
  """
23242 
 
23243 
  thrift_spec = (
23244 
    None, # 0
23245 
    (1, TType.I64, 'orderId', None, None, ), # 1
23246 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23247 
  )
23248 
 
23249 
  def __init__(self, orderId=None, isRefund=None,):
23250 
    self.orderId = orderId
23251 
    self.isRefund = isRefund
23252 
 
23253 
  def read(self, iprot):
23254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23256 
      return
23257 
    iprot.readStructBegin()
23258 
    while True:
23259 
      (fname, ftype, fid) = iprot.readFieldBegin()
23260 
      if ftype == TType.STOP:
23261 
        break
23262 
      if fid == 1:
23263 
        if ftype == TType.I64:
23264 
          self.orderId = iprot.readI64();
23265 
        else:
23266 
          iprot.skip(ftype)
23267 
      elif fid == 2:
23268 
        if ftype == TType.BOOL:
23269 
          self.isRefund = iprot.readBool();
23270 
        else:
23271 
          iprot.skip(ftype)
23272 
      else:
23273 
        iprot.skip(ftype)
23274 
      iprot.readFieldEnd()
23275 
    iprot.readStructEnd()
23276 
 
23277 
  def write(self, oprot):
23278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23280 
      return
23281 
    oprot.writeStructBegin('getSettlementForCod_args')
23282 
    if self.orderId is not None:
23283 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23284 
      oprot.writeI64(self.orderId)
23285 
      oprot.writeFieldEnd()
5189 varun.gupt 23286 
    if self.isRefund is not None:
5386 phani.kuma 23287 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23288 
      oprot.writeBool(self.isRefund)
23289 
      oprot.writeFieldEnd()
4600 varun.gupt 23290 
    oprot.writeFieldStop()
23291 
    oprot.writeStructEnd()
23292 
 
23293 
  def validate(self):
23294 
    return
23295 
 
23296 
 
23297 
  def __repr__(self):
23298 
    L = ['%s=%r' % (key, value)
23299 
      for key, value in self.__dict__.iteritems()]
23300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23301 
 
23302 
  def __eq__(self, other):
23303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23304 
 
23305 
  def __ne__(self, other):
23306 
    return not (self == other)
23307 
 
5386 phani.kuma 23308 
class getSettlementForCod_result:
4600 varun.gupt 23309 
  """
23310 
  Attributes:
23311 
   - success
23312 
   - ex
23313 
  """
23314 
 
23315 
  thrift_spec = (
23316 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23317 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23318 
  )
23319 
 
23320 
  def __init__(self, success=None, ex=None,):
23321 
    self.success = success
23322 
    self.ex = ex
23323 
 
23324 
  def read(self, iprot):
23325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23327 
      return
23328 
    iprot.readStructBegin()
23329 
    while True:
23330 
      (fname, ftype, fid) = iprot.readFieldBegin()
23331 
      if ftype == TType.STOP:
23332 
        break
23333 
      if fid == 0:
23334 
        if ftype == TType.STRUCT:
23335 
          self.success = PaymentSettlement()
23336 
          self.success.read(iprot)
23337 
        else:
23338 
          iprot.skip(ftype)
23339 
      elif fid == 1:
23340 
        if ftype == TType.STRUCT:
23341 
          self.ex = TransactionServiceException()
23342 
          self.ex.read(iprot)
23343 
        else:
23344 
          iprot.skip(ftype)
23345 
      else:
23346 
        iprot.skip(ftype)
23347 
      iprot.readFieldEnd()
23348 
    iprot.readStructEnd()
23349 
 
23350 
  def write(self, oprot):
23351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23353 
      return
5386 phani.kuma 23354 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23355 
    if self.success is not None:
23356 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23357 
      self.success.write(oprot)
23358 
      oprot.writeFieldEnd()
23359 
    if self.ex is not None:
23360 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23361 
      self.ex.write(oprot)
23362 
      oprot.writeFieldEnd()
23363 
    oprot.writeFieldStop()
23364 
    oprot.writeStructEnd()
23365 
 
23366 
  def validate(self):
23367 
    return
23368 
 
23369 
 
23370 
  def __repr__(self):
23371 
    L = ['%s=%r' % (key, value)
23372 
      for key, value in self.__dict__.iteritems()]
23373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23374 
 
23375 
  def __eq__(self, other):
23376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23377 
 
23378 
  def __ne__(self, other):
23379 
    return not (self == other)
23380 
 
23381 
class getEBSSettlementSummaries_args:
23382 
 
23383 
  thrift_spec = (
23384 
  )
23385 
 
23386 
  def read(self, iprot):
23387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23389 
      return
23390 
    iprot.readStructBegin()
23391 
    while True:
23392 
      (fname, ftype, fid) = iprot.readFieldBegin()
23393 
      if ftype == TType.STOP:
23394 
        break
23395 
      else:
23396 
        iprot.skip(ftype)
23397 
      iprot.readFieldEnd()
23398 
    iprot.readStructEnd()
23399 
 
23400 
  def write(self, oprot):
23401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23403 
      return
23404 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23405 
    oprot.writeFieldStop()
23406 
    oprot.writeStructEnd()
23407 
 
23408 
  def validate(self):
23409 
    return
23410 
 
23411 
 
23412 
  def __repr__(self):
23413 
    L = ['%s=%r' % (key, value)
23414 
      for key, value in self.__dict__.iteritems()]
23415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23416 
 
23417 
  def __eq__(self, other):
23418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23419 
 
23420 
  def __ne__(self, other):
23421 
    return not (self == other)
23422 
 
23423 
class getEBSSettlementSummaries_result:
23424 
  """
23425 
  Attributes:
23426 
   - success
23427 
   - ex
23428 
  """
23429 
 
23430 
  thrift_spec = (
23431 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23433 
  )
23434 
 
23435 
  def __init__(self, success=None, ex=None,):
23436 
    self.success = success
23437 
    self.ex = ex
23438 
 
23439 
  def read(self, iprot):
23440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23442 
      return
23443 
    iprot.readStructBegin()
23444 
    while True:
23445 
      (fname, ftype, fid) = iprot.readFieldBegin()
23446 
      if ftype == TType.STOP:
23447 
        break
23448 
      if fid == 0:
23449 
        if ftype == TType.MAP:
23450 
          self.success = {}
6188 rajveer 23451 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23452 
          for _i558 in xrange(_size554):
23453 
            _key559 = iprot.readI64();
23454 
            _val560 = iprot.readString();
23455 
            self.success[_key559] = _val560
4600 varun.gupt 23456 
          iprot.readMapEnd()
23457 
        else:
23458 
          iprot.skip(ftype)
23459 
      elif fid == 1:
23460 
        if ftype == TType.STRUCT:
23461 
          self.ex = TransactionServiceException()
23462 
          self.ex.read(iprot)
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('getEBSSettlementSummaries_result')
23475 
    if self.success is not None:
23476 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23477 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23478 
      for kiter561,viter562 in self.success.items():
23479 
        oprot.writeI64(kiter561)
23480 
        oprot.writeString(viter562)
4600 varun.gupt 23481 
      oprot.writeMapEnd()
23482 
      oprot.writeFieldEnd()
23483 
    if self.ex is not None:
23484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23485 
      self.ex.write(oprot)
23486 
      oprot.writeFieldEnd()
23487 
    oprot.writeFieldStop()
23488 
    oprot.writeStructEnd()
23489 
 
23490 
  def validate(self):
23491 
    return
23492 
 
23493 
 
23494 
  def __repr__(self):
23495 
    L = ['%s=%r' % (key, value)
23496 
      for key, value in self.__dict__.iteritems()]
23497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23498 
 
23499 
  def __eq__(self, other):
23500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23501 
 
23502 
  def __ne__(self, other):
23503 
    return not (self == other)
23504 
 
23505 
class markEBSSettlementUploaded_args:
23506 
  """
23507 
  Attributes:
23508 
   - settlementId
23509 
  """
23510 
 
23511 
  thrift_spec = (
23512 
    None, # 0
23513 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23514 
  )
23515 
 
23516 
  def __init__(self, settlementId=None,):
23517 
    self.settlementId = settlementId
23518 
 
23519 
  def read(self, iprot):
23520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23522 
      return
23523 
    iprot.readStructBegin()
23524 
    while True:
23525 
      (fname, ftype, fid) = iprot.readFieldBegin()
23526 
      if ftype == TType.STOP:
23527 
        break
23528 
      if fid == 1:
23529 
        if ftype == TType.I64:
23530 
          self.settlementId = iprot.readI64();
23531 
        else:
23532 
          iprot.skip(ftype)
23533 
      else:
23534 
        iprot.skip(ftype)
23535 
      iprot.readFieldEnd()
23536 
    iprot.readStructEnd()
23537 
 
23538 
  def write(self, oprot):
23539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23541 
      return
23542 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23543 
    if self.settlementId is not None:
23544 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23545 
      oprot.writeI64(self.settlementId)
23546 
      oprot.writeFieldEnd()
23547 
    oprot.writeFieldStop()
23548 
    oprot.writeStructEnd()
23549 
 
23550 
  def validate(self):
23551 
    return
23552 
 
23553 
 
23554 
  def __repr__(self):
23555 
    L = ['%s=%r' % (key, value)
23556 
      for key, value in self.__dict__.iteritems()]
23557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23558 
 
23559 
  def __eq__(self, other):
23560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23561 
 
23562 
  def __ne__(self, other):
23563 
    return not (self == other)
23564 
 
23565 
class markEBSSettlementUploaded_result:
23566 
  """
23567 
  Attributes:
23568 
   - ex
23569 
  """
23570 
 
23571 
  thrift_spec = (
23572 
    None, # 0
23573 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23574 
  )
23575 
 
23576 
  def __init__(self, ex=None,):
23577 
    self.ex = ex
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 
      if fid == 1:
23589 
        if ftype == TType.STRUCT:
23590 
          self.ex = TransactionServiceException()
23591 
          self.ex.read(iprot)
23592 
        else:
23593 
          iprot.skip(ftype)
23594 
      else:
23595 
        iprot.skip(ftype)
23596 
      iprot.readFieldEnd()
23597 
    iprot.readStructEnd()
23598 
 
23599 
  def write(self, oprot):
23600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23602 
      return
23603 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23604 
    if self.ex is not None:
23605 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23606 
      self.ex.write(oprot)
23607 
      oprot.writeFieldEnd()
23608 
    oprot.writeFieldStop()
23609 
    oprot.writeStructEnd()
23610 
 
23611 
  def validate(self):
23612 
    return
23613 
 
23614 
 
23615 
  def __repr__(self):
23616 
    L = ['%s=%r' % (key, value)
23617 
      for key, value in self.__dict__.iteritems()]
23618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23619 
 
23620 
  def __eq__(self, other):
23621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23622 
 
23623 
  def __ne__(self, other):
23624 
    return not (self == other)
23625 
 
23626 
class getEBSSettlementDate_args:
23627 
  """
23628 
  Attributes:
23629 
   - settlementId
23630 
  """
23631 
 
23632 
  thrift_spec = (
23633 
    None, # 0
23634 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23635 
  )
23636 
 
23637 
  def __init__(self, settlementId=None,):
23638 
    self.settlementId = settlementId
23639 
 
23640 
  def read(self, iprot):
23641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23643 
      return
23644 
    iprot.readStructBegin()
23645 
    while True:
23646 
      (fname, ftype, fid) = iprot.readFieldBegin()
23647 
      if ftype == TType.STOP:
23648 
        break
23649 
      if fid == 1:
23650 
        if ftype == TType.I64:
23651 
          self.settlementId = iprot.readI64();
23652 
        else:
23653 
          iprot.skip(ftype)
23654 
      else:
23655 
        iprot.skip(ftype)
23656 
      iprot.readFieldEnd()
23657 
    iprot.readStructEnd()
23658 
 
23659 
  def write(self, oprot):
23660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23662 
      return
23663 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23664 
    if self.settlementId is not None:
23665 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23666 
      oprot.writeI64(self.settlementId)
23667 
      oprot.writeFieldEnd()
23668 
    oprot.writeFieldStop()
23669 
    oprot.writeStructEnd()
23670 
 
23671 
  def validate(self):
23672 
    return
23673 
 
23674 
 
23675 
  def __repr__(self):
23676 
    L = ['%s=%r' % (key, value)
23677 
      for key, value in self.__dict__.iteritems()]
23678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23679 
 
23680 
  def __eq__(self, other):
23681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23682 
 
23683 
  def __ne__(self, other):
23684 
    return not (self == other)
23685 
 
23686 
class getEBSSettlementDate_result:
23687 
  """
23688 
  Attributes:
23689 
   - success
23690 
   - ex
23691 
  """
23692 
 
23693 
  thrift_spec = (
23694 
    (0, TType.I64, 'success', None, None, ), # 0
23695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23696 
  )
23697 
 
23698 
  def __init__(self, success=None, ex=None,):
23699 
    self.success = success
23700 
    self.ex = ex
23701 
 
23702 
  def read(self, iprot):
23703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23705 
      return
23706 
    iprot.readStructBegin()
23707 
    while True:
23708 
      (fname, ftype, fid) = iprot.readFieldBegin()
23709 
      if ftype == TType.STOP:
23710 
        break
23711 
      if fid == 0:
23712 
        if ftype == TType.I64:
23713 
          self.success = iprot.readI64();
23714 
        else:
23715 
          iprot.skip(ftype)
23716 
      elif fid == 1:
23717 
        if ftype == TType.STRUCT:
23718 
          self.ex = TransactionServiceException()
23719 
          self.ex.read(iprot)
23720 
        else:
23721 
          iprot.skip(ftype)
23722 
      else:
23723 
        iprot.skip(ftype)
23724 
      iprot.readFieldEnd()
23725 
    iprot.readStructEnd()
23726 
 
23727 
  def write(self, oprot):
23728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23730 
      return
23731 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23732 
    if self.success is not None:
23733 
      oprot.writeFieldBegin('success', TType.I64, 0)
23734 
      oprot.writeI64(self.success)
23735 
      oprot.writeFieldEnd()
23736 
    if self.ex is not None:
23737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23738 
      self.ex.write(oprot)
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)
4715 varun.gupt 23757 
 
23758 
class getSettlementsByDate_args:
23759 
  """
23760 
  Attributes:
23761 
   - settlementDateFrom
23762 
   - settlementDateTo
23763 
   - isRefund
23764 
  """
23765 
 
23766 
  thrift_spec = (
23767 
    None, # 0
23768 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23769 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23770 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23771 
  )
23772 
 
23773 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23774 
    self.settlementDateFrom = settlementDateFrom
23775 
    self.settlementDateTo = settlementDateTo
23776 
    self.isRefund = isRefund
23777 
 
23778 
  def read(self, iprot):
23779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23781 
      return
23782 
    iprot.readStructBegin()
23783 
    while True:
23784 
      (fname, ftype, fid) = iprot.readFieldBegin()
23785 
      if ftype == TType.STOP:
23786 
        break
23787 
      if fid == 1:
23788 
        if ftype == TType.I64:
23789 
          self.settlementDateFrom = iprot.readI64();
23790 
        else:
23791 
          iprot.skip(ftype)
23792 
      elif fid == 2:
23793 
        if ftype == TType.I64:
23794 
          self.settlementDateTo = iprot.readI64();
23795 
        else:
23796 
          iprot.skip(ftype)
23797 
      elif fid == 3:
23798 
        if ftype == TType.BOOL:
23799 
          self.isRefund = iprot.readBool();
23800 
        else:
23801 
          iprot.skip(ftype)
23802 
      else:
23803 
        iprot.skip(ftype)
23804 
      iprot.readFieldEnd()
23805 
    iprot.readStructEnd()
23806 
 
23807 
  def write(self, oprot):
23808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23810 
      return
23811 
    oprot.writeStructBegin('getSettlementsByDate_args')
23812 
    if self.settlementDateFrom is not None:
23813 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23814 
      oprot.writeI64(self.settlementDateFrom)
23815 
      oprot.writeFieldEnd()
23816 
    if self.settlementDateTo is not None:
23817 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23818 
      oprot.writeI64(self.settlementDateTo)
23819 
      oprot.writeFieldEnd()
23820 
    if self.isRefund is not None:
23821 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23822 
      oprot.writeBool(self.isRefund)
23823 
      oprot.writeFieldEnd()
23824 
    oprot.writeFieldStop()
23825 
    oprot.writeStructEnd()
23826 
 
23827 
  def validate(self):
23828 
    return
23829 
 
23830 
 
23831 
  def __repr__(self):
23832 
    L = ['%s=%r' % (key, value)
23833 
      for key, value in self.__dict__.iteritems()]
23834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23835 
 
23836 
  def __eq__(self, other):
23837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23838 
 
23839 
  def __ne__(self, other):
23840 
    return not (self == other)
23841 
 
23842 
class getSettlementsByDate_result:
23843 
  """
23844 
  Attributes:
23845 
   - success
23846 
   - ex
23847 
  """
23848 
 
23849 
  thrift_spec = (
23850 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23852 
  )
23853 
 
23854 
  def __init__(self, success=None, ex=None,):
23855 
    self.success = success
23856 
    self.ex = ex
23857 
 
23858 
  def read(self, iprot):
23859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23861 
      return
23862 
    iprot.readStructBegin()
23863 
    while True:
23864 
      (fname, ftype, fid) = iprot.readFieldBegin()
23865 
      if ftype == TType.STOP:
23866 
        break
23867 
      if fid == 0:
23868 
        if ftype == TType.LIST:
23869 
          self.success = []
6188 rajveer 23870 
          (_etype566, _size563) = iprot.readListBegin()
23871 
          for _i567 in xrange(_size563):
23872 
            _elem568 = PaymentSettlement()
23873 
            _elem568.read(iprot)
23874 
            self.success.append(_elem568)
4715 varun.gupt 23875 
          iprot.readListEnd()
23876 
        else:
23877 
          iprot.skip(ftype)
23878 
      elif fid == 1:
23879 
        if ftype == TType.STRUCT:
23880 
          self.ex = TransactionServiceException()
23881 
          self.ex.read(iprot)
23882 
        else:
23883 
          iprot.skip(ftype)
23884 
      else:
23885 
        iprot.skip(ftype)
23886 
      iprot.readFieldEnd()
23887 
    iprot.readStructEnd()
23888 
 
23889 
  def write(self, oprot):
23890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23892 
      return
23893 
    oprot.writeStructBegin('getSettlementsByDate_result')
23894 
    if self.success is not None:
23895 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23896 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23897 
      for iter569 in self.success:
23898 
        iter569.write(oprot)
4715 varun.gupt 23899 
      oprot.writeListEnd()
23900 
      oprot.writeFieldEnd()
23901 
    if self.ex is not None:
23902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23903 
      self.ex.write(oprot)
23904 
      oprot.writeFieldEnd()
23905 
    oprot.writeFieldStop()
23906 
    oprot.writeStructEnd()
23907 
 
23908 
  def validate(self):
23909 
    return
23910 
 
23911 
 
23912 
  def __repr__(self):
23913 
    L = ['%s=%r' % (key, value)
23914 
      for key, value in self.__dict__.iteritems()]
23915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23916 
 
23917 
  def __eq__(self, other):
23918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23919 
 
23920 
  def __ne__(self, other):
23921 
    return not (self == other)
23922 
 
23923 
class getReshippedOrderIds_args:
23924 
  """
23925 
  Attributes:
23926 
   - orderIds
23927 
  """
23928 
 
23929 
  thrift_spec = (
23930 
    None, # 0
23931 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23932 
  )
23933 
 
23934 
  def __init__(self, orderIds=None,):
23935 
    self.orderIds = orderIds
23936 
 
23937 
  def read(self, iprot):
23938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23940 
      return
23941 
    iprot.readStructBegin()
23942 
    while True:
23943 
      (fname, ftype, fid) = iprot.readFieldBegin()
23944 
      if ftype == TType.STOP:
23945 
        break
23946 
      if fid == 1:
23947 
        if ftype == TType.LIST:
23948 
          self.orderIds = []
6188 rajveer 23949 
          (_etype573, _size570) = iprot.readListBegin()
23950 
          for _i574 in xrange(_size570):
23951 
            _elem575 = iprot.readI64();
23952 
            self.orderIds.append(_elem575)
4715 varun.gupt 23953 
          iprot.readListEnd()
23954 
        else:
23955 
          iprot.skip(ftype)
23956 
      else:
23957 
        iprot.skip(ftype)
23958 
      iprot.readFieldEnd()
23959 
    iprot.readStructEnd()
23960 
 
23961 
  def write(self, oprot):
23962 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23963 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23964 
      return
23965 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23966 
    if self.orderIds is not None:
23967 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23968 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23969 
      for iter576 in self.orderIds:
23970 
        oprot.writeI64(iter576)
4715 varun.gupt 23971 
      oprot.writeListEnd()
23972 
      oprot.writeFieldEnd()
23973 
    oprot.writeFieldStop()
23974 
    oprot.writeStructEnd()
23975 
 
23976 
  def validate(self):
23977 
    return
23978 
 
23979 
 
23980 
  def __repr__(self):
23981 
    L = ['%s=%r' % (key, value)
23982 
      for key, value in self.__dict__.iteritems()]
23983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23984 
 
23985 
  def __eq__(self, other):
23986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23987 
 
23988 
  def __ne__(self, other):
23989 
    return not (self == other)
23990 
 
23991 
class getReshippedOrderIds_result:
23992 
  """
23993 
  Attributes:
23994 
   - success
23995 
   - ex
23996 
  """
23997 
 
23998 
  thrift_spec = (
23999 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24001 
  )
24002 
 
24003 
  def __init__(self, success=None, ex=None,):
24004 
    self.success = success
24005 
    self.ex = ex
24006 
 
24007 
  def read(self, iprot):
24008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24010 
      return
24011 
    iprot.readStructBegin()
24012 
    while True:
24013 
      (fname, ftype, fid) = iprot.readFieldBegin()
24014 
      if ftype == TType.STOP:
24015 
        break
24016 
      if fid == 0:
24017 
        if ftype == TType.LIST:
24018 
          self.success = []
6188 rajveer 24019 
          (_etype580, _size577) = iprot.readListBegin()
24020 
          for _i581 in xrange(_size577):
24021 
            _elem582 = iprot.readI64();
24022 
            self.success.append(_elem582)
4715 varun.gupt 24023 
          iprot.readListEnd()
24024 
        else:
24025 
          iprot.skip(ftype)
24026 
      elif fid == 1:
24027 
        if ftype == TType.STRUCT:
24028 
          self.ex = TransactionServiceException()
24029 
          self.ex.read(iprot)
24030 
        else:
24031 
          iprot.skip(ftype)
24032 
      else:
24033 
        iprot.skip(ftype)
24034 
      iprot.readFieldEnd()
24035 
    iprot.readStructEnd()
24036 
 
24037 
  def write(self, oprot):
24038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24040 
      return
24041 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24042 
    if self.success is not None:
24043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24044 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24045 
      for iter583 in self.success:
24046 
        oprot.writeI64(iter583)
4715 varun.gupt 24047 
      oprot.writeListEnd()
24048 
      oprot.writeFieldEnd()
24049 
    if self.ex is not None:
24050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24051 
      self.ex.write(oprot)
24052 
      oprot.writeFieldEnd()
24053 
    oprot.writeFieldStop()
24054 
    oprot.writeStructEnd()
24055 
 
24056 
  def validate(self):
24057 
    return
24058 
 
24059 
 
24060 
  def __repr__(self):
24061 
    L = ['%s=%r' % (key, value)
24062 
      for key, value in self.__dict__.iteritems()]
24063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24064 
 
24065 
  def __eq__(self, other):
24066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24067 
 
24068 
  def __ne__(self, other):
24069 
    return not (self == other)
4757 mandeep.dh 24070 
 
5481 phani.kuma 24071 
class getBilledOrders_args:
4875 varun.gupt 24072 
  """
24073 
  Attributes:
24074 
   - vendorId
5481 phani.kuma 24075 
   - onlyVendorNotPaid
24076 
   - billingDateFrom
24077 
   - billingDateTo
4875 varun.gupt 24078 
  """
24079 
 
24080 
  thrift_spec = (
24081 
    None, # 0
24082 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24083 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24084 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24085 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24086 
  )
24087 
 
5481 phani.kuma 24088 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24089 
    self.vendorId = vendorId
5481 phani.kuma 24090 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24091 
    self.billingDateFrom = billingDateFrom
24092 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24093 
 
24094 
  def read(self, iprot):
24095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24097 
      return
24098 
    iprot.readStructBegin()
24099 
    while True:
24100 
      (fname, ftype, fid) = iprot.readFieldBegin()
24101 
      if ftype == TType.STOP:
24102 
        break
24103 
      if fid == 1:
24104 
        if ftype == TType.I64:
24105 
          self.vendorId = iprot.readI64();
24106 
        else:
24107 
          iprot.skip(ftype)
5481 phani.kuma 24108 
      elif fid == 2:
24109 
        if ftype == TType.BOOL:
24110 
          self.onlyVendorNotPaid = iprot.readBool();
24111 
        else:
24112 
          iprot.skip(ftype)
24113 
      elif fid == 3:
24114 
        if ftype == TType.I64:
24115 
          self.billingDateFrom = iprot.readI64();
24116 
        else:
24117 
          iprot.skip(ftype)
24118 
      elif fid == 4:
24119 
        if ftype == TType.I64:
24120 
          self.billingDateTo = iprot.readI64();
24121 
        else:
24122 
          iprot.skip(ftype)
4875 varun.gupt 24123 
      else:
24124 
        iprot.skip(ftype)
24125 
      iprot.readFieldEnd()
24126 
    iprot.readStructEnd()
24127 
 
24128 
  def write(self, oprot):
24129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24131 
      return
5481 phani.kuma 24132 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24133 
    if self.vendorId is not None:
24134 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24135 
      oprot.writeI64(self.vendorId)
24136 
      oprot.writeFieldEnd()
5481 phani.kuma 24137 
    if self.onlyVendorNotPaid is not None:
24138 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24139 
      oprot.writeBool(self.onlyVendorNotPaid)
24140 
      oprot.writeFieldEnd()
24141 
    if self.billingDateFrom is not None:
24142 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24143 
      oprot.writeI64(self.billingDateFrom)
24144 
      oprot.writeFieldEnd()
24145 
    if self.billingDateTo is not None:
24146 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24147 
      oprot.writeI64(self.billingDateTo)
24148 
      oprot.writeFieldEnd()
4875 varun.gupt 24149 
    oprot.writeFieldStop()
24150 
    oprot.writeStructEnd()
24151 
 
24152 
  def validate(self):
24153 
    return
24154 
 
24155 
 
24156 
  def __repr__(self):
24157 
    L = ['%s=%r' % (key, value)
24158 
      for key, value in self.__dict__.iteritems()]
24159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24160 
 
24161 
  def __eq__(self, other):
24162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24163 
 
24164 
  def __ne__(self, other):
24165 
    return not (self == other)
24166 
 
5481 phani.kuma 24167 
class getBilledOrders_result:
4875 varun.gupt 24168 
  """
24169 
  Attributes:
24170 
   - success
24171 
   - ex
24172 
  """
24173 
 
24174 
  thrift_spec = (
24175 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24177 
  )
24178 
 
24179 
  def __init__(self, success=None, ex=None,):
24180 
    self.success = success
24181 
    self.ex = ex
24182 
 
24183 
  def read(self, iprot):
24184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24186 
      return
24187 
    iprot.readStructBegin()
24188 
    while True:
24189 
      (fname, ftype, fid) = iprot.readFieldBegin()
24190 
      if ftype == TType.STOP:
24191 
        break
24192 
      if fid == 0:
24193 
        if ftype == TType.LIST:
24194 
          self.success = []
6188 rajveer 24195 
          (_etype587, _size584) = iprot.readListBegin()
24196 
          for _i588 in xrange(_size584):
24197 
            _elem589 = Order()
24198 
            _elem589.read(iprot)
24199 
            self.success.append(_elem589)
4875 varun.gupt 24200 
          iprot.readListEnd()
24201 
        else:
24202 
          iprot.skip(ftype)
24203 
      elif fid == 1:
24204 
        if ftype == TType.STRUCT:
24205 
          self.ex = TransactionServiceException()
24206 
          self.ex.read(iprot)
24207 
        else:
24208 
          iprot.skip(ftype)
24209 
      else:
24210 
        iprot.skip(ftype)
24211 
      iprot.readFieldEnd()
24212 
    iprot.readStructEnd()
24213 
 
24214 
  def write(self, oprot):
24215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24217 
      return
5481 phani.kuma 24218 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24219 
    if self.success is not None:
24220 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24221 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24222 
      for iter590 in self.success:
24223 
        iter590.write(oprot)
4875 varun.gupt 24224 
      oprot.writeListEnd()
24225 
      oprot.writeFieldEnd()
24226 
    if self.ex is not None:
24227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24228 
      self.ex.write(oprot)
24229 
      oprot.writeFieldEnd()
24230 
    oprot.writeFieldStop()
24231 
    oprot.writeStructEnd()
24232 
 
24233 
  def validate(self):
24234 
    return
24235 
 
24236 
 
24237 
  def __repr__(self):
24238 
    L = ['%s=%r' % (key, value)
24239 
      for key, value in self.__dict__.iteritems()]
24240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24241 
 
24242 
  def __eq__(self, other):
24243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24244 
 
24245 
  def __ne__(self, other):
24246 
    return not (self == other)
5031 varun.gupt 24247 
 
24248 
class getStatusDistributionOfOrders_args:
24249 
  """
24250 
  Attributes:
24251 
   - startDate
24252 
   - endDate
24253 
  """
24254 
 
24255 
  thrift_spec = (
24256 
    None, # 0
24257 
    (1, TType.I64, 'startDate', None, None, ), # 1
24258 
    (2, TType.I64, 'endDate', None, None, ), # 2
24259 
  )
24260 
 
24261 
  def __init__(self, startDate=None, endDate=None,):
24262 
    self.startDate = startDate
24263 
    self.endDate = endDate
24264 
 
24265 
  def read(self, iprot):
24266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24268 
      return
24269 
    iprot.readStructBegin()
24270 
    while True:
24271 
      (fname, ftype, fid) = iprot.readFieldBegin()
24272 
      if ftype == TType.STOP:
24273 
        break
24274 
      if fid == 1:
24275 
        if ftype == TType.I64:
24276 
          self.startDate = iprot.readI64();
24277 
        else:
24278 
          iprot.skip(ftype)
24279 
      elif fid == 2:
24280 
        if ftype == TType.I64:
24281 
          self.endDate = iprot.readI64();
24282 
        else:
24283 
          iprot.skip(ftype)
24284 
      else:
24285 
        iprot.skip(ftype)
24286 
      iprot.readFieldEnd()
24287 
    iprot.readStructEnd()
24288 
 
24289 
  def write(self, oprot):
24290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24292 
      return
24293 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24294 
    if self.startDate is not None:
24295 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24296 
      oprot.writeI64(self.startDate)
24297 
      oprot.writeFieldEnd()
24298 
    if self.endDate is not None:
24299 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24300 
      oprot.writeI64(self.endDate)
24301 
      oprot.writeFieldEnd()
24302 
    oprot.writeFieldStop()
24303 
    oprot.writeStructEnd()
24304 
 
24305 
  def validate(self):
24306 
    return
24307 
 
24308 
 
24309 
  def __repr__(self):
24310 
    L = ['%s=%r' % (key, value)
24311 
      for key, value in self.__dict__.iteritems()]
24312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24313 
 
24314 
  def __eq__(self, other):
24315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24316 
 
24317 
  def __ne__(self, other):
24318 
    return not (self == other)
24319 
 
24320 
class getStatusDistributionOfOrders_result:
24321 
  """
24322 
  Attributes:
24323 
   - success
24324 
   - ex
24325 
  """
24326 
 
24327 
  thrift_spec = (
24328 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24330 
  )
24331 
 
24332 
  def __init__(self, success=None, ex=None,):
24333 
    self.success = success
24334 
    self.ex = ex
24335 
 
24336 
  def read(self, iprot):
24337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24339 
      return
24340 
    iprot.readStructBegin()
24341 
    while True:
24342 
      (fname, ftype, fid) = iprot.readFieldBegin()
24343 
      if ftype == TType.STOP:
24344 
        break
24345 
      if fid == 0:
24346 
        if ftype == TType.MAP:
24347 
          self.success = {}
6188 rajveer 24348 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24349 
          for _i595 in xrange(_size591):
24350 
            _key596 = iprot.readI64();
24351 
            _val597 = iprot.readI64();
24352 
            self.success[_key596] = _val597
5031 varun.gupt 24353 
          iprot.readMapEnd()
24354 
        else:
24355 
          iprot.skip(ftype)
24356 
      elif fid == 1:
24357 
        if ftype == TType.STRUCT:
24358 
          self.ex = TransactionServiceException()
24359 
          self.ex.read(iprot)
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      else:
24363 
        iprot.skip(ftype)
24364 
      iprot.readFieldEnd()
24365 
    iprot.readStructEnd()
24366 
 
24367 
  def write(self, oprot):
24368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24370 
      return
24371 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24372 
    if self.success is not None:
24373 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24374 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24375 
      for kiter598,viter599 in self.success.items():
24376 
        oprot.writeI64(kiter598)
24377 
        oprot.writeI64(viter599)
5031 varun.gupt 24378 
      oprot.writeMapEnd()
24379 
      oprot.writeFieldEnd()
24380 
    if self.ex is not None:
24381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24382 
      self.ex.write(oprot)
24383 
      oprot.writeFieldEnd()
24384 
    oprot.writeFieldStop()
24385 
    oprot.writeStructEnd()
24386 
 
24387 
  def validate(self):
24388 
    return
24389 
 
24390 
 
24391 
  def __repr__(self):
24392 
    L = ['%s=%r' % (key, value)
24393 
      for key, value in self.__dict__.iteritems()]
24394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24395 
 
24396 
  def __eq__(self, other):
24397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24398 
 
24399 
  def __ne__(self, other):
24400 
    return not (self == other)
5067 varun.gupt 24401 
 
24402 
class getOrderIdsForStatus_args:
24403 
  """
24404 
  Attributes:
24405 
   - status
24406 
   - startDatetime
24407 
   - endDatetime
24408 
  """
24409 
 
24410 
  thrift_spec = (
24411 
    None, # 0
24412 
    (1, TType.I64, 'status', None, None, ), # 1
24413 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24414 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24415 
  )
24416 
 
24417 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24418 
    self.status = status
24419 
    self.startDatetime = startDatetime
24420 
    self.endDatetime = endDatetime
24421 
 
24422 
  def read(self, iprot):
24423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24425 
      return
24426 
    iprot.readStructBegin()
24427 
    while True:
24428 
      (fname, ftype, fid) = iprot.readFieldBegin()
24429 
      if ftype == TType.STOP:
24430 
        break
24431 
      if fid == 1:
24432 
        if ftype == TType.I64:
24433 
          self.status = iprot.readI64();
24434 
        else:
24435 
          iprot.skip(ftype)
24436 
      elif fid == 2:
24437 
        if ftype == TType.I64:
24438 
          self.startDatetime = iprot.readI64();
24439 
        else:
24440 
          iprot.skip(ftype)
24441 
      elif fid == 3:
24442 
        if ftype == TType.I64:
24443 
          self.endDatetime = iprot.readI64();
24444 
        else:
24445 
          iprot.skip(ftype)
24446 
      else:
24447 
        iprot.skip(ftype)
24448 
      iprot.readFieldEnd()
24449 
    iprot.readStructEnd()
24450 
 
24451 
  def write(self, oprot):
24452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24454 
      return
24455 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24456 
    if self.status is not None:
24457 
      oprot.writeFieldBegin('status', TType.I64, 1)
24458 
      oprot.writeI64(self.status)
24459 
      oprot.writeFieldEnd()
24460 
    if self.startDatetime is not None:
24461 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24462 
      oprot.writeI64(self.startDatetime)
24463 
      oprot.writeFieldEnd()
24464 
    if self.endDatetime is not None:
24465 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24466 
      oprot.writeI64(self.endDatetime)
24467 
      oprot.writeFieldEnd()
24468 
    oprot.writeFieldStop()
24469 
    oprot.writeStructEnd()
24470 
 
24471 
  def validate(self):
24472 
    return
24473 
 
24474 
 
24475 
  def __repr__(self):
24476 
    L = ['%s=%r' % (key, value)
24477 
      for key, value in self.__dict__.iteritems()]
24478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24479 
 
24480 
  def __eq__(self, other):
24481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24482 
 
24483 
  def __ne__(self, other):
24484 
    return not (self == other)
24485 
 
24486 
class getOrderIdsForStatus_result:
24487 
  """
24488 
  Attributes:
24489 
   - success
24490 
   - ex
24491 
  """
24492 
 
24493 
  thrift_spec = (
24494 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24495 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24496 
  )
24497 
 
24498 
  def __init__(self, success=None, ex=None,):
24499 
    self.success = success
24500 
    self.ex = ex
24501 
 
24502 
  def read(self, iprot):
24503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24505 
      return
24506 
    iprot.readStructBegin()
24507 
    while True:
24508 
      (fname, ftype, fid) = iprot.readFieldBegin()
24509 
      if ftype == TType.STOP:
24510 
        break
24511 
      if fid == 0:
24512 
        if ftype == TType.LIST:
24513 
          self.success = []
6188 rajveer 24514 
          (_etype603, _size600) = iprot.readListBegin()
24515 
          for _i604 in xrange(_size600):
24516 
            _elem605 = iprot.readI64();
24517 
            self.success.append(_elem605)
5067 varun.gupt 24518 
          iprot.readListEnd()
24519 
        else:
24520 
          iprot.skip(ftype)
24521 
      elif fid == 1:
24522 
        if ftype == TType.STRUCT:
24523 
          self.ex = TransactionServiceException()
24524 
          self.ex.read(iprot)
24525 
        else:
24526 
          iprot.skip(ftype)
24527 
      else:
24528 
        iprot.skip(ftype)
24529 
      iprot.readFieldEnd()
24530 
    iprot.readStructEnd()
24531 
 
24532 
  def write(self, oprot):
24533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24535 
      return
24536 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24537 
    if self.success is not None:
24538 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24539 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24540 
      for iter606 in self.success:
24541 
        oprot.writeI64(iter606)
5067 varun.gupt 24542 
      oprot.writeListEnd()
24543 
      oprot.writeFieldEnd()
24544 
    if self.ex is not None:
24545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24546 
      self.ex.write(oprot)
24547 
      oprot.writeFieldEnd()
24548 
    oprot.writeFieldStop()
24549 
    oprot.writeStructEnd()
24550 
 
24551 
  def validate(self):
24552 
    return
24553 
 
24554 
 
24555 
  def __repr__(self):
24556 
    L = ['%s=%r' % (key, value)
24557 
      for key, value in self.__dict__.iteritems()]
24558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24559 
 
24560 
  def __eq__(self, other):
24561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24562 
 
24563 
  def __ne__(self, other):
24564 
    return not (self == other)
5099 varun.gupt 24565 
 
5348 anupam.sin 24566 
class updateCODAgent_args:
24567 
  """
24568 
  Attributes:
24569 
   - agent
24570 
   - orderId
24571 
  """
24572 
 
24573 
  thrift_spec = (
24574 
    None, # 0
24575 
    (1, TType.STRING, 'agent', None, None, ), # 1
24576 
    (2, TType.I64, 'orderId', None, None, ), # 2
24577 
  )
24578 
 
24579 
  def __init__(self, agent=None, orderId=None,):
24580 
    self.agent = agent
24581 
    self.orderId = orderId
24582 
 
24583 
  def read(self, iprot):
24584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24586 
      return
24587 
    iprot.readStructBegin()
24588 
    while True:
24589 
      (fname, ftype, fid) = iprot.readFieldBegin()
24590 
      if ftype == TType.STOP:
24591 
        break
24592 
      if fid == 1:
24593 
        if ftype == TType.STRING:
24594 
          self.agent = iprot.readString();
24595 
        else:
24596 
          iprot.skip(ftype)
24597 
      elif fid == 2:
24598 
        if ftype == TType.I64:
24599 
          self.orderId = iprot.readI64();
24600 
        else:
24601 
          iprot.skip(ftype)
24602 
      else:
24603 
        iprot.skip(ftype)
24604 
      iprot.readFieldEnd()
24605 
    iprot.readStructEnd()
24606 
 
24607 
  def write(self, oprot):
24608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24610 
      return
24611 
    oprot.writeStructBegin('updateCODAgent_args')
24612 
    if self.agent is not None:
24613 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24614 
      oprot.writeString(self.agent)
24615 
      oprot.writeFieldEnd()
24616 
    if self.orderId is not None:
24617 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24618 
      oprot.writeI64(self.orderId)
24619 
      oprot.writeFieldEnd()
24620 
    oprot.writeFieldStop()
24621 
    oprot.writeStructEnd()
24622 
 
24623 
  def validate(self):
24624 
    return
24625 
 
24626 
 
24627 
  def __repr__(self):
24628 
    L = ['%s=%r' % (key, value)
24629 
      for key, value in self.__dict__.iteritems()]
24630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24631 
 
24632 
  def __eq__(self, other):
24633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24634 
 
24635 
  def __ne__(self, other):
24636 
    return not (self == other)
24637 
 
24638 
class updateCODAgent_result:
24639 
  """
24640 
  Attributes:
24641 
   - ex
24642 
  """
24643 
 
24644 
  thrift_spec = (
24645 
    None, # 0
24646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24647 
  )
24648 
 
24649 
  def __init__(self, ex=None,):
24650 
    self.ex = ex
24651 
 
24652 
  def read(self, iprot):
24653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24655 
      return
24656 
    iprot.readStructBegin()
24657 
    while True:
24658 
      (fname, ftype, fid) = iprot.readFieldBegin()
24659 
      if ftype == TType.STOP:
24660 
        break
24661 
      if fid == 1:
24662 
        if ftype == TType.STRUCT:
24663 
          self.ex = TransactionServiceException()
24664 
          self.ex.read(iprot)
24665 
        else:
24666 
          iprot.skip(ftype)
24667 
      else:
24668 
        iprot.skip(ftype)
24669 
      iprot.readFieldEnd()
24670 
    iprot.readStructEnd()
24671 
 
24672 
  def write(self, oprot):
24673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24675 
      return
24676 
    oprot.writeStructBegin('updateCODAgent_result')
24677 
    if self.ex is not None:
24678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24679 
      self.ex.write(oprot)
24680 
      oprot.writeFieldEnd()
24681 
    oprot.writeFieldStop()
24682 
    oprot.writeStructEnd()
24683 
 
24684 
  def validate(self):
24685 
    return
24686 
 
24687 
 
24688 
  def __repr__(self):
24689 
    L = ['%s=%r' % (key, value)
24690 
      for key, value in self.__dict__.iteritems()]
24691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24692 
 
24693 
  def __eq__(self, other):
24694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24695 
 
24696 
  def __ne__(self, other):
24697 
    return not (self == other)
24698 
 
5099 varun.gupt 24699 
class updateOrderAsPaidToVendor_args:
24700 
  """
24701 
  Attributes:
24702 
   - orderId
24703 
  """
24704 
 
24705 
  thrift_spec = (
24706 
    None, # 0
24707 
    (1, TType.I64, 'orderId', None, None, ), # 1
24708 
  )
24709 
 
24710 
  def __init__(self, orderId=None,):
24711 
    self.orderId = orderId
24712 
 
24713 
  def read(self, iprot):
24714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24716 
      return
24717 
    iprot.readStructBegin()
24718 
    while True:
24719 
      (fname, ftype, fid) = iprot.readFieldBegin()
24720 
      if ftype == TType.STOP:
24721 
        break
24722 
      if fid == 1:
24723 
        if ftype == TType.I64:
24724 
          self.orderId = iprot.readI64();
24725 
        else:
24726 
          iprot.skip(ftype)
24727 
      else:
24728 
        iprot.skip(ftype)
24729 
      iprot.readFieldEnd()
24730 
    iprot.readStructEnd()
24731 
 
24732 
  def write(self, oprot):
24733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24735 
      return
24736 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24737 
    if self.orderId is not None:
24738 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24739 
      oprot.writeI64(self.orderId)
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)
24758 
 
24759 
class updateOrderAsPaidToVendor_result:
24760 
  """
24761 
  Attributes:
24762 
   - ex
24763 
  """
24764 
 
24765 
  thrift_spec = (
24766 
    None, # 0
24767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24768 
  )
24769 
 
24770 
  def __init__(self, ex=None,):
24771 
    self.ex = ex
24772 
 
24773 
  def read(self, iprot):
24774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24776 
      return
24777 
    iprot.readStructBegin()
24778 
    while True:
24779 
      (fname, ftype, fid) = iprot.readFieldBegin()
24780 
      if ftype == TType.STOP:
24781 
        break
24782 
      if fid == 1:
24783 
        if ftype == TType.STRUCT:
24784 
          self.ex = TransactionServiceException()
24785 
          self.ex.read(iprot)
24786 
        else:
24787 
          iprot.skip(ftype)
24788 
      else:
24789 
        iprot.skip(ftype)
24790 
      iprot.readFieldEnd()
24791 
    iprot.readStructEnd()
24792 
 
24793 
  def write(self, oprot):
24794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24796 
      return
24797 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24798 
    if self.ex is not None:
24799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24800 
      self.ex.write(oprot)
24801 
      oprot.writeFieldEnd()
24802 
    oprot.writeFieldStop()
24803 
    oprot.writeStructEnd()
24804 
 
24805 
  def validate(self):
24806 
    return
24807 
 
24808 
 
24809 
  def __repr__(self):
24810 
    L = ['%s=%r' % (key, value)
24811 
      for key, value in self.__dict__.iteritems()]
24812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24813 
 
24814 
  def __eq__(self, other):
24815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24816 
 
24817 
  def __ne__(self, other):
24818 
    return not (self == other)
5208 varun.gupt 24819 
 
5386 phani.kuma 24820 
class updateOrderOnlyAsPaidToVendor_args:
24821 
  """
24822 
  Attributes:
24823 
   - orderId
24824 
  """
24825 
 
24826 
  thrift_spec = (
24827 
    None, # 0
24828 
    (1, TType.I64, 'orderId', None, None, ), # 1
24829 
  )
24830 
 
24831 
  def __init__(self, orderId=None,):
24832 
    self.orderId = orderId
24833 
 
24834 
  def read(self, iprot):
24835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24837 
      return
24838 
    iprot.readStructBegin()
24839 
    while True:
24840 
      (fname, ftype, fid) = iprot.readFieldBegin()
24841 
      if ftype == TType.STOP:
24842 
        break
24843 
      if fid == 1:
24844 
        if ftype == TType.I64:
24845 
          self.orderId = iprot.readI64();
24846 
        else:
24847 
          iprot.skip(ftype)
24848 
      else:
24849 
        iprot.skip(ftype)
24850 
      iprot.readFieldEnd()
24851 
    iprot.readStructEnd()
24852 
 
24853 
  def write(self, oprot):
24854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24856 
      return
24857 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24858 
    if self.orderId is not None:
24859 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24860 
      oprot.writeI64(self.orderId)
24861 
      oprot.writeFieldEnd()
24862 
    oprot.writeFieldStop()
24863 
    oprot.writeStructEnd()
24864 
 
24865 
  def validate(self):
24866 
    return
24867 
 
24868 
 
24869 
  def __repr__(self):
24870 
    L = ['%s=%r' % (key, value)
24871 
      for key, value in self.__dict__.iteritems()]
24872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24873 
 
24874 
  def __eq__(self, other):
24875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24876 
 
24877 
  def __ne__(self, other):
24878 
    return not (self == other)
24879 
 
24880 
class updateOrderOnlyAsPaidToVendor_result:
24881 
  """
24882 
  Attributes:
24883 
   - ex
24884 
  """
24885 
 
24886 
  thrift_spec = (
24887 
    None, # 0
24888 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24889 
  )
24890 
 
24891 
  def __init__(self, ex=None,):
24892 
    self.ex = ex
24893 
 
24894 
  def read(self, iprot):
24895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24897 
      return
24898 
    iprot.readStructBegin()
24899 
    while True:
24900 
      (fname, ftype, fid) = iprot.readFieldBegin()
24901 
      if ftype == TType.STOP:
24902 
        break
24903 
      if fid == 1:
24904 
        if ftype == TType.STRUCT:
24905 
          self.ex = TransactionServiceException()
24906 
          self.ex.read(iprot)
24907 
        else:
24908 
          iprot.skip(ftype)
24909 
      else:
24910 
        iprot.skip(ftype)
24911 
      iprot.readFieldEnd()
24912 
    iprot.readStructEnd()
24913 
 
24914 
  def write(self, oprot):
24915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24917 
      return
24918 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24919 
    if self.ex is not None:
24920 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24921 
      self.ex.write(oprot)
24922 
      oprot.writeFieldEnd()
24923 
    oprot.writeFieldStop()
24924 
    oprot.writeStructEnd()
24925 
 
24926 
  def validate(self):
24927 
    return
24928 
 
24929 
 
24930 
  def __repr__(self):
24931 
    L = ['%s=%r' % (key, value)
24932 
      for key, value in self.__dict__.iteritems()]
24933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24934 
 
24935 
  def __eq__(self, other):
24936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24937 
 
24938 
  def __ne__(self, other):
24939 
    return not (self == other)
24940 
 
5208 varun.gupt 24941 
class getRefundedOrdersMarkedPaid_args:
24942 
 
24943 
  thrift_spec = (
24944 
  )
24945 
 
24946 
  def read(self, iprot):
24947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24949 
      return
24950 
    iprot.readStructBegin()
24951 
    while True:
24952 
      (fname, ftype, fid) = iprot.readFieldBegin()
24953 
      if ftype == TType.STOP:
24954 
        break
24955 
      else:
24956 
        iprot.skip(ftype)
24957 
      iprot.readFieldEnd()
24958 
    iprot.readStructEnd()
24959 
 
24960 
  def write(self, oprot):
24961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24963 
      return
24964 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24965 
    oprot.writeFieldStop()
24966 
    oprot.writeStructEnd()
24967 
 
24968 
  def validate(self):
24969 
    return
24970 
 
24971 
 
24972 
  def __repr__(self):
24973 
    L = ['%s=%r' % (key, value)
24974 
      for key, value in self.__dict__.iteritems()]
24975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24976 
 
24977 
  def __eq__(self, other):
24978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24979 
 
24980 
  def __ne__(self, other):
24981 
    return not (self == other)
24982 
 
24983 
class getRefundedOrdersMarkedPaid_result:
24984 
  """
24985 
  Attributes:
24986 
   - success
24987 
   - ex
24988 
  """
24989 
 
24990 
  thrift_spec = (
24991 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24992 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24993 
  )
24994 
 
24995 
  def __init__(self, success=None, ex=None,):
24996 
    self.success = success
24997 
    self.ex = ex
24998 
 
24999 
  def read(self, iprot):
25000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25002 
      return
25003 
    iprot.readStructBegin()
25004 
    while True:
25005 
      (fname, ftype, fid) = iprot.readFieldBegin()
25006 
      if ftype == TType.STOP:
25007 
        break
25008 
      if fid == 0:
25009 
        if ftype == TType.LIST:
25010 
          self.success = []
6188 rajveer 25011 
          (_etype610, _size607) = iprot.readListBegin()
25012 
          for _i611 in xrange(_size607):
25013 
            _elem612 = Order()
25014 
            _elem612.read(iprot)
25015 
            self.success.append(_elem612)
5208 varun.gupt 25016 
          iprot.readListEnd()
25017 
        else:
25018 
          iprot.skip(ftype)
25019 
      elif fid == 1:
25020 
        if ftype == TType.STRUCT:
25021 
          self.ex = TransactionServiceException()
25022 
          self.ex.read(iprot)
25023 
        else:
25024 
          iprot.skip(ftype)
25025 
      else:
25026 
        iprot.skip(ftype)
25027 
      iprot.readFieldEnd()
25028 
    iprot.readStructEnd()
25029 
 
25030 
  def write(self, oprot):
25031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25033 
      return
25034 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25035 
    if self.success is not None:
25036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25037 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25038 
      for iter613 in self.success:
25039 
        iter613.write(oprot)
5208 varun.gupt 25040 
      oprot.writeListEnd()
25041 
      oprot.writeFieldEnd()
25042 
    if self.ex is not None:
25043 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25044 
      self.ex.write(oprot)
25045 
      oprot.writeFieldEnd()
25046 
    oprot.writeFieldStop()
25047 
    oprot.writeStructEnd()
25048 
 
25049 
  def validate(self):
25050 
    return
25051 
 
25052 
 
25053 
  def __repr__(self):
25054 
    L = ['%s=%r' % (key, value)
25055 
      for key, value in self.__dict__.iteritems()]
25056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25057 
 
25058 
  def __eq__(self, other):
25059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25060 
 
25061 
  def __ne__(self, other):
25062 
    return not (self == other)
5447 anupam.sin 25063 
 
25064 
class getAllVerificationAgents_args:
25065 
  """
25066 
  Attributes:
25067 
   - minOrderId
25068 
   - maxOrderId
25069 
  """
25070 
 
25071 
  thrift_spec = (
25072 
    None, # 0
25073 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25074 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25075 
  )
25076 
 
25077 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25078 
    self.minOrderId = minOrderId
25079 
    self.maxOrderId = maxOrderId
25080 
 
25081 
  def read(self, iprot):
25082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25084 
      return
25085 
    iprot.readStructBegin()
25086 
    while True:
25087 
      (fname, ftype, fid) = iprot.readFieldBegin()
25088 
      if ftype == TType.STOP:
25089 
        break
25090 
      if fid == 1:
25091 
        if ftype == TType.I64:
25092 
          self.minOrderId = iprot.readI64();
25093 
        else:
25094 
          iprot.skip(ftype)
25095 
      elif fid == 2:
25096 
        if ftype == TType.I64:
25097 
          self.maxOrderId = iprot.readI64();
25098 
        else:
25099 
          iprot.skip(ftype)
25100 
      else:
25101 
        iprot.skip(ftype)
25102 
      iprot.readFieldEnd()
25103 
    iprot.readStructEnd()
25104 
 
25105 
  def write(self, oprot):
25106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25108 
      return
25109 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25110 
    if self.minOrderId is not None:
25111 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25112 
      oprot.writeI64(self.minOrderId)
25113 
      oprot.writeFieldEnd()
25114 
    if self.maxOrderId is not None:
25115 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25116 
      oprot.writeI64(self.maxOrderId)
25117 
      oprot.writeFieldEnd()
25118 
    oprot.writeFieldStop()
25119 
    oprot.writeStructEnd()
25120 
 
25121 
  def validate(self):
25122 
    return
25123 
 
25124 
 
25125 
  def __repr__(self):
25126 
    L = ['%s=%r' % (key, value)
25127 
      for key, value in self.__dict__.iteritems()]
25128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25129 
 
25130 
  def __eq__(self, other):
25131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25132 
 
25133 
  def __ne__(self, other):
25134 
    return not (self == other)
25135 
 
25136 
class getAllVerificationAgents_result:
25137 
  """
25138 
  Attributes:
25139 
   - success
25140 
  """
25141 
 
25142 
  thrift_spec = (
25143 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25144 
  )
25145 
 
25146 
  def __init__(self, success=None,):
25147 
    self.success = success
25148 
 
25149 
  def read(self, iprot):
25150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25152 
      return
25153 
    iprot.readStructBegin()
25154 
    while True:
25155 
      (fname, ftype, fid) = iprot.readFieldBegin()
25156 
      if ftype == TType.STOP:
25157 
        break
25158 
      if fid == 0:
25159 
        if ftype == TType.LIST:
25160 
          self.success = []
6188 rajveer 25161 
          (_etype617, _size614) = iprot.readListBegin()
25162 
          for _i618 in xrange(_size614):
25163 
            _elem619 = CODVerificationAgent()
25164 
            _elem619.read(iprot)
25165 
            self.success.append(_elem619)
5447 anupam.sin 25166 
          iprot.readListEnd()
25167 
        else:
25168 
          iprot.skip(ftype)
25169 
      else:
25170 
        iprot.skip(ftype)
25171 
      iprot.readFieldEnd()
25172 
    iprot.readStructEnd()
25173 
 
25174 
  def write(self, oprot):
25175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25177 
      return
25178 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25179 
    if self.success is not None:
25180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25182 
      for iter620 in self.success:
25183 
        iter620.write(oprot)
5447 anupam.sin 25184 
      oprot.writeListEnd()
25185 
      oprot.writeFieldEnd()
25186 
    oprot.writeFieldStop()
25187 
    oprot.writeStructEnd()
25188 
 
25189 
  def validate(self):
25190 
    return
25191 
 
25192 
 
25193 
  def __repr__(self):
25194 
    L = ['%s=%r' % (key, value)
25195 
      for key, value in self.__dict__.iteritems()]
25196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25197 
 
25198 
  def __eq__(self, other):
25199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25200 
 
25201 
  def __ne__(self, other):
25202 
    return not (self == other)
5527 anupam.sin 25203 
 
25204 
class getAllAttributesForOrderId_args:
25205 
  """
25206 
  Attributes:
25207 
   - orderId
25208 
  """
25209 
 
25210 
  thrift_spec = (
25211 
    None, # 0
25212 
    (1, TType.I64, 'orderId', None, None, ), # 1
25213 
  )
25214 
 
25215 
  def __init__(self, orderId=None,):
25216 
    self.orderId = orderId
25217 
 
25218 
  def read(self, iprot):
25219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25221 
      return
25222 
    iprot.readStructBegin()
25223 
    while True:
25224 
      (fname, ftype, fid) = iprot.readFieldBegin()
25225 
      if ftype == TType.STOP:
25226 
        break
25227 
      if fid == 1:
25228 
        if ftype == TType.I64:
25229 
          self.orderId = iprot.readI64();
25230 
        else:
25231 
          iprot.skip(ftype)
25232 
      else:
25233 
        iprot.skip(ftype)
25234 
      iprot.readFieldEnd()
25235 
    iprot.readStructEnd()
25236 
 
25237 
  def write(self, oprot):
25238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25240 
      return
25241 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25242 
    if self.orderId is not None:
25243 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25244 
      oprot.writeI64(self.orderId)
25245 
      oprot.writeFieldEnd()
25246 
    oprot.writeFieldStop()
25247 
    oprot.writeStructEnd()
25248 
 
25249 
  def validate(self):
25250 
    return
25251 
 
25252 
 
25253 
  def __repr__(self):
25254 
    L = ['%s=%r' % (key, value)
25255 
      for key, value in self.__dict__.iteritems()]
25256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25257 
 
25258 
  def __eq__(self, other):
25259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25260 
 
25261 
  def __ne__(self, other):
25262 
    return not (self == other)
25263 
 
25264 
class getAllAttributesForOrderId_result:
25265 
  """
25266 
  Attributes:
25267 
   - success
25268 
  """
25269 
 
25270 
  thrift_spec = (
25271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25272 
  )
25273 
 
25274 
  def __init__(self, success=None,):
25275 
    self.success = success
25276 
 
25277 
  def read(self, iprot):
25278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25280 
      return
25281 
    iprot.readStructBegin()
25282 
    while True:
25283 
      (fname, ftype, fid) = iprot.readFieldBegin()
25284 
      if ftype == TType.STOP:
25285 
        break
25286 
      if fid == 0:
25287 
        if ftype == TType.LIST:
25288 
          self.success = []
6188 rajveer 25289 
          (_etype624, _size621) = iprot.readListBegin()
25290 
          for _i625 in xrange(_size621):
25291 
            _elem626 = Attribute()
25292 
            _elem626.read(iprot)
25293 
            self.success.append(_elem626)
5527 anupam.sin 25294 
          iprot.readListEnd()
25295 
        else:
25296 
          iprot.skip(ftype)
25297 
      else:
25298 
        iprot.skip(ftype)
25299 
      iprot.readFieldEnd()
25300 
    iprot.readStructEnd()
25301 
 
25302 
  def write(self, oprot):
25303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25305 
      return
25306 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25307 
    if self.success is not None:
25308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25310 
      for iter627 in self.success:
25311 
        iter627.write(oprot)
5527 anupam.sin 25312 
      oprot.writeListEnd()
25313 
      oprot.writeFieldEnd()
25314 
    oprot.writeFieldStop()
25315 
    oprot.writeStructEnd()
25316 
 
25317 
  def validate(self):
25318 
    return
25319 
 
25320 
 
25321 
  def __repr__(self):
25322 
    L = ['%s=%r' % (key, value)
25323 
      for key, value in self.__dict__.iteritems()]
25324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25325 
 
25326 
  def __eq__(self, other):
25327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25328 
 
25329 
  def __ne__(self, other):
25330 
    return not (self == other)
25331 
 
5676 rajveer 25332 
class setOrderAttributes_args:
25333 
  """
25334 
  Attributes:
25335 
   - orderId
25336 
   - attributes
25337 
  """
25338 
 
25339 
  thrift_spec = None
25340 
  def __init__(self, orderId=None, attributes=None,):
25341 
    self.orderId = orderId
25342 
    self.attributes = attributes
25343 
 
25344 
  def read(self, iprot):
25345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25347 
      return
25348 
    iprot.readStructBegin()
25349 
    while True:
25350 
      (fname, ftype, fid) = iprot.readFieldBegin()
25351 
      if ftype == TType.STOP:
25352 
        break
25353 
      if fid == 1:
25354 
        if ftype == TType.I64:
25355 
          self.orderId = iprot.readI64();
25356 
        else:
25357 
          iprot.skip(ftype)
25358 
      elif fid == -1:
25359 
        if ftype == TType.LIST:
25360 
          self.attributes = []
6188 rajveer 25361 
          (_etype631, _size628) = iprot.readListBegin()
25362 
          for _i632 in xrange(_size628):
25363 
            _elem633 = Attribute()
25364 
            _elem633.read(iprot)
25365 
            self.attributes.append(_elem633)
5676 rajveer 25366 
          iprot.readListEnd()
25367 
        else:
25368 
          iprot.skip(ftype)
25369 
      else:
25370 
        iprot.skip(ftype)
25371 
      iprot.readFieldEnd()
25372 
    iprot.readStructEnd()
25373 
 
25374 
  def write(self, oprot):
25375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25377 
      return
25378 
    oprot.writeStructBegin('setOrderAttributes_args')
25379 
    if self.attributes is not None:
25380 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25381 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25382 
      for iter634 in self.attributes:
25383 
        iter634.write(oprot)
5676 rajveer 25384 
      oprot.writeListEnd()
25385 
      oprot.writeFieldEnd()
25386 
    if self.orderId is not None:
25387 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25388 
      oprot.writeI64(self.orderId)
25389 
      oprot.writeFieldEnd()
25390 
    oprot.writeFieldStop()
25391 
    oprot.writeStructEnd()
25392 
 
25393 
  def validate(self):
25394 
    return
25395 
 
25396 
 
25397 
  def __repr__(self):
25398 
    L = ['%s=%r' % (key, value)
25399 
      for key, value in self.__dict__.iteritems()]
25400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25401 
 
25402 
  def __eq__(self, other):
25403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25404 
 
25405 
  def __ne__(self, other):
25406 
    return not (self == other)
25407 
 
25408 
class setOrderAttributes_result:
25409 
 
25410 
  thrift_spec = (
25411 
  )
25412 
 
25413 
  def read(self, iprot):
25414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25416 
      return
25417 
    iprot.readStructBegin()
25418 
    while True:
25419 
      (fname, ftype, fid) = iprot.readFieldBegin()
25420 
      if ftype == TType.STOP:
25421 
        break
25422 
      else:
25423 
        iprot.skip(ftype)
25424 
      iprot.readFieldEnd()
25425 
    iprot.readStructEnd()
25426 
 
25427 
  def write(self, oprot):
25428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25430 
      return
25431 
    oprot.writeStructBegin('setOrderAttributes_result')
25432 
    oprot.writeFieldStop()
25433 
    oprot.writeStructEnd()
25434 
 
25435 
  def validate(self):
25436 
    return
25437 
 
25438 
 
25439 
  def __repr__(self):
25440 
    L = ['%s=%r' % (key, value)
25441 
      for key, value in self.__dict__.iteritems()]
25442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25443 
 
25444 
  def __eq__(self, other):
25445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25446 
 
25447 
  def __ne__(self, other):
25448 
    return not (self == other)
25449 
 
5527 anupam.sin 25450 
class setOrderAttributeForTransaction_args:
25451 
  """
25452 
  Attributes:
25453 
   - transactionId
25454 
   - attribute
25455 
  """
25456 
 
25457 
  thrift_spec = None
25458 
  def __init__(self, transactionId=None, attribute=None,):
25459 
    self.transactionId = transactionId
25460 
    self.attribute = attribute
25461 
 
25462 
  def read(self, iprot):
25463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25465 
      return
25466 
    iprot.readStructBegin()
25467 
    while True:
25468 
      (fname, ftype, fid) = iprot.readFieldBegin()
25469 
      if ftype == TType.STOP:
25470 
        break
25471 
      if fid == 1:
25472 
        if ftype == TType.I64:
25473 
          self.transactionId = iprot.readI64();
25474 
        else:
25475 
          iprot.skip(ftype)
25476 
      elif fid == -1:
25477 
        if ftype == TType.STRUCT:
25478 
          self.attribute = Attribute()
25479 
          self.attribute.read(iprot)
25480 
        else:
25481 
          iprot.skip(ftype)
25482 
      else:
25483 
        iprot.skip(ftype)
25484 
      iprot.readFieldEnd()
25485 
    iprot.readStructEnd()
25486 
 
25487 
  def write(self, oprot):
25488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25490 
      return
25491 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25492 
    if self.attribute is not None:
25493 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25494 
      self.attribute.write(oprot)
25495 
      oprot.writeFieldEnd()
25496 
    if self.transactionId is not None:
25497 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25498 
      oprot.writeI64(self.transactionId)
25499 
      oprot.writeFieldEnd()
25500 
    oprot.writeFieldStop()
25501 
    oprot.writeStructEnd()
25502 
 
25503 
  def validate(self):
25504 
    return
25505 
 
25506 
 
25507 
  def __repr__(self):
25508 
    L = ['%s=%r' % (key, value)
25509 
      for key, value in self.__dict__.iteritems()]
25510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25511 
 
25512 
  def __eq__(self, other):
25513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25514 
 
25515 
  def __ne__(self, other):
25516 
    return not (self == other)
25517 
 
25518 
class setOrderAttributeForTransaction_result:
25519 
 
25520 
  thrift_spec = (
25521 
  )
25522 
 
25523 
  def read(self, iprot):
25524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25526 
      return
25527 
    iprot.readStructBegin()
25528 
    while True:
25529 
      (fname, ftype, fid) = iprot.readFieldBegin()
25530 
      if ftype == TType.STOP:
25531 
        break
25532 
      else:
25533 
        iprot.skip(ftype)
25534 
      iprot.readFieldEnd()
25535 
    iprot.readStructEnd()
25536 
 
25537 
  def write(self, oprot):
25538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25540 
      return
25541 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25542 
    oprot.writeFieldStop()
25543 
    oprot.writeStructEnd()
25544 
 
25545 
  def validate(self):
25546 
    return
25547 
 
25548 
 
25549 
  def __repr__(self):
25550 
    L = ['%s=%r' % (key, value)
25551 
      for key, value in self.__dict__.iteritems()]
25552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25553 
 
25554 
  def __eq__(self, other):
25555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25556 
 
25557 
  def __ne__(self, other):
25558 
    return not (self == other)
5553 rajveer 25559 
 
25560 
class getReceivePendingOrders_args:
25561 
  """
25562 
  Attributes:
25563 
   - storeId
25564 
  """
25565 
 
25566 
  thrift_spec = (
25567 
    None, # 0
25568 
    (1, TType.I64, 'storeId', None, None, ), # 1
25569 
  )
25570 
 
25571 
  def __init__(self, storeId=None,):
25572 
    self.storeId = storeId
25573 
 
25574 
  def read(self, iprot):
25575 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25576 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25577 
      return
25578 
    iprot.readStructBegin()
25579 
    while True:
25580 
      (fname, ftype, fid) = iprot.readFieldBegin()
25581 
      if ftype == TType.STOP:
25582 
        break
25583 
      if fid == 1:
25584 
        if ftype == TType.I64:
25585 
          self.storeId = iprot.readI64();
25586 
        else:
25587 
          iprot.skip(ftype)
25588 
      else:
25589 
        iprot.skip(ftype)
25590 
      iprot.readFieldEnd()
25591 
    iprot.readStructEnd()
25592 
 
25593 
  def write(self, oprot):
25594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25596 
      return
25597 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25598 
    if self.storeId is not None:
25599 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25600 
      oprot.writeI64(self.storeId)
25601 
      oprot.writeFieldEnd()
25602 
    oprot.writeFieldStop()
25603 
    oprot.writeStructEnd()
25604 
 
25605 
  def validate(self):
25606 
    return
25607 
 
25608 
 
25609 
  def __repr__(self):
25610 
    L = ['%s=%r' % (key, value)
25611 
      for key, value in self.__dict__.iteritems()]
25612 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25613 
 
25614 
  def __eq__(self, other):
25615 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25616 
 
25617 
  def __ne__(self, other):
25618 
    return not (self == other)
25619 
 
25620 
class getReceivePendingOrders_result:
25621 
  """
25622 
  Attributes:
25623 
   - success
25624 
  """
25625 
 
25626 
  thrift_spec = (
25627 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25628 
  )
25629 
 
25630 
  def __init__(self, success=None,):
25631 
    self.success = success
25632 
 
25633 
  def read(self, iprot):
25634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25636 
      return
25637 
    iprot.readStructBegin()
25638 
    while True:
25639 
      (fname, ftype, fid) = iprot.readFieldBegin()
25640 
      if ftype == TType.STOP:
25641 
        break
25642 
      if fid == 0:
25643 
        if ftype == TType.LIST:
25644 
          self.success = []
6188 rajveer 25645 
          (_etype638, _size635) = iprot.readListBegin()
25646 
          for _i639 in xrange(_size635):
25647 
            _elem640 = Order()
25648 
            _elem640.read(iprot)
25649 
            self.success.append(_elem640)
5553 rajveer 25650 
          iprot.readListEnd()
25651 
        else:
25652 
          iprot.skip(ftype)
25653 
      else:
25654 
        iprot.skip(ftype)
25655 
      iprot.readFieldEnd()
25656 
    iprot.readStructEnd()
25657 
 
25658 
  def write(self, oprot):
25659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25661 
      return
25662 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25663 
    if self.success is not None:
25664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25666 
      for iter641 in self.success:
25667 
        iter641.write(oprot)
5553 rajveer 25668 
      oprot.writeListEnd()
25669 
      oprot.writeFieldEnd()
25670 
    oprot.writeFieldStop()
25671 
    oprot.writeStructEnd()
25672 
 
25673 
  def validate(self):
25674 
    return
25675 
 
25676 
 
25677 
  def __repr__(self):
25678 
    L = ['%s=%r' % (key, value)
25679 
      for key, value in self.__dict__.iteritems()]
25680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25681 
 
25682 
  def __eq__(self, other):
25683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25684 
 
25685 
  def __ne__(self, other):
25686 
    return not (self == other)
25687 
 
25688 
class getReceivedAtStoreOrders_args:
25689 
  """
25690 
  Attributes:
25691 
   - storeId
25692 
  """
25693 
 
25694 
  thrift_spec = (
25695 
    None, # 0
25696 
    (1, TType.I64, 'storeId', None, None, ), # 1
25697 
  )
25698 
 
25699 
  def __init__(self, storeId=None,):
25700 
    self.storeId = storeId
25701 
 
25702 
  def read(self, iprot):
25703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25705 
      return
25706 
    iprot.readStructBegin()
25707 
    while True:
25708 
      (fname, ftype, fid) = iprot.readFieldBegin()
25709 
      if ftype == TType.STOP:
25710 
        break
25711 
      if fid == 1:
25712 
        if ftype == TType.I64:
25713 
          self.storeId = iprot.readI64();
25714 
        else:
25715 
          iprot.skip(ftype)
25716 
      else:
25717 
        iprot.skip(ftype)
25718 
      iprot.readFieldEnd()
25719 
    iprot.readStructEnd()
25720 
 
25721 
  def write(self, oprot):
25722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25724 
      return
25725 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25726 
    if self.storeId is not None:
25727 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25728 
      oprot.writeI64(self.storeId)
25729 
      oprot.writeFieldEnd()
25730 
    oprot.writeFieldStop()
25731 
    oprot.writeStructEnd()
25732 
 
25733 
  def validate(self):
25734 
    return
25735 
 
25736 
 
25737 
  def __repr__(self):
25738 
    L = ['%s=%r' % (key, value)
25739 
      for key, value in self.__dict__.iteritems()]
25740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25741 
 
25742 
  def __eq__(self, other):
25743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25744 
 
25745 
  def __ne__(self, other):
25746 
    return not (self == other)
25747 
 
25748 
class getReceivedAtStoreOrders_result:
25749 
  """
25750 
  Attributes:
25751 
   - success
25752 
  """
25753 
 
25754 
  thrift_spec = (
25755 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25756 
  )
25757 
 
25758 
  def __init__(self, success=None,):
25759 
    self.success = success
25760 
 
25761 
  def read(self, iprot):
25762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25764 
      return
25765 
    iprot.readStructBegin()
25766 
    while True:
25767 
      (fname, ftype, fid) = iprot.readFieldBegin()
25768 
      if ftype == TType.STOP:
25769 
        break
25770 
      if fid == 0:
25771 
        if ftype == TType.LIST:
25772 
          self.success = []
6188 rajveer 25773 
          (_etype645, _size642) = iprot.readListBegin()
25774 
          for _i646 in xrange(_size642):
25775 
            _elem647 = Order()
25776 
            _elem647.read(iprot)
25777 
            self.success.append(_elem647)
5553 rajveer 25778 
          iprot.readListEnd()
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('getReceivedAtStoreOrders_result')
25791 
    if self.success is not None:
25792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25794 
      for iter648 in self.success:
25795 
        iter648.write(oprot)
5553 rajveer 25796 
      oprot.writeListEnd()
25797 
      oprot.writeFieldEnd()
25798 
    oprot.writeFieldStop()
25799 
    oprot.writeStructEnd()
25800 
 
25801 
  def validate(self):
25802 
    return
25803 
 
25804 
 
25805 
  def __repr__(self):
25806 
    L = ['%s=%r' % (key, value)
25807 
      for key, value in self.__dict__.iteritems()]
25808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25809 
 
25810 
  def __eq__(self, other):
25811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25812 
 
25813 
  def __ne__(self, other):
25814 
    return not (self == other)
5593 mandeep.dh 25815 
 
5713 rajveer 25816 
class getOrdersCollectionAtStore_args:
25817 
  """
25818 
  Attributes:
25819 
   - storeId
25820 
   - fromDate
25821 
   - toDate
25822 
   - onlyCod
25823 
  """
25824 
 
25825 
  thrift_spec = (
25826 
    None, # 0
25827 
    (1, TType.I64, 'storeId', None, None, ), # 1
25828 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25829 
    (3, TType.I64, 'toDate', None, None, ), # 3
25830 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25831 
  )
25832 
 
25833 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25834 
    self.storeId = storeId
25835 
    self.fromDate = fromDate
25836 
    self.toDate = toDate
25837 
    self.onlyCod = onlyCod
25838 
 
25839 
  def read(self, iprot):
25840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25842 
      return
25843 
    iprot.readStructBegin()
25844 
    while True:
25845 
      (fname, ftype, fid) = iprot.readFieldBegin()
25846 
      if ftype == TType.STOP:
25847 
        break
25848 
      if fid == 1:
25849 
        if ftype == TType.I64:
25850 
          self.storeId = iprot.readI64();
25851 
        else:
25852 
          iprot.skip(ftype)
25853 
      elif fid == 2:
25854 
        if ftype == TType.I64:
25855 
          self.fromDate = iprot.readI64();
25856 
        else:
25857 
          iprot.skip(ftype)
25858 
      elif fid == 3:
25859 
        if ftype == TType.I64:
25860 
          self.toDate = iprot.readI64();
25861 
        else:
25862 
          iprot.skip(ftype)
25863 
      elif fid == 4:
25864 
        if ftype == TType.BOOL:
25865 
          self.onlyCod = iprot.readBool();
25866 
        else:
25867 
          iprot.skip(ftype)
25868 
      else:
25869 
        iprot.skip(ftype)
25870 
      iprot.readFieldEnd()
25871 
    iprot.readStructEnd()
25872 
 
25873 
  def write(self, oprot):
25874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25876 
      return
25877 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25878 
    if self.storeId is not None:
25879 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25880 
      oprot.writeI64(self.storeId)
25881 
      oprot.writeFieldEnd()
25882 
    if self.fromDate is not None:
25883 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25884 
      oprot.writeI64(self.fromDate)
25885 
      oprot.writeFieldEnd()
25886 
    if self.toDate is not None:
25887 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25888 
      oprot.writeI64(self.toDate)
25889 
      oprot.writeFieldEnd()
25890 
    if self.onlyCod is not None:
25891 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25892 
      oprot.writeBool(self.onlyCod)
25893 
      oprot.writeFieldEnd()
25894 
    oprot.writeFieldStop()
25895 
    oprot.writeStructEnd()
25896 
 
25897 
  def validate(self):
25898 
    return
25899 
 
25900 
 
25901 
  def __repr__(self):
25902 
    L = ['%s=%r' % (key, value)
25903 
      for key, value in self.__dict__.iteritems()]
25904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25905 
 
25906 
  def __eq__(self, other):
25907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25908 
 
25909 
  def __ne__(self, other):
25910 
    return not (self == other)
25911 
 
25912 
class getOrdersCollectionAtStore_result:
25913 
  """
25914 
  Attributes:
25915 
   - success
25916 
  """
25917 
 
25918 
  thrift_spec = (
25919 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25920 
  )
25921 
 
25922 
  def __init__(self, success=None,):
25923 
    self.success = success
25924 
 
25925 
  def read(self, iprot):
25926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25928 
      return
25929 
    iprot.readStructBegin()
25930 
    while True:
25931 
      (fname, ftype, fid) = iprot.readFieldBegin()
25932 
      if ftype == TType.STOP:
25933 
        break
25934 
      if fid == 0:
25935 
        if ftype == TType.LIST:
25936 
          self.success = []
6188 rajveer 25937 
          (_etype652, _size649) = iprot.readListBegin()
25938 
          for _i653 in xrange(_size649):
25939 
            _elem654 = Order()
25940 
            _elem654.read(iprot)
25941 
            self.success.append(_elem654)
5713 rajveer 25942 
          iprot.readListEnd()
25943 
        else:
25944 
          iprot.skip(ftype)
25945 
      else:
25946 
        iprot.skip(ftype)
25947 
      iprot.readFieldEnd()
25948 
    iprot.readStructEnd()
25949 
 
25950 
  def write(self, oprot):
25951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25953 
      return
25954 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25955 
    if self.success is not None:
25956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25957 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25958 
      for iter655 in self.success:
25959 
        iter655.write(oprot)
5713 rajveer 25960 
      oprot.writeListEnd()
25961 
      oprot.writeFieldEnd()
25962 
    oprot.writeFieldStop()
25963 
    oprot.writeStructEnd()
25964 
 
25965 
  def validate(self):
25966 
    return
25967 
 
25968 
 
25969 
  def __repr__(self):
25970 
    L = ['%s=%r' % (key, value)
25971 
      for key, value in self.__dict__.iteritems()]
25972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25973 
 
25974 
  def __eq__(self, other):
25975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25976 
 
25977 
  def __ne__(self, other):
25978 
    return not (self == other)
25979 
 
5833 rajveer 25980 
class getOrderAttributeValue_args:
25981 
  """
25982 
  Attributes:
25983 
   - orderId
25984 
   - attributeName
25985 
  """
25986 
 
25987 
  thrift_spec = None
25988 
  def __init__(self, orderId=None, attributeName=None,):
25989 
    self.orderId = orderId
25990 
    self.attributeName = attributeName
25991 
 
25992 
  def read(self, iprot):
25993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25995 
      return
25996 
    iprot.readStructBegin()
25997 
    while True:
25998 
      (fname, ftype, fid) = iprot.readFieldBegin()
25999 
      if ftype == TType.STOP:
26000 
        break
26001 
      if fid == 1:
26002 
        if ftype == TType.I64:
26003 
          self.orderId = iprot.readI64();
26004 
        else:
26005 
          iprot.skip(ftype)
26006 
      elif fid == -1:
26007 
        if ftype == TType.STRING:
26008 
          self.attributeName = iprot.readString();
26009 
        else:
26010 
          iprot.skip(ftype)
26011 
      else:
26012 
        iprot.skip(ftype)
26013 
      iprot.readFieldEnd()
26014 
    iprot.readStructEnd()
26015 
 
26016 
  def write(self, oprot):
26017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26019 
      return
26020 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26021 
    if self.attributeName is not None:
26022 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26023 
      oprot.writeString(self.attributeName)
26024 
      oprot.writeFieldEnd()
26025 
    if self.orderId is not None:
26026 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26027 
      oprot.writeI64(self.orderId)
26028 
      oprot.writeFieldEnd()
26029 
    oprot.writeFieldStop()
26030 
    oprot.writeStructEnd()
26031 
 
26032 
  def validate(self):
26033 
    return
26034 
 
26035 
 
26036 
  def __repr__(self):
26037 
    L = ['%s=%r' % (key, value)
26038 
      for key, value in self.__dict__.iteritems()]
26039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26040 
 
26041 
  def __eq__(self, other):
26042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26043 
 
26044 
  def __ne__(self, other):
26045 
    return not (self == other)
26046 
 
26047 
class getOrderAttributeValue_result:
26048 
  """
26049 
  Attributes:
26050 
   - success
26051 
  """
26052 
 
26053 
  thrift_spec = (
26054 
    (0, TType.STRING, 'success', None, None, ), # 0
26055 
  )
26056 
 
26057 
  def __init__(self, success=None,):
26058 
    self.success = success
26059 
 
26060 
  def read(self, iprot):
26061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26063 
      return
26064 
    iprot.readStructBegin()
26065 
    while True:
26066 
      (fname, ftype, fid) = iprot.readFieldBegin()
26067 
      if ftype == TType.STOP:
26068 
        break
26069 
      if fid == 0:
26070 
        if ftype == TType.STRING:
26071 
          self.success = iprot.readString();
26072 
        else:
26073 
          iprot.skip(ftype)
26074 
      else:
26075 
        iprot.skip(ftype)
26076 
      iprot.readFieldEnd()
26077 
    iprot.readStructEnd()
26078 
 
26079 
  def write(self, oprot):
26080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26082 
      return
26083 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26084 
    if self.success is not None:
26085 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26086 
      oprot.writeString(self.success)
26087 
      oprot.writeFieldEnd()
26088 
    oprot.writeFieldStop()
26089 
    oprot.writeStructEnd()
26090 
 
26091 
  def validate(self):
26092 
    return
26093 
 
26094 
 
26095 
  def __repr__(self):
26096 
    L = ['%s=%r' % (key, value)
26097 
      for key, value in self.__dict__.iteritems()]
26098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26099 
 
26100 
  def __eq__(self, other):
26101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26102 
 
26103 
  def __ne__(self, other):
26104 
    return not (self == other)
26105 
 
6019 rajveer 26106 
class changeJacketNumber_args:
26107 
  """
26108 
  Attributes:
26109 
   - orderId
26110 
   - jacketNumber
26111 
  """
26112 
 
26113 
  thrift_spec = (
26114 
    None, # 0
26115 
    (1, TType.I64, 'orderId', None, None, ), # 1
26116 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26117 
  )
26118 
 
26119 
  def __init__(self, orderId=None, jacketNumber=None,):
26120 
    self.orderId = orderId
26121 
    self.jacketNumber = jacketNumber
26122 
 
26123 
  def read(self, iprot):
26124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26126 
      return
26127 
    iprot.readStructBegin()
26128 
    while True:
26129 
      (fname, ftype, fid) = iprot.readFieldBegin()
26130 
      if ftype == TType.STOP:
26131 
        break
26132 
      if fid == 1:
26133 
        if ftype == TType.I64:
26134 
          self.orderId = iprot.readI64();
26135 
        else:
26136 
          iprot.skip(ftype)
26137 
      elif fid == 2:
26138 
        if ftype == TType.I64:
26139 
          self.jacketNumber = iprot.readI64();
26140 
        else:
26141 
          iprot.skip(ftype)
26142 
      else:
26143 
        iprot.skip(ftype)
26144 
      iprot.readFieldEnd()
26145 
    iprot.readStructEnd()
26146 
 
26147 
  def write(self, oprot):
26148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26150 
      return
26151 
    oprot.writeStructBegin('changeJacketNumber_args')
26152 
    if self.orderId is not None:
26153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26154 
      oprot.writeI64(self.orderId)
26155 
      oprot.writeFieldEnd()
26156 
    if self.jacketNumber is not None:
26157 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26158 
      oprot.writeI64(self.jacketNumber)
26159 
      oprot.writeFieldEnd()
26160 
    oprot.writeFieldStop()
26161 
    oprot.writeStructEnd()
26162 
 
26163 
  def validate(self):
26164 
    return
26165 
 
26166 
 
26167 
  def __repr__(self):
26168 
    L = ['%s=%r' % (key, value)
26169 
      for key, value in self.__dict__.iteritems()]
26170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26171 
 
26172 
  def __eq__(self, other):
26173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26174 
 
26175 
  def __ne__(self, other):
26176 
    return not (self == other)
26177 
 
26178 
class changeJacketNumber_result:
26179 
  """
26180 
  Attributes:
26181 
   - success
26182 
  """
26183 
 
26184 
  thrift_spec = (
26185 
    (0, TType.BOOL, 'success', None, None, ), # 0
26186 
  )
26187 
 
26188 
  def __init__(self, success=None,):
26189 
    self.success = success
26190 
 
26191 
  def read(self, iprot):
26192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26194 
      return
26195 
    iprot.readStructBegin()
26196 
    while True:
26197 
      (fname, ftype, fid) = iprot.readFieldBegin()
26198 
      if ftype == TType.STOP:
26199 
        break
26200 
      if fid == 0:
26201 
        if ftype == TType.BOOL:
26202 
          self.success = iprot.readBool();
26203 
        else:
26204 
          iprot.skip(ftype)
26205 
      else:
26206 
        iprot.skip(ftype)
26207 
      iprot.readFieldEnd()
26208 
    iprot.readStructEnd()
26209 
 
26210 
  def write(self, oprot):
26211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26213 
      return
26214 
    oprot.writeStructBegin('changeJacketNumber_result')
26215 
    if self.success is not None:
26216 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26217 
      oprot.writeBool(self.success)
26218 
      oprot.writeFieldEnd()
26219 
    oprot.writeFieldStop()
26220 
    oprot.writeStructEnd()
26221 
 
26222 
  def validate(self):
26223 
    return
26224 
 
26225 
 
26226 
  def __repr__(self):
26227 
    L = ['%s=%r' % (key, value)
26228 
      for key, value in self.__dict__.iteritems()]
26229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26230 
 
26231 
  def __eq__(self, other):
26232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26233 
 
26234 
  def __ne__(self, other):
26235 
    return not (self == other)
26236 
 
26237 
class markOrderAsRtoInTransit_args:
26238 
  """
26239 
  Attributes:
26240 
   - orderId
26241 
  """
26242 
 
26243 
  thrift_spec = (
26244 
    None, # 0
26245 
    (1, TType.I64, 'orderId', None, None, ), # 1
26246 
  )
26247 
 
26248 
  def __init__(self, orderId=None,):
26249 
    self.orderId = orderId
26250 
 
26251 
  def read(self, iprot):
26252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26254 
      return
26255 
    iprot.readStructBegin()
26256 
    while True:
26257 
      (fname, ftype, fid) = iprot.readFieldBegin()
26258 
      if ftype == TType.STOP:
26259 
        break
26260 
      if fid == 1:
26261 
        if ftype == TType.I64:
26262 
          self.orderId = iprot.readI64();
26263 
        else:
26264 
          iprot.skip(ftype)
26265 
      else:
26266 
        iprot.skip(ftype)
26267 
      iprot.readFieldEnd()
26268 
    iprot.readStructEnd()
26269 
 
26270 
  def write(self, oprot):
26271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26273 
      return
26274 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26275 
    if self.orderId is not None:
26276 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26277 
      oprot.writeI64(self.orderId)
26278 
      oprot.writeFieldEnd()
26279 
    oprot.writeFieldStop()
26280 
    oprot.writeStructEnd()
26281 
 
26282 
  def validate(self):
26283 
    return
26284 
 
26285 
 
26286 
  def __repr__(self):
26287 
    L = ['%s=%r' % (key, value)
26288 
      for key, value in self.__dict__.iteritems()]
26289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26290 
 
26291 
  def __eq__(self, other):
26292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26293 
 
26294 
  def __ne__(self, other):
26295 
    return not (self == other)
26296 
 
26297 
class markOrderAsRtoInTransit_result:
26298 
  """
26299 
  Attributes:
26300 
   - success
26301 
  """
26302 
 
26303 
  thrift_spec = (
26304 
    (0, TType.BOOL, 'success', None, None, ), # 0
26305 
  )
26306 
 
26307 
  def __init__(self, success=None,):
26308 
    self.success = success
26309 
 
26310 
  def read(self, iprot):
26311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26313 
      return
26314 
    iprot.readStructBegin()
26315 
    while True:
26316 
      (fname, ftype, fid) = iprot.readFieldBegin()
26317 
      if ftype == TType.STOP:
26318 
        break
26319 
      if fid == 0:
26320 
        if ftype == TType.BOOL:
26321 
          self.success = iprot.readBool();
26322 
        else:
26323 
          iprot.skip(ftype)
26324 
      else:
26325 
        iprot.skip(ftype)
26326 
      iprot.readFieldEnd()
26327 
    iprot.readStructEnd()
26328 
 
26329 
  def write(self, oprot):
26330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26332 
      return
26333 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26334 
    if self.success is not None:
26335 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26336 
      oprot.writeBool(self.success)
26337 
      oprot.writeFieldEnd()
26338 
    oprot.writeFieldStop()
26339 
    oprot.writeStructEnd()
26340 
 
26341 
  def validate(self):
26342 
    return
26343 
 
26344 
 
26345 
  def __repr__(self):
26346 
    L = ['%s=%r' % (key, value)
26347 
      for key, value in self.__dict__.iteritems()]
26348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26349 
 
26350 
  def __eq__(self, other):
26351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26352 
 
26353 
  def __ne__(self, other):
26354 
    return not (self == other)
26355 
 
5593 mandeep.dh 26356 
class acceptOrderForItem_args:
26357 
  """
26358 
  Attributes:
26359 
   - itemId
26360 
   - quantity
26361 
   - fulfilmentWarehouseId
26362 
   - billingWarehouseId
26363 
  """
26364 
 
26365 
  thrift_spec = (
26366 
    None, # 0
26367 
    (1, TType.I64, 'itemId', None, None, ), # 1
26368 
    (2, TType.I64, 'quantity', None, None, ), # 2
26369 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26370 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26371 
  )
26372 
 
26373 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26374 
    self.itemId = itemId
26375 
    self.quantity = quantity
26376 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26377 
    self.billingWarehouseId = billingWarehouseId
26378 
 
26379 
  def read(self, iprot):
26380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26382 
      return
26383 
    iprot.readStructBegin()
26384 
    while True:
26385 
      (fname, ftype, fid) = iprot.readFieldBegin()
26386 
      if ftype == TType.STOP:
26387 
        break
26388 
      if fid == 1:
26389 
        if ftype == TType.I64:
26390 
          self.itemId = iprot.readI64();
26391 
        else:
26392 
          iprot.skip(ftype)
26393 
      elif fid == 2:
26394 
        if ftype == TType.I64:
26395 
          self.quantity = iprot.readI64();
26396 
        else:
26397 
          iprot.skip(ftype)
26398 
      elif fid == 3:
26399 
        if ftype == TType.I64:
26400 
          self.fulfilmentWarehouseId = iprot.readI64();
26401 
        else:
26402 
          iprot.skip(ftype)
26403 
      elif fid == 4:
26404 
        if ftype == TType.I64:
26405 
          self.billingWarehouseId = iprot.readI64();
26406 
        else:
26407 
          iprot.skip(ftype)
26408 
      else:
26409 
        iprot.skip(ftype)
26410 
      iprot.readFieldEnd()
26411 
    iprot.readStructEnd()
26412 
 
26413 
  def write(self, oprot):
26414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26416 
      return
26417 
    oprot.writeStructBegin('acceptOrderForItem_args')
26418 
    if self.itemId is not None:
26419 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26420 
      oprot.writeI64(self.itemId)
26421 
      oprot.writeFieldEnd()
26422 
    if self.quantity is not None:
26423 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26424 
      oprot.writeI64(self.quantity)
26425 
      oprot.writeFieldEnd()
26426 
    if self.fulfilmentWarehouseId is not None:
26427 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26428 
      oprot.writeI64(self.fulfilmentWarehouseId)
26429 
      oprot.writeFieldEnd()
26430 
    if self.billingWarehouseId is not None:
26431 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26432 
      oprot.writeI64(self.billingWarehouseId)
26433 
      oprot.writeFieldEnd()
26434 
    oprot.writeFieldStop()
26435 
    oprot.writeStructEnd()
26436 
 
26437 
  def validate(self):
26438 
    return
26439 
 
26440 
 
26441 
  def __repr__(self):
26442 
    L = ['%s=%r' % (key, value)
26443 
      for key, value in self.__dict__.iteritems()]
26444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26445 
 
26446 
  def __eq__(self, other):
26447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26448 
 
26449 
  def __ne__(self, other):
26450 
    return not (self == other)
26451 
 
26452 
class acceptOrderForItem_result:
26453 
 
26454 
  thrift_spec = (
26455 
  )
26456 
 
26457 
  def read(self, iprot):
26458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26460 
      return
26461 
    iprot.readStructBegin()
26462 
    while True:
26463 
      (fname, ftype, fid) = iprot.readFieldBegin()
26464 
      if ftype == TType.STOP:
26465 
        break
26466 
      else:
26467 
        iprot.skip(ftype)
26468 
      iprot.readFieldEnd()
26469 
    iprot.readStructEnd()
26470 
 
26471 
  def write(self, oprot):
26472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26474 
      return
26475 
    oprot.writeStructBegin('acceptOrderForItem_result')
26476 
    oprot.writeFieldStop()
26477 
    oprot.writeStructEnd()
26478 
 
26479 
  def validate(self):
26480 
    return
26481 
 
26482 
 
26483 
  def __repr__(self):
26484 
    L = ['%s=%r' % (key, value)
26485 
      for key, value in self.__dict__.iteritems()]
26486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26487 
 
26488 
  def __eq__(self, other):
26489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26490 
 
26491 
  def __ne__(self, other):
26492 
    return not (self == other)
6000 mandeep.dh 26493 
 
26494 
class createRechargeOrder_args:
26495 
  """
26496 
  Attributes:
26497 
   - rechargeOrder
26498 
  """
26499 
 
26500 
  thrift_spec = (
26501 
    None, # 0
26502 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26503 
  )
26504 
 
26505 
  def __init__(self, rechargeOrder=None,):
26506 
    self.rechargeOrder = rechargeOrder
26507 
 
26508 
  def read(self, iprot):
26509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26511 
      return
26512 
    iprot.readStructBegin()
26513 
    while True:
26514 
      (fname, ftype, fid) = iprot.readFieldBegin()
26515 
      if ftype == TType.STOP:
26516 
        break
26517 
      if fid == 1:
26518 
        if ftype == TType.STRUCT:
26519 
          self.rechargeOrder = RechargeOrder()
26520 
          self.rechargeOrder.read(iprot)
26521 
        else:
26522 
          iprot.skip(ftype)
26523 
      else:
26524 
        iprot.skip(ftype)
26525 
      iprot.readFieldEnd()
26526 
    iprot.readStructEnd()
26527 
 
26528 
  def write(self, oprot):
26529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26531 
      return
26532 
    oprot.writeStructBegin('createRechargeOrder_args')
26533 
    if self.rechargeOrder is not None:
26534 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26535 
      self.rechargeOrder.write(oprot)
26536 
      oprot.writeFieldEnd()
26537 
    oprot.writeFieldStop()
26538 
    oprot.writeStructEnd()
26539 
 
26540 
  def validate(self):
26541 
    return
26542 
 
26543 
 
26544 
  def __repr__(self):
26545 
    L = ['%s=%r' % (key, value)
26546 
      for key, value in self.__dict__.iteritems()]
26547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26548 
 
26549 
  def __eq__(self, other):
26550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26551 
 
26552 
  def __ne__(self, other):
26553 
    return not (self == other)
26554 
 
26555 
class createRechargeOrder_result:
26556 
  """
26557 
  Attributes:
26558 
   - success
26559 
   - ex
26560 
  """
26561 
 
26562 
  thrift_spec = (
26563 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26565 
  )
26566 
 
26567 
  def __init__(self, success=None, ex=None,):
26568 
    self.success = success
26569 
    self.ex = ex
26570 
 
26571 
  def read(self, iprot):
26572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26574 
      return
26575 
    iprot.readStructBegin()
26576 
    while True:
26577 
      (fname, ftype, fid) = iprot.readFieldBegin()
26578 
      if ftype == TType.STOP:
26579 
        break
26580 
      if fid == 0:
26581 
        if ftype == TType.STRUCT:
26582 
          self.success = RechargeOrder()
26583 
          self.success.read(iprot)
26584 
        else:
26585 
          iprot.skip(ftype)
26586 
      elif fid == 1:
26587 
        if ftype == TType.STRUCT:
26588 
          self.ex = TransactionServiceException()
26589 
          self.ex.read(iprot)
26590 
        else:
26591 
          iprot.skip(ftype)
26592 
      else:
26593 
        iprot.skip(ftype)
26594 
      iprot.readFieldEnd()
26595 
    iprot.readStructEnd()
26596 
 
26597 
  def write(self, oprot):
26598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26600 
      return
26601 
    oprot.writeStructBegin('createRechargeOrder_result')
26602 
    if self.success is not None:
26603 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26604 
      self.success.write(oprot)
26605 
      oprot.writeFieldEnd()
26606 
    if self.ex is not None:
26607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26608 
      self.ex.write(oprot)
26609 
      oprot.writeFieldEnd()
26610 
    oprot.writeFieldStop()
26611 
    oprot.writeStructEnd()
26612 
 
26613 
  def validate(self):
26614 
    return
26615 
 
26616 
 
26617 
  def __repr__(self):
26618 
    L = ['%s=%r' % (key, value)
26619 
      for key, value in self.__dict__.iteritems()]
26620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26621 
 
26622 
  def __eq__(self, other):
26623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26624 
 
26625 
  def __ne__(self, other):
26626 
    return not (self == other)
26627 
 
6031 rajveer 26628 
class getRechargeOrder_args:
26629 
  """
26630 
  Attributes:
26631 
   - rechargeRrderId
26632 
  """
26633 
 
26634 
  thrift_spec = (
26635 
    None, # 0
26636 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26637 
  )
26638 
 
26639 
  def __init__(self, rechargeRrderId=None,):
26640 
    self.rechargeRrderId = rechargeRrderId
26641 
 
26642 
  def read(self, iprot):
26643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26645 
      return
26646 
    iprot.readStructBegin()
26647 
    while True:
26648 
      (fname, ftype, fid) = iprot.readFieldBegin()
26649 
      if ftype == TType.STOP:
26650 
        break
26651 
      if fid == 1:
26652 
        if ftype == TType.I64:
26653 
          self.rechargeRrderId = iprot.readI64();
26654 
        else:
26655 
          iprot.skip(ftype)
26656 
      else:
26657 
        iprot.skip(ftype)
26658 
      iprot.readFieldEnd()
26659 
    iprot.readStructEnd()
26660 
 
26661 
  def write(self, oprot):
26662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26664 
      return
26665 
    oprot.writeStructBegin('getRechargeOrder_args')
26666 
    if self.rechargeRrderId is not None:
26667 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26668 
      oprot.writeI64(self.rechargeRrderId)
26669 
      oprot.writeFieldEnd()
26670 
    oprot.writeFieldStop()
26671 
    oprot.writeStructEnd()
26672 
 
26673 
  def validate(self):
26674 
    return
26675 
 
26676 
 
26677 
  def __repr__(self):
26678 
    L = ['%s=%r' % (key, value)
26679 
      for key, value in self.__dict__.iteritems()]
26680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26681 
 
26682 
  def __eq__(self, other):
26683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26684 
 
26685 
  def __ne__(self, other):
26686 
    return not (self == other)
26687 
 
26688 
class getRechargeOrder_result:
26689 
  """
26690 
  Attributes:
26691 
   - success
26692 
   - ex
26693 
  """
26694 
 
26695 
  thrift_spec = (
26696 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26698 
  )
26699 
 
26700 
  def __init__(self, success=None, ex=None,):
26701 
    self.success = success
26702 
    self.ex = ex
26703 
 
26704 
  def read(self, iprot):
26705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26707 
      return
26708 
    iprot.readStructBegin()
26709 
    while True:
26710 
      (fname, ftype, fid) = iprot.readFieldBegin()
26711 
      if ftype == TType.STOP:
26712 
        break
26713 
      if fid == 0:
26714 
        if ftype == TType.STRUCT:
26715 
          self.success = RechargeOrder()
26716 
          self.success.read(iprot)
26717 
        else:
26718 
          iprot.skip(ftype)
26719 
      elif fid == 1:
26720 
        if ftype == TType.STRUCT:
26721 
          self.ex = TransactionServiceException()
26722 
          self.ex.read(iprot)
26723 
        else:
26724 
          iprot.skip(ftype)
26725 
      else:
26726 
        iprot.skip(ftype)
26727 
      iprot.readFieldEnd()
26728 
    iprot.readStructEnd()
26729 
 
26730 
  def write(self, oprot):
26731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26733 
      return
26734 
    oprot.writeStructBegin('getRechargeOrder_result')
26735 
    if self.success is not None:
26736 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26737 
      self.success.write(oprot)
26738 
      oprot.writeFieldEnd()
26739 
    if self.ex is not None:
26740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26741 
      self.ex.write(oprot)
26742 
      oprot.writeFieldEnd()
26743 
    oprot.writeFieldStop()
26744 
    oprot.writeStructEnd()
26745 
 
26746 
  def validate(self):
26747 
    return
26748 
 
26749 
 
26750 
  def __repr__(self):
26751 
    L = ['%s=%r' % (key, value)
26752 
      for key, value in self.__dict__.iteritems()]
26753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26754 
 
26755 
  def __eq__(self, other):
26756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26757 
 
26758 
  def __ne__(self, other):
26759 
    return not (self == other)
26760 
 
26761 
class getRechargeOrders_args:
26762 
  """
26763 
  Attributes:
26764 
   - userId
26765 
  """
26766 
 
26767 
  thrift_spec = (
26768 
    None, # 0
26769 
    (1, TType.I64, 'userId', None, None, ), # 1
26770 
  )
26771 
 
26772 
  def __init__(self, userId=None,):
26773 
    self.userId = userId
26774 
 
26775 
  def read(self, iprot):
26776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26778 
      return
26779 
    iprot.readStructBegin()
26780 
    while True:
26781 
      (fname, ftype, fid) = iprot.readFieldBegin()
26782 
      if ftype == TType.STOP:
26783 
        break
26784 
      if fid == 1:
26785 
        if ftype == TType.I64:
26786 
          self.userId = iprot.readI64();
26787 
        else:
26788 
          iprot.skip(ftype)
26789 
      else:
26790 
        iprot.skip(ftype)
26791 
      iprot.readFieldEnd()
26792 
    iprot.readStructEnd()
26793 
 
26794 
  def write(self, oprot):
26795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26797 
      return
26798 
    oprot.writeStructBegin('getRechargeOrders_args')
26799 
    if self.userId is not None:
26800 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26801 
      oprot.writeI64(self.userId)
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 
 
26821 
class getRechargeOrders_result:
26822 
  """
26823 
  Attributes:
26824 
   - success
26825 
  """
26826 
 
26827 
  thrift_spec = (
26828 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26829 
  )
26830 
 
26831 
  def __init__(self, success=None,):
26832 
    self.success = success
26833 
 
26834 
  def read(self, iprot):
26835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26837 
      return
26838 
    iprot.readStructBegin()
26839 
    while True:
26840 
      (fname, ftype, fid) = iprot.readFieldBegin()
26841 
      if ftype == TType.STOP:
26842 
        break
26843 
      if fid == 0:
26844 
        if ftype == TType.LIST:
26845 
          self.success = []
6188 rajveer 26846 
          (_etype659, _size656) = iprot.readListBegin()
26847 
          for _i660 in xrange(_size656):
26848 
            _elem661 = RechargeOrder()
26849 
            _elem661.read(iprot)
26850 
            self.success.append(_elem661)
6031 rajveer 26851 
          iprot.readListEnd()
26852 
        else:
26853 
          iprot.skip(ftype)
26854 
      else:
26855 
        iprot.skip(ftype)
26856 
      iprot.readFieldEnd()
26857 
    iprot.readStructEnd()
26858 
 
26859 
  def write(self, oprot):
26860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26862 
      return
26863 
    oprot.writeStructBegin('getRechargeOrders_result')
26864 
    if self.success is not None:
26865 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26866 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26867 
      for iter662 in self.success:
26868 
        iter662.write(oprot)
6031 rajveer 26869 
      oprot.writeListEnd()
26870 
      oprot.writeFieldEnd()
26871 
    oprot.writeFieldStop()
26872 
    oprot.writeStructEnd()
26873 
 
26874 
  def validate(self):
26875 
    return
26876 
 
26877 
 
26878 
  def __repr__(self):
26879 
    L = ['%s=%r' % (key, value)
26880 
      for key, value in self.__dict__.iteritems()]
26881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26882 
 
26883 
  def __eq__(self, other):
26884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26885 
 
26886 
  def __ne__(self, other):
26887 
    return not (self == other)
26888 
 
6000 mandeep.dh 26889 
class updateRechargeOrderStatus_args:
26890 
  """
26891 
  Attributes:
26892 
   - rechargeOrderId
26893 
   - rechargeOrderStatus
26894 
  """
26895 
 
26896 
  thrift_spec = (
26897 
    None, # 0
26898 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26899 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26900 
  )
26901 
 
26902 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26903 
    self.rechargeOrderId = rechargeOrderId
26904 
    self.rechargeOrderStatus = rechargeOrderStatus
26905 
 
26906 
  def read(self, iprot):
26907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26909 
      return
26910 
    iprot.readStructBegin()
26911 
    while True:
26912 
      (fname, ftype, fid) = iprot.readFieldBegin()
26913 
      if ftype == TType.STOP:
26914 
        break
26915 
      if fid == 1:
26916 
        if ftype == TType.I64:
26917 
          self.rechargeOrderId = iprot.readI64();
26918 
        else:
26919 
          iprot.skip(ftype)
26920 
      elif fid == 2:
26921 
        if ftype == TType.I32:
26922 
          self.rechargeOrderStatus = iprot.readI32();
26923 
        else:
26924 
          iprot.skip(ftype)
26925 
      else:
26926 
        iprot.skip(ftype)
26927 
      iprot.readFieldEnd()
26928 
    iprot.readStructEnd()
26929 
 
26930 
  def write(self, oprot):
26931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26933 
      return
26934 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26935 
    if self.rechargeOrderId is not None:
26936 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26937 
      oprot.writeI64(self.rechargeOrderId)
26938 
      oprot.writeFieldEnd()
26939 
    if self.rechargeOrderStatus is not None:
26940 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26941 
      oprot.writeI32(self.rechargeOrderStatus)
26942 
      oprot.writeFieldEnd()
26943 
    oprot.writeFieldStop()
26944 
    oprot.writeStructEnd()
26945 
 
26946 
  def validate(self):
26947 
    return
26948 
 
26949 
 
26950 
  def __repr__(self):
26951 
    L = ['%s=%r' % (key, value)
26952 
      for key, value in self.__dict__.iteritems()]
26953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26954 
 
26955 
  def __eq__(self, other):
26956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26957 
 
26958 
  def __ne__(self, other):
26959 
    return not (self == other)
26960 
 
26961 
class updateRechargeOrderStatus_result:
26962 
  """
26963 
  Attributes:
6031 rajveer 26964 
   - success
6000 mandeep.dh 26965 
   - ex
26966 
  """
26967 
 
26968 
  thrift_spec = (
6031 rajveer 26969 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26971 
  )
26972 
 
6031 rajveer 26973 
  def __init__(self, success=None, ex=None,):
26974 
    self.success = success
6000 mandeep.dh 26975 
    self.ex = ex
26976 
 
26977 
  def read(self, iprot):
26978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26980 
      return
26981 
    iprot.readStructBegin()
26982 
    while True:
26983 
      (fname, ftype, fid) = iprot.readFieldBegin()
26984 
      if ftype == TType.STOP:
26985 
        break
6031 rajveer 26986 
      if fid == 0:
26987 
        if ftype == TType.BOOL:
26988 
          self.success = iprot.readBool();
26989 
        else:
26990 
          iprot.skip(ftype)
26991 
      elif fid == 1:
6000 mandeep.dh 26992 
        if ftype == TType.STRUCT:
26993 
          self.ex = TransactionServiceException()
26994 
          self.ex.read(iprot)
26995 
        else:
26996 
          iprot.skip(ftype)
26997 
      else:
26998 
        iprot.skip(ftype)
26999 
      iprot.readFieldEnd()
27000 
    iprot.readStructEnd()
27001 
 
27002 
  def write(self, oprot):
27003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27005 
      return
27006 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27007 
    if self.success is not None:
27008 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27009 
      oprot.writeBool(self.success)
27010 
      oprot.writeFieldEnd()
6000 mandeep.dh 27011 
    if self.ex is not None:
27012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27013 
      self.ex.write(oprot)
27014 
      oprot.writeFieldEnd()
27015 
    oprot.writeFieldStop()
27016 
    oprot.writeStructEnd()
27017 
 
27018 
  def validate(self):
27019 
    return
27020 
 
27021 
 
27022 
  def __repr__(self):
27023 
    L = ['%s=%r' % (key, value)
27024 
      for key, value in self.__dict__.iteritems()]
27025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27026 
 
27027 
  def __eq__(self, other):
27028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27029 
 
27030 
  def __ne__(self, other):
27031 
    return not (self == other)
27032 
 
27033 
class activateRechargeTxn_args:
27034 
  """
27035 
  Attributes:
6031 rajveer 27036 
   - rechargeOrderId
6000 mandeep.dh 27037 
  """
27038 
 
27039 
  thrift_spec = (
27040 
    None, # 0
6031 rajveer 27041 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27042 
  )
27043 
 
6031 rajveer 27044 
  def __init__(self, rechargeOrderId=None,):
27045 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27046 
 
27047 
  def read(self, iprot):
27048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27050 
      return
27051 
    iprot.readStructBegin()
27052 
    while True:
27053 
      (fname, ftype, fid) = iprot.readFieldBegin()
27054 
      if ftype == TType.STOP:
27055 
        break
27056 
      if fid == 1:
6031 rajveer 27057 
        if ftype == TType.I64:
27058 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27059 
        else:
27060 
          iprot.skip(ftype)
27061 
      else:
27062 
        iprot.skip(ftype)
27063 
      iprot.readFieldEnd()
27064 
    iprot.readStructEnd()
27065 
 
27066 
  def write(self, oprot):
27067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27069 
      return
27070 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27071 
    if self.rechargeOrderId is not None:
27072 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27073 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27074 
      oprot.writeFieldEnd()
27075 
    oprot.writeFieldStop()
27076 
    oprot.writeStructEnd()
27077 
 
27078 
  def validate(self):
27079 
    return
27080 
 
27081 
 
27082 
  def __repr__(self):
27083 
    L = ['%s=%r' % (key, value)
27084 
      for key, value in self.__dict__.iteritems()]
27085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27086 
 
27087 
  def __eq__(self, other):
27088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27089 
 
27090 
  def __ne__(self, other):
27091 
    return not (self == other)
27092 
 
27093 
class activateRechargeTxn_result:
27094 
  """
27095 
  Attributes:
27096 
   - success
27097 
   - ex
27098 
  """
27099 
 
27100 
  thrift_spec = (
6031 rajveer 27101 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27102 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27103 
  )
27104 
 
27105 
  def __init__(self, success=None, ex=None,):
27106 
    self.success = success
27107 
    self.ex = ex
27108 
 
27109 
  def read(self, iprot):
27110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27112 
      return
27113 
    iprot.readStructBegin()
27114 
    while True:
27115 
      (fname, ftype, fid) = iprot.readFieldBegin()
27116 
      if ftype == TType.STOP:
27117 
        break
27118 
      if fid == 0:
6031 rajveer 27119 
        if ftype == TType.BOOL:
27120 
          self.success = iprot.readBool();
6000 mandeep.dh 27121 
        else:
27122 
          iprot.skip(ftype)
27123 
      elif fid == 1:
27124 
        if ftype == TType.STRUCT:
27125 
          self.ex = TransactionServiceException()
27126 
          self.ex.read(iprot)
27127 
        else:
27128 
          iprot.skip(ftype)
27129 
      else:
27130 
        iprot.skip(ftype)
27131 
      iprot.readFieldEnd()
27132 
    iprot.readStructEnd()
27133 
 
27134 
  def write(self, oprot):
27135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27137 
      return
27138 
    oprot.writeStructBegin('activateRechargeTxn_result')
27139 
    if self.success is not None:
6031 rajveer 27140 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27141 
      oprot.writeBool(self.success)
6000 mandeep.dh 27142 
      oprot.writeFieldEnd()
27143 
    if self.ex is not None:
27144 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27145 
      self.ex.write(oprot)
27146 
      oprot.writeFieldEnd()
27147 
    oprot.writeFieldStop()
27148 
    oprot.writeStructEnd()
27149 
 
27150 
  def validate(self):
27151 
    return
27152 
 
27153 
 
27154 
  def __repr__(self):
27155 
    L = ['%s=%r' % (key, value)
27156 
      for key, value in self.__dict__.iteritems()]
27157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27158 
 
27159 
  def __eq__(self, other):
27160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27161 
 
27162 
  def __ne__(self, other):
27163 
    return not (self == other)
27164 
 
6031 rajveer 27165 
class getUserWallet_args:
6000 mandeep.dh 27166 
  """
27167 
  Attributes:
6031 rajveer 27168 
   - userId
6000 mandeep.dh 27169 
  """
27170 
 
27171 
  thrift_spec = (
27172 
    None, # 0
6031 rajveer 27173 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27174 
  )
27175 
 
6031 rajveer 27176 
  def __init__(self, userId=None,):
27177 
    self.userId = userId
6000 mandeep.dh 27178 
 
27179 
  def read(self, iprot):
27180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27182 
      return
27183 
    iprot.readStructBegin()
27184 
    while True:
27185 
      (fname, ftype, fid) = iprot.readFieldBegin()
27186 
      if ftype == TType.STOP:
27187 
        break
27188 
      if fid == 1:
27189 
        if ftype == TType.I64:
6031 rajveer 27190 
          self.userId = iprot.readI64();
6000 mandeep.dh 27191 
        else:
27192 
          iprot.skip(ftype)
27193 
      else:
27194 
        iprot.skip(ftype)
27195 
      iprot.readFieldEnd()
27196 
    iprot.readStructEnd()
27197 
 
27198 
  def write(self, oprot):
27199 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27200 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27201 
      return
6031 rajveer 27202 
    oprot.writeStructBegin('getUserWallet_args')
27203 
    if self.userId is not None:
27204 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27205 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27206 
      oprot.writeFieldEnd()
27207 
    oprot.writeFieldStop()
27208 
    oprot.writeStructEnd()
27209 
 
27210 
  def validate(self):
27211 
    return
27212 
 
27213 
 
27214 
  def __repr__(self):
27215 
    L = ['%s=%r' % (key, value)
27216 
      for key, value in self.__dict__.iteritems()]
27217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27218 
 
27219 
  def __eq__(self, other):
27220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27221 
 
27222 
  def __ne__(self, other):
27223 
    return not (self == other)
27224 
 
6031 rajveer 27225 
class getUserWallet_result:
6000 mandeep.dh 27226 
  """
27227 
  Attributes:
27228 
   - success
27229 
  """
27230 
 
27231 
  thrift_spec = (
6031 rajveer 27232 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27233 
  )
27234 
 
27235 
  def __init__(self, success=None,):
27236 
    self.success = success
27237 
 
27238 
  def read(self, iprot):
27239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27241 
      return
27242 
    iprot.readStructBegin()
27243 
    while True:
27244 
      (fname, ftype, fid) = iprot.readFieldBegin()
27245 
      if ftype == TType.STOP:
27246 
        break
27247 
      if fid == 0:
6031 rajveer 27248 
        if ftype == TType.STRUCT:
27249 
          self.success = UserWallet()
27250 
          self.success.read(iprot)
6000 mandeep.dh 27251 
        else:
27252 
          iprot.skip(ftype)
27253 
      else:
27254 
        iprot.skip(ftype)
27255 
      iprot.readFieldEnd()
27256 
    iprot.readStructEnd()
27257 
 
27258 
  def write(self, oprot):
27259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27261 
      return
6031 rajveer 27262 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27263 
    if self.success is not None:
6031 rajveer 27264 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27265 
      self.success.write(oprot)
6000 mandeep.dh 27266 
      oprot.writeFieldEnd()
27267 
    oprot.writeFieldStop()
27268 
    oprot.writeStructEnd()
27269 
 
27270 
  def validate(self):
27271 
    return
27272 
 
27273 
 
27274 
  def __repr__(self):
27275 
    L = ['%s=%r' % (key, value)
27276 
      for key, value in self.__dict__.iteritems()]
27277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27278 
 
27279 
  def __eq__(self, other):
27280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27281 
 
27282 
  def __ne__(self, other):
27283 
    return not (self == other)
27284 
 
6031 rajveer 27285 
class getUserWalletHistory_args:
6000 mandeep.dh 27286 
  """
27287 
  Attributes:
6031 rajveer 27288 
   - userId
6000 mandeep.dh 27289 
  """
27290 
 
27291 
  thrift_spec = (
27292 
    None, # 0
6031 rajveer 27293 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27294 
  )
27295 
 
6031 rajveer 27296 
  def __init__(self, userId=None,):
27297 
    self.userId = userId
6000 mandeep.dh 27298 
 
27299 
  def read(self, iprot):
27300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27302 
      return
27303 
    iprot.readStructBegin()
27304 
    while True:
27305 
      (fname, ftype, fid) = iprot.readFieldBegin()
27306 
      if ftype == TType.STOP:
27307 
        break
27308 
      if fid == 1:
27309 
        if ftype == TType.I64:
6031 rajveer 27310 
          self.userId = iprot.readI64();
6000 mandeep.dh 27311 
        else:
27312 
          iprot.skip(ftype)
27313 
      else:
27314 
        iprot.skip(ftype)
27315 
      iprot.readFieldEnd()
27316 
    iprot.readStructEnd()
27317 
 
27318 
  def write(self, oprot):
27319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27321 
      return
6031 rajveer 27322 
    oprot.writeStructBegin('getUserWalletHistory_args')
27323 
    if self.userId is not None:
27324 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27325 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27326 
      oprot.writeFieldEnd()
27327 
    oprot.writeFieldStop()
27328 
    oprot.writeStructEnd()
27329 
 
27330 
  def validate(self):
27331 
    return
27332 
 
27333 
 
27334 
  def __repr__(self):
27335 
    L = ['%s=%r' % (key, value)
27336 
      for key, value in self.__dict__.iteritems()]
27337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27338 
 
27339 
  def __eq__(self, other):
27340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27341 
 
27342 
  def __ne__(self, other):
27343 
    return not (self == other)
27344 
 
6031 rajveer 27345 
class getUserWalletHistory_result:
6000 mandeep.dh 27346 
  """
27347 
  Attributes:
27348 
   - success
27349 
  """
27350 
 
27351 
  thrift_spec = (
6031 rajveer 27352 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27353 
  )
27354 
 
27355 
  def __init__(self, success=None,):
27356 
    self.success = success
27357 
 
27358 
  def read(self, iprot):
27359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27361 
      return
27362 
    iprot.readStructBegin()
27363 
    while True:
27364 
      (fname, ftype, fid) = iprot.readFieldBegin()
27365 
      if ftype == TType.STOP:
27366 
        break
27367 
      if fid == 0:
27368 
        if ftype == TType.LIST:
27369 
          self.success = []
6188 rajveer 27370 
          (_etype666, _size663) = iprot.readListBegin()
27371 
          for _i667 in xrange(_size663):
27372 
            _elem668 = UserWalletHistory()
27373 
            _elem668.read(iprot)
27374 
            self.success.append(_elem668)
6000 mandeep.dh 27375 
          iprot.readListEnd()
27376 
        else:
27377 
          iprot.skip(ftype)
27378 
      else:
27379 
        iprot.skip(ftype)
27380 
      iprot.readFieldEnd()
27381 
    iprot.readStructEnd()
27382 
 
27383 
  def write(self, oprot):
27384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27386 
      return
6031 rajveer 27387 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27388 
    if self.success is not None:
27389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27391 
      for iter669 in self.success:
27392 
        iter669.write(oprot)
6000 mandeep.dh 27393 
      oprot.writeListEnd()
27394 
      oprot.writeFieldEnd()
27395 
    oprot.writeFieldStop()
27396 
    oprot.writeStructEnd()
27397 
 
27398 
  def validate(self):
27399 
    return
27400 
 
27401 
 
27402 
  def __repr__(self):
27403 
    L = ['%s=%r' % (key, value)
27404 
      for key, value in self.__dict__.iteritems()]
27405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27406 
 
27407 
  def __eq__(self, other):
27408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27409 
 
27410 
  def __ne__(self, other):
27411 
    return not (self == other)
6048 rajveer 27412 
 
6050 anupam.sin 27413 
class getRechargeOrdersForTransaction_args:
27414 
  """
27415 
  Attributes:
27416 
   - txnId
27417 
  """
27418 
 
27419 
  thrift_spec = (
27420 
    None, # 0
27421 
    (1, TType.I64, 'txnId', None, None, ), # 1
27422 
  )
27423 
 
27424 
  def __init__(self, txnId=None,):
27425 
    self.txnId = txnId
27426 
 
27427 
  def read(self, iprot):
27428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27430 
      return
27431 
    iprot.readStructBegin()
27432 
    while True:
27433 
      (fname, ftype, fid) = iprot.readFieldBegin()
27434 
      if ftype == TType.STOP:
27435 
        break
27436 
      if fid == 1:
27437 
        if ftype == TType.I64:
27438 
          self.txnId = iprot.readI64();
27439 
        else:
27440 
          iprot.skip(ftype)
27441 
      else:
27442 
        iprot.skip(ftype)
27443 
      iprot.readFieldEnd()
27444 
    iprot.readStructEnd()
27445 
 
27446 
  def write(self, oprot):
27447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27449 
      return
27450 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27451 
    if self.txnId is not None:
27452 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27453 
      oprot.writeI64(self.txnId)
27454 
      oprot.writeFieldEnd()
27455 
    oprot.writeFieldStop()
27456 
    oprot.writeStructEnd()
27457 
 
27458 
  def validate(self):
27459 
    return
27460 
 
27461 
 
27462 
  def __repr__(self):
27463 
    L = ['%s=%r' % (key, value)
27464 
      for key, value in self.__dict__.iteritems()]
27465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27466 
 
27467 
  def __eq__(self, other):
27468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27469 
 
27470 
  def __ne__(self, other):
27471 
    return not (self == other)
27472 
 
27473 
class getRechargeOrdersForTransaction_result:
27474 
  """
27475 
  Attributes:
27476 
   - success
27477 
   - ex
27478 
  """
27479 
 
27480 
  thrift_spec = (
27481 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27483 
  )
27484 
 
27485 
  def __init__(self, success=None, ex=None,):
27486 
    self.success = success
27487 
    self.ex = ex
27488 
 
27489 
  def read(self, iprot):
27490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27492 
      return
27493 
    iprot.readStructBegin()
27494 
    while True:
27495 
      (fname, ftype, fid) = iprot.readFieldBegin()
27496 
      if ftype == TType.STOP:
27497 
        break
27498 
      if fid == 0:
27499 
        if ftype == TType.STRUCT:
27500 
          self.success = RechargeOrder()
27501 
          self.success.read(iprot)
27502 
        else:
27503 
          iprot.skip(ftype)
27504 
      elif fid == 1:
27505 
        if ftype == TType.STRUCT:
27506 
          self.ex = TransactionServiceException()
27507 
          self.ex.read(iprot)
27508 
        else:
27509 
          iprot.skip(ftype)
27510 
      else:
27511 
        iprot.skip(ftype)
27512 
      iprot.readFieldEnd()
27513 
    iprot.readStructEnd()
27514 
 
27515 
  def write(self, oprot):
27516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27518 
      return
27519 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27520 
    if self.success is not None:
27521 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27522 
      self.success.write(oprot)
27523 
      oprot.writeFieldEnd()
27524 
    if self.ex is not None:
27525 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27526 
      self.ex.write(oprot)
27527 
      oprot.writeFieldEnd()
27528 
    oprot.writeFieldStop()
27529 
    oprot.writeStructEnd()
27530 
 
27531 
  def validate(self):
27532 
    return
27533 
 
27534 
 
27535 
  def __repr__(self):
27536 
    L = ['%s=%r' % (key, value)
27537 
      for key, value in self.__dict__.iteritems()]
27538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27539 
 
27540 
  def __eq__(self, other):
27541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27542 
 
27543 
  def __ne__(self, other):
27544 
    return not (self == other)
27545 
 
6048 rajveer 27546 
class getServiceProviders_args:
27547 
  """
27548 
  Attributes:
27549 
   - rechargeType
6206 rajveer 27550 
   - onlyActive
6048 rajveer 27551 
  """
27552 
 
27553 
  thrift_spec = (
27554 
    None, # 0
27555 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27556 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27557 
  )
27558 
 
6206 rajveer 27559 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27560 
    self.rechargeType = rechargeType
6206 rajveer 27561 
    self.onlyActive = onlyActive
6048 rajveer 27562 
 
27563 
  def read(self, iprot):
27564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27566 
      return
27567 
    iprot.readStructBegin()
27568 
    while True:
27569 
      (fname, ftype, fid) = iprot.readFieldBegin()
27570 
      if ftype == TType.STOP:
27571 
        break
27572 
      if fid == 1:
27573 
        if ftype == TType.I32:
27574 
          self.rechargeType = iprot.readI32();
27575 
        else:
27576 
          iprot.skip(ftype)
6206 rajveer 27577 
      elif fid == 2:
27578 
        if ftype == TType.BOOL:
27579 
          self.onlyActive = iprot.readBool();
27580 
        else:
27581 
          iprot.skip(ftype)
6048 rajveer 27582 
      else:
27583 
        iprot.skip(ftype)
27584 
      iprot.readFieldEnd()
27585 
    iprot.readStructEnd()
27586 
 
27587 
  def write(self, oprot):
27588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27590 
      return
27591 
    oprot.writeStructBegin('getServiceProviders_args')
27592 
    if self.rechargeType is not None:
27593 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27594 
      oprot.writeI32(self.rechargeType)
27595 
      oprot.writeFieldEnd()
6206 rajveer 27596 
    if self.onlyActive is not None:
27597 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27598 
      oprot.writeBool(self.onlyActive)
27599 
      oprot.writeFieldEnd()
6048 rajveer 27600 
    oprot.writeFieldStop()
27601 
    oprot.writeStructEnd()
27602 
 
27603 
  def validate(self):
27604 
    return
27605 
 
27606 
 
27607 
  def __repr__(self):
27608 
    L = ['%s=%r' % (key, value)
27609 
      for key, value in self.__dict__.iteritems()]
27610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27611 
 
27612 
  def __eq__(self, other):
27613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27614 
 
27615 
  def __ne__(self, other):
27616 
    return not (self == other)
27617 
 
27618 
class getServiceProviders_result:
27619 
  """
27620 
  Attributes:
27621 
   - success
27622 
  """
27623 
 
27624 
  thrift_spec = (
27625 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27626 
  )
27627 
 
27628 
  def __init__(self, success=None,):
27629 
    self.success = success
27630 
 
27631 
  def read(self, iprot):
27632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27634 
      return
27635 
    iprot.readStructBegin()
27636 
    while True:
27637 
      (fname, ftype, fid) = iprot.readFieldBegin()
27638 
      if ftype == TType.STOP:
27639 
        break
27640 
      if fid == 0:
27641 
        if ftype == TType.MAP:
27642 
          self.success = {}
6188 rajveer 27643 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27644 
          for _i674 in xrange(_size670):
27645 
            _key675 = iprot.readI64();
27646 
            _val676 = iprot.readString();
27647 
            self.success[_key675] = _val676
6048 rajveer 27648 
          iprot.readMapEnd()
27649 
        else:
27650 
          iprot.skip(ftype)
27651 
      else:
27652 
        iprot.skip(ftype)
27653 
      iprot.readFieldEnd()
27654 
    iprot.readStructEnd()
27655 
 
27656 
  def write(self, oprot):
27657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27659 
      return
27660 
    oprot.writeStructBegin('getServiceProviders_result')
27661 
    if self.success is not None:
27662 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27663 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27664 
      for kiter677,viter678 in self.success.items():
27665 
        oprot.writeI64(kiter677)
27666 
        oprot.writeString(viter678)
6048 rajveer 27667 
      oprot.writeMapEnd()
27668 
      oprot.writeFieldEnd()
27669 
    oprot.writeFieldStop()
27670 
    oprot.writeStructEnd()
27671 
 
27672 
  def validate(self):
27673 
    return
27674 
 
27675 
 
27676 
  def __repr__(self):
27677 
    L = ['%s=%r' % (key, value)
27678 
      for key, value in self.__dict__.iteritems()]
27679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27680 
 
27681 
  def __eq__(self, other):
27682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27683 
 
27684 
  def __ne__(self, other):
27685 
    return not (self == other)
27686 
 
27687 
class getServiceProviderForDevice_args:
27688 
  """
27689 
  Attributes:
6049 rajveer 27690 
   - rechargeType
6048 rajveer 27691 
   - deviceNumber
27692 
  """
27693 
 
27694 
  thrift_spec = (
27695 
    None, # 0
6049 rajveer 27696 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27697 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27698 
  )
27699 
 
6049 rajveer 27700 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27701 
    self.rechargeType = rechargeType
6048 rajveer 27702 
    self.deviceNumber = deviceNumber
27703 
 
27704 
  def read(self, iprot):
27705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27707 
      return
27708 
    iprot.readStructBegin()
27709 
    while True:
27710 
      (fname, ftype, fid) = iprot.readFieldBegin()
27711 
      if ftype == TType.STOP:
27712 
        break
27713 
      if fid == 1:
6049 rajveer 27714 
        if ftype == TType.I32:
27715 
          self.rechargeType = iprot.readI32();
27716 
        else:
27717 
          iprot.skip(ftype)
27718 
      elif fid == 2:
6048 rajveer 27719 
        if ftype == TType.STRING:
27720 
          self.deviceNumber = iprot.readString();
27721 
        else:
27722 
          iprot.skip(ftype)
27723 
      else:
27724 
        iprot.skip(ftype)
27725 
      iprot.readFieldEnd()
27726 
    iprot.readStructEnd()
27727 
 
27728 
  def write(self, oprot):
27729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27731 
      return
27732 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27733 
    if self.rechargeType is not None:
27734 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27735 
      oprot.writeI32(self.rechargeType)
27736 
      oprot.writeFieldEnd()
6048 rajveer 27737 
    if self.deviceNumber is not None:
6049 rajveer 27738 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27739 
      oprot.writeString(self.deviceNumber)
27740 
      oprot.writeFieldEnd()
27741 
    oprot.writeFieldStop()
27742 
    oprot.writeStructEnd()
27743 
 
27744 
  def validate(self):
27745 
    return
27746 
 
27747 
 
27748 
  def __repr__(self):
27749 
    L = ['%s=%r' % (key, value)
27750 
      for key, value in self.__dict__.iteritems()]
27751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27752 
 
27753 
  def __eq__(self, other):
27754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27755 
 
27756 
  def __ne__(self, other):
27757 
    return not (self == other)
27758 
 
27759 
class getServiceProviderForDevice_result:
27760 
  """
27761 
  Attributes:
27762 
   - success
27763 
  """
27764 
 
27765 
  thrift_spec = (
6289 anupam.sin 27766 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27767 
  )
27768 
 
27769 
  def __init__(self, success=None,):
27770 
    self.success = success
27771 
 
27772 
  def read(self, iprot):
27773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27775 
      return
27776 
    iprot.readStructBegin()
27777 
    while True:
27778 
      (fname, ftype, fid) = iprot.readFieldBegin()
27779 
      if ftype == TType.STOP:
27780 
        break
27781 
      if fid == 0:
6289 anupam.sin 27782 
        if ftype == TType.STRUCT:
27783 
          self.success = DeviceNumberInfo()
27784 
          self.success.read(iprot)
6048 rajveer 27785 
        else:
27786 
          iprot.skip(ftype)
27787 
      else:
27788 
        iprot.skip(ftype)
27789 
      iprot.readFieldEnd()
27790 
    iprot.readStructEnd()
27791 
 
27792 
  def write(self, oprot):
27793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27795 
      return
27796 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27797 
    if self.success is not None:
6289 anupam.sin 27798 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27799 
      self.success.write(oprot)
6048 rajveer 27800 
      oprot.writeFieldEnd()
27801 
    oprot.writeFieldStop()
27802 
    oprot.writeStructEnd()
27803 
 
27804 
  def validate(self):
27805 
    return
27806 
 
27807 
 
27808 
  def __repr__(self):
27809 
    L = ['%s=%r' % (key, value)
27810 
      for key, value in self.__dict__.iteritems()]
27811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27812 
 
27813 
  def __eq__(self, other):
27814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27815 
 
27816 
  def __ne__(self, other):
27817 
    return not (self == other)
6094 rajveer 27818 
 
6269 rajveer 27819 
class validateRecharge_args:
27820 
  """
27821 
  Attributes:
27822 
   - rechargeType
27823 
   - deviceNumber
6307 anupam.sin 27824 
   - circleCode
27825 
   - userSelectedProviderId
6269 rajveer 27826 
  """
27827 
 
27828 
  thrift_spec = (
27829 
    None, # 0
27830 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27831 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6307 anupam.sin 27832 
    (3, TType.STRING, 'circleCode', None, None, ), # 3
27833 
    (4, TType.I64, 'userSelectedProviderId', None, None, ), # 4
6269 rajveer 27834 
  )
27835 
 
6307 anupam.sin 27836 
  def __init__(self, rechargeType=None, deviceNumber=None, circleCode=None, userSelectedProviderId=None,):
6269 rajveer 27837 
    self.rechargeType = rechargeType
27838 
    self.deviceNumber = deviceNumber
6307 anupam.sin 27839 
    self.circleCode = circleCode
27840 
    self.userSelectedProviderId = userSelectedProviderId
6269 rajveer 27841 
 
27842 
  def read(self, iprot):
27843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27845 
      return
27846 
    iprot.readStructBegin()
27847 
    while True:
27848 
      (fname, ftype, fid) = iprot.readFieldBegin()
27849 
      if ftype == TType.STOP:
27850 
        break
27851 
      if fid == 1:
27852 
        if ftype == TType.I32:
27853 
          self.rechargeType = iprot.readI32();
27854 
        else:
27855 
          iprot.skip(ftype)
27856 
      elif fid == 2:
27857 
        if ftype == TType.STRING:
27858 
          self.deviceNumber = iprot.readString();
27859 
        else:
27860 
          iprot.skip(ftype)
6307 anupam.sin 27861 
      elif fid == 3:
27862 
        if ftype == TType.STRING:
27863 
          self.circleCode = iprot.readString();
27864 
        else:
27865 
          iprot.skip(ftype)
27866 
      elif fid == 4:
27867 
        if ftype == TType.I64:
27868 
          self.userSelectedProviderId = iprot.readI64();
27869 
        else:
27870 
          iprot.skip(ftype)
6269 rajveer 27871 
      else:
27872 
        iprot.skip(ftype)
27873 
      iprot.readFieldEnd()
27874 
    iprot.readStructEnd()
27875 
 
27876 
  def write(self, oprot):
27877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27879 
      return
27880 
    oprot.writeStructBegin('validateRecharge_args')
27881 
    if self.rechargeType is not None:
27882 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27883 
      oprot.writeI32(self.rechargeType)
27884 
      oprot.writeFieldEnd()
27885 
    if self.deviceNumber is not None:
27886 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
27887 
      oprot.writeString(self.deviceNumber)
27888 
      oprot.writeFieldEnd()
6307 anupam.sin 27889 
    if self.circleCode is not None:
27890 
      oprot.writeFieldBegin('circleCode', TType.STRING, 3)
27891 
      oprot.writeString(self.circleCode)
27892 
      oprot.writeFieldEnd()
27893 
    if self.userSelectedProviderId is not None:
27894 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 4)
27895 
      oprot.writeI64(self.userSelectedProviderId)
27896 
      oprot.writeFieldEnd()
6269 rajveer 27897 
    oprot.writeFieldStop()
27898 
    oprot.writeStructEnd()
27899 
 
27900 
  def validate(self):
27901 
    return
27902 
 
27903 
 
27904 
  def __repr__(self):
27905 
    L = ['%s=%r' % (key, value)
27906 
      for key, value in self.__dict__.iteritems()]
27907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27908 
 
27909 
  def __eq__(self, other):
27910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27911 
 
27912 
  def __ne__(self, other):
27913 
    return not (self == other)
27914 
 
27915 
class validateRecharge_result:
27916 
  """
27917 
  Attributes:
27918 
   - success
27919 
  """
27920 
 
27921 
  thrift_spec = (
27922 
    (0, TType.STRING, 'success', None, None, ), # 0
27923 
  )
27924 
 
27925 
  def __init__(self, success=None,):
27926 
    self.success = success
27927 
 
27928 
  def read(self, iprot):
27929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27931 
      return
27932 
    iprot.readStructBegin()
27933 
    while True:
27934 
      (fname, ftype, fid) = iprot.readFieldBegin()
27935 
      if ftype == TType.STOP:
27936 
        break
27937 
      if fid == 0:
27938 
        if ftype == TType.STRING:
27939 
          self.success = iprot.readString();
27940 
        else:
27941 
          iprot.skip(ftype)
27942 
      else:
27943 
        iprot.skip(ftype)
27944 
      iprot.readFieldEnd()
27945 
    iprot.readStructEnd()
27946 
 
27947 
  def write(self, oprot):
27948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27950 
      return
27951 
    oprot.writeStructBegin('validateRecharge_result')
27952 
    if self.success is not None:
27953 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27954 
      oprot.writeString(self.success)
27955 
      oprot.writeFieldEnd()
27956 
    oprot.writeFieldStop()
27957 
    oprot.writeStructEnd()
27958 
 
27959 
  def validate(self):
27960 
    return
27961 
 
27962 
 
27963 
  def __repr__(self):
27964 
    L = ['%s=%r' % (key, value)
27965 
      for key, value in self.__dict__.iteritems()]
27966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27967 
 
27968 
  def __eq__(self, other):
27969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27970 
 
27971 
  def __ne__(self, other):
27972 
    return not (self == other)
27973 
 
6094 rajveer 27974 
class getRechargeOrdersForDevice_args:
27975 
  """
27976 
  Attributes:
27977 
   - deviceNumber
27978 
  """
27979 
 
27980 
  thrift_spec = (
27981 
    None, # 0
27982 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27983 
  )
27984 
 
27985 
  def __init__(self, deviceNumber=None,):
27986 
    self.deviceNumber = deviceNumber
27987 
 
27988 
  def read(self, iprot):
27989 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27990 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27991 
      return
27992 
    iprot.readStructBegin()
27993 
    while True:
27994 
      (fname, ftype, fid) = iprot.readFieldBegin()
27995 
      if ftype == TType.STOP:
27996 
        break
27997 
      if fid == 1:
27998 
        if ftype == TType.STRING:
27999 
          self.deviceNumber = iprot.readString();
28000 
        else:
28001 
          iprot.skip(ftype)
28002 
      else:
28003 
        iprot.skip(ftype)
28004 
      iprot.readFieldEnd()
28005 
    iprot.readStructEnd()
28006 
 
28007 
  def write(self, oprot):
28008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28010 
      return
28011 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28012 
    if self.deviceNumber is not None:
28013 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28014 
      oprot.writeString(self.deviceNumber)
28015 
      oprot.writeFieldEnd()
28016 
    oprot.writeFieldStop()
28017 
    oprot.writeStructEnd()
28018 
 
28019 
  def validate(self):
28020 
    return
28021 
 
28022 
 
28023 
  def __repr__(self):
28024 
    L = ['%s=%r' % (key, value)
28025 
      for key, value in self.__dict__.iteritems()]
28026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28027 
 
28028 
  def __eq__(self, other):
28029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28030 
 
28031 
  def __ne__(self, other):
28032 
    return not (self == other)
28033 
 
28034 
class getRechargeOrdersForDevice_result:
28035 
  """
28036 
  Attributes:
28037 
   - success
28038 
  """
28039 
 
28040 
  thrift_spec = (
28041 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28042 
  )
28043 
 
28044 
  def __init__(self, success=None,):
28045 
    self.success = success
28046 
 
28047 
  def read(self, iprot):
28048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28050 
      return
28051 
    iprot.readStructBegin()
28052 
    while True:
28053 
      (fname, ftype, fid) = iprot.readFieldBegin()
28054 
      if ftype == TType.STOP:
28055 
        break
28056 
      if fid == 0:
28057 
        if ftype == TType.LIST:
28058 
          self.success = []
6188 rajveer 28059 
          (_etype682, _size679) = iprot.readListBegin()
28060 
          for _i683 in xrange(_size679):
28061 
            _elem684 = RechargeOrder()
28062 
            _elem684.read(iprot)
28063 
            self.success.append(_elem684)
6094 rajveer 28064 
          iprot.readListEnd()
28065 
        else:
28066 
          iprot.skip(ftype)
28067 
      else:
28068 
        iprot.skip(ftype)
28069 
      iprot.readFieldEnd()
28070 
    iprot.readStructEnd()
28071 
 
28072 
  def write(self, oprot):
28073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28075 
      return
28076 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28077 
    if self.success is not None:
28078 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28079 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28080 
      for iter685 in self.success:
28081 
        iter685.write(oprot)
6094 rajveer 28082 
      oprot.writeListEnd()
28083 
      oprot.writeFieldEnd()
28084 
    oprot.writeFieldStop()
28085 
    oprot.writeStructEnd()
28086 
 
28087 
  def validate(self):
28088 
    return
28089 
 
28090 
 
28091 
  def __repr__(self):
28092 
    L = ['%s=%r' % (key, value)
28093 
      for key, value in self.__dict__.iteritems()]
28094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28095 
 
28096 
  def __eq__(self, other):
28097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28098 
 
28099 
  def __ne__(self, other):
28100 
    return not (self == other)
28101 
 
28102 
class addAmountToWallet_args:
28103 
  """
28104 
  Attributes:
28105 
   - userId
28106 
   - orderId
28107 
   - amount
28108 
  """
28109 
 
28110 
  thrift_spec = (
28111 
    None, # 0
28112 
    (1, TType.I64, 'userId', None, None, ), # 1
28113 
    (2, TType.I64, 'orderId', None, None, ), # 2
28114 
    (3, TType.I64, 'amount', None, None, ), # 3
28115 
  )
28116 
 
28117 
  def __init__(self, userId=None, orderId=None, amount=None,):
28118 
    self.userId = userId
28119 
    self.orderId = orderId
28120 
    self.amount = amount
28121 
 
28122 
  def read(self, iprot):
28123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28125 
      return
28126 
    iprot.readStructBegin()
28127 
    while True:
28128 
      (fname, ftype, fid) = iprot.readFieldBegin()
28129 
      if ftype == TType.STOP:
28130 
        break
28131 
      if fid == 1:
28132 
        if ftype == TType.I64:
28133 
          self.userId = iprot.readI64();
28134 
        else:
28135 
          iprot.skip(ftype)
28136 
      elif fid == 2:
28137 
        if ftype == TType.I64:
28138 
          self.orderId = iprot.readI64();
28139 
        else:
28140 
          iprot.skip(ftype)
28141 
      elif fid == 3:
28142 
        if ftype == TType.I64:
28143 
          self.amount = iprot.readI64();
28144 
        else:
28145 
          iprot.skip(ftype)
28146 
      else:
28147 
        iprot.skip(ftype)
28148 
      iprot.readFieldEnd()
28149 
    iprot.readStructEnd()
28150 
 
28151 
  def write(self, oprot):
28152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28154 
      return
28155 
    oprot.writeStructBegin('addAmountToWallet_args')
28156 
    if self.userId is not None:
28157 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28158 
      oprot.writeI64(self.userId)
28159 
      oprot.writeFieldEnd()
28160 
    if self.orderId is not None:
28161 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28162 
      oprot.writeI64(self.orderId)
28163 
      oprot.writeFieldEnd()
28164 
    if self.amount is not None:
28165 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28166 
      oprot.writeI64(self.amount)
28167 
      oprot.writeFieldEnd()
28168 
    oprot.writeFieldStop()
28169 
    oprot.writeStructEnd()
28170 
 
28171 
  def validate(self):
28172 
    return
28173 
 
28174 
 
28175 
  def __repr__(self):
28176 
    L = ['%s=%r' % (key, value)
28177 
      for key, value in self.__dict__.iteritems()]
28178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28179 
 
28180 
  def __eq__(self, other):
28181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28182 
 
28183 
  def __ne__(self, other):
28184 
    return not (self == other)
28185 
 
28186 
class addAmountToWallet_result:
28187 
 
28188 
  thrift_spec = (
28189 
  )
28190 
 
28191 
  def read(self, iprot):
28192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28194 
      return
28195 
    iprot.readStructBegin()
28196 
    while True:
28197 
      (fname, ftype, fid) = iprot.readFieldBegin()
28198 
      if ftype == TType.STOP:
28199 
        break
28200 
      else:
28201 
        iprot.skip(ftype)
28202 
      iprot.readFieldEnd()
28203 
    iprot.readStructEnd()
28204 
 
28205 
  def write(self, oprot):
28206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28208 
      return
28209 
    oprot.writeStructBegin('addAmountToWallet_result')
28210 
    oprot.writeFieldStop()
28211 
    oprot.writeStructEnd()
28212 
 
28213 
  def validate(self):
28214 
    return
28215 
 
28216 
 
28217 
  def __repr__(self):
28218 
    L = ['%s=%r' % (key, value)
28219 
      for key, value in self.__dict__.iteritems()]
28220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28221 
 
28222 
  def __eq__(self, other):
28223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28224 
 
28225 
  def __ne__(self, other):
28226 
    return not (self == other)
6154 rajveer 28227 
 
6188 rajveer 28228 
class getRechargeStatistics_args:
28229 
 
28230 
  thrift_spec = (
28231 
  )
28232 
 
28233 
  def read(self, iprot):
28234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28236 
      return
28237 
    iprot.readStructBegin()
28238 
    while True:
28239 
      (fname, ftype, fid) = iprot.readFieldBegin()
28240 
      if ftype == TType.STOP:
28241 
        break
28242 
      else:
28243 
        iprot.skip(ftype)
28244 
      iprot.readFieldEnd()
28245 
    iprot.readStructEnd()
28246 
 
28247 
  def write(self, oprot):
28248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28250 
      return
28251 
    oprot.writeStructBegin('getRechargeStatistics_args')
28252 
    oprot.writeFieldStop()
28253 
    oprot.writeStructEnd()
28254 
 
28255 
  def validate(self):
28256 
    return
28257 
 
28258 
 
28259 
  def __repr__(self):
28260 
    L = ['%s=%r' % (key, value)
28261 
      for key, value in self.__dict__.iteritems()]
28262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28263 
 
28264 
  def __eq__(self, other):
28265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28266 
 
28267 
  def __ne__(self, other):
28268 
    return not (self == other)
28269 
 
28270 
class getRechargeStatistics_result:
28271 
  """
28272 
  Attributes:
28273 
   - success
28274 
  """
28275 
 
28276 
  thrift_spec = (
28277 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28278 
  )
28279 
 
28280 
  def __init__(self, success=None,):
28281 
    self.success = success
28282 
 
28283 
  def read(self, iprot):
28284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28286 
      return
28287 
    iprot.readStructBegin()
28288 
    while True:
28289 
      (fname, ftype, fid) = iprot.readFieldBegin()
28290 
      if ftype == TType.STOP:
28291 
        break
28292 
      if fid == 0:
28293 
        if ftype == TType.STRUCT:
28294 
          self.success = RechargeStatistics()
28295 
          self.success.read(iprot)
28296 
        else:
28297 
          iprot.skip(ftype)
28298 
      else:
28299 
        iprot.skip(ftype)
28300 
      iprot.readFieldEnd()
28301 
    iprot.readStructEnd()
28302 
 
28303 
  def write(self, oprot):
28304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28306 
      return
28307 
    oprot.writeStructBegin('getRechargeStatistics_result')
28308 
    if self.success is not None:
28309 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28310 
      self.success.write(oprot)
28311 
      oprot.writeFieldEnd()
28312 
    oprot.writeFieldStop()
28313 
    oprot.writeStructEnd()
28314 
 
28315 
  def validate(self):
28316 
    return
28317 
 
28318 
 
28319 
  def __repr__(self):
28320 
    L = ['%s=%r' % (key, value)
28321 
      for key, value in self.__dict__.iteritems()]
28322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28323 
 
28324 
  def __eq__(self, other):
28325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28326 
 
28327 
  def __ne__(self, other):
28328 
    return not (self == other)
28329 
 
6154 rajveer 28330 
class getRechargeOrdersForStatus_args:
28331 
  """
28332 
  Attributes:
28333 
   - status
28334 
  """
28335 
 
28336 
  thrift_spec = (
28337 
    None, # 0
28338 
    (1, TType.I64, 'status', None, None, ), # 1
28339 
  )
28340 
 
28341 
  def __init__(self, status=None,):
28342 
    self.status = status
28343 
 
28344 
  def read(self, iprot):
28345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28347 
      return
28348 
    iprot.readStructBegin()
28349 
    while True:
28350 
      (fname, ftype, fid) = iprot.readFieldBegin()
28351 
      if ftype == TType.STOP:
28352 
        break
28353 
      if fid == 1:
28354 
        if ftype == TType.I64:
28355 
          self.status = iprot.readI64();
28356 
        else:
28357 
          iprot.skip(ftype)
28358 
      else:
28359 
        iprot.skip(ftype)
28360 
      iprot.readFieldEnd()
28361 
    iprot.readStructEnd()
28362 
 
28363 
  def write(self, oprot):
28364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28366 
      return
28367 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28368 
    if self.status is not None:
28369 
      oprot.writeFieldBegin('status', TType.I64, 1)
28370 
      oprot.writeI64(self.status)
28371 
      oprot.writeFieldEnd()
28372 
    oprot.writeFieldStop()
28373 
    oprot.writeStructEnd()
28374 
 
28375 
  def validate(self):
28376 
    return
28377 
 
28378 
 
28379 
  def __repr__(self):
28380 
    L = ['%s=%r' % (key, value)
28381 
      for key, value in self.__dict__.iteritems()]
28382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28383 
 
28384 
  def __eq__(self, other):
28385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28386 
 
28387 
  def __ne__(self, other):
28388 
    return not (self == other)
28389 
 
28390 
class getRechargeOrdersForStatus_result:
28391 
  """
28392 
  Attributes:
28393 
   - success
28394 
  """
28395 
 
28396 
  thrift_spec = (
28397 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28398 
  )
28399 
 
28400 
  def __init__(self, success=None,):
28401 
    self.success = success
28402 
 
28403 
  def read(self, iprot):
28404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28406 
      return
28407 
    iprot.readStructBegin()
28408 
    while True:
28409 
      (fname, ftype, fid) = iprot.readFieldBegin()
28410 
      if ftype == TType.STOP:
28411 
        break
28412 
      if fid == 0:
28413 
        if ftype == TType.LIST:
28414 
          self.success = []
6188 rajveer 28415 
          (_etype689, _size686) = iprot.readListBegin()
28416 
          for _i690 in xrange(_size686):
28417 
            _elem691 = RechargeOrder()
28418 
            _elem691.read(iprot)
28419 
            self.success.append(_elem691)
6154 rajveer 28420 
          iprot.readListEnd()
28421 
        else:
28422 
          iprot.skip(ftype)
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('getRechargeOrdersForStatus_result')
28433 
    if self.success is not None:
28434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28436 
      for iter692 in self.success:
28437 
        iter692.write(oprot)
6154 rajveer 28438 
      oprot.writeListEnd()
28439 
      oprot.writeFieldEnd()
28440 
    oprot.writeFieldStop()
28441 
    oprot.writeStructEnd()
28442 
 
28443 
  def validate(self):
28444 
    return
28445 
 
28446 
 
28447 
  def __repr__(self):
28448 
    L = ['%s=%r' % (key, value)
28449 
      for key, value in self.__dict__.iteritems()]
28450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28451 
 
28452 
  def __eq__(self, other):
28453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28454 
 
28455 
  def __ne__(self, other):
28456 
    return not (self == other)
6159 rajveer 28457 
 
28458 
class getPlansForOperator_args:
28459 
  """
28460 
  Attributes:
28461 
   - operatorId
28462 
  """
28463 
 
28464 
  thrift_spec = (
28465 
    None, # 0
28466 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28467 
  )
28468 
 
28469 
  def __init__(self, operatorId=None,):
28470 
    self.operatorId = operatorId
28471 
 
28472 
  def read(self, iprot):
28473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28475 
      return
28476 
    iprot.readStructBegin()
28477 
    while True:
28478 
      (fname, ftype, fid) = iprot.readFieldBegin()
28479 
      if ftype == TType.STOP:
28480 
        break
28481 
      if fid == 1:
28482 
        if ftype == TType.I64:
28483 
          self.operatorId = iprot.readI64();
28484 
        else:
28485 
          iprot.skip(ftype)
28486 
      else:
28487 
        iprot.skip(ftype)
28488 
      iprot.readFieldEnd()
28489 
    iprot.readStructEnd()
28490 
 
28491 
  def write(self, oprot):
28492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28494 
      return
28495 
    oprot.writeStructBegin('getPlansForOperator_args')
28496 
    if self.operatorId is not None:
28497 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28498 
      oprot.writeI64(self.operatorId)
28499 
      oprot.writeFieldEnd()
28500 
    oprot.writeFieldStop()
28501 
    oprot.writeStructEnd()
28502 
 
28503 
  def validate(self):
28504 
    return
28505 
 
28506 
 
28507 
  def __repr__(self):
28508 
    L = ['%s=%r' % (key, value)
28509 
      for key, value in self.__dict__.iteritems()]
28510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28511 
 
28512 
  def __eq__(self, other):
28513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28514 
 
28515 
  def __ne__(self, other):
28516 
    return not (self == other)
28517 
 
28518 
class getPlansForOperator_result:
28519 
  """
28520 
  Attributes:
28521 
   - success
28522 
  """
28523 
 
28524 
  thrift_spec = (
28525 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28526 
  )
28527 
 
28528 
  def __init__(self, success=None,):
28529 
    self.success = success
28530 
 
28531 
  def read(self, iprot):
28532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28534 
      return
28535 
    iprot.readStructBegin()
28536 
    while True:
28537 
      (fname, ftype, fid) = iprot.readFieldBegin()
28538 
      if ftype == TType.STOP:
28539 
        break
28540 
      if fid == 0:
28541 
        if ftype == TType.LIST:
28542 
          self.success = []
6188 rajveer 28543 
          (_etype696, _size693) = iprot.readListBegin()
28544 
          for _i697 in xrange(_size693):
28545 
            _elem698 = RechargePlan()
28546 
            _elem698.read(iprot)
28547 
            self.success.append(_elem698)
6159 rajveer 28548 
          iprot.readListEnd()
28549 
        else:
28550 
          iprot.skip(ftype)
28551 
      else:
28552 
        iprot.skip(ftype)
28553 
      iprot.readFieldEnd()
28554 
    iprot.readStructEnd()
28555 
 
28556 
  def write(self, oprot):
28557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28559 
      return
28560 
    oprot.writeStructBegin('getPlansForOperator_result')
28561 
    if self.success is not None:
28562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28563 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28564 
      for iter699 in self.success:
28565 
        iter699.write(oprot)
6159 rajveer 28566 
      oprot.writeListEnd()
28567 
      oprot.writeFieldEnd()
28568 
    oprot.writeFieldStop()
28569 
    oprot.writeStructEnd()
28570 
 
28571 
  def validate(self):
28572 
    return
28573 
 
28574 
 
28575 
  def __repr__(self):
28576 
    L = ['%s=%r' % (key, value)
28577 
      for key, value in self.__dict__.iteritems()]
28578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28579 
 
28580 
  def __eq__(self, other):
28581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28582 
 
28583 
  def __ne__(self, other):
28584 
    return not (self == other)
6289 anupam.sin 28585 
 
28586 
class getRechargeDenominations_args:
28587 
  """
28588 
  Attributes:
28589 
   - operatorId
6307 anupam.sin 28590 
   - circleCode
6289 anupam.sin 28591 
   - denominationType
28592 
  """
28593 
 
28594 
  thrift_spec = (
28595 
    None, # 0
28596 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28597 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28598 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28599 
  )
28600 
 
6307 anupam.sin 28601 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28602 
    self.operatorId = operatorId
6307 anupam.sin 28603 
    self.circleCode = circleCode
6289 anupam.sin 28604 
    self.denominationType = denominationType
28605 
 
28606 
  def read(self, iprot):
28607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28609 
      return
28610 
    iprot.readStructBegin()
28611 
    while True:
28612 
      (fname, ftype, fid) = iprot.readFieldBegin()
28613 
      if ftype == TType.STOP:
28614 
        break
28615 
      if fid == 1:
28616 
        if ftype == TType.I64:
28617 
          self.operatorId = iprot.readI64();
28618 
        else:
28619 
          iprot.skip(ftype)
28620 
      elif fid == 2:
28621 
        if ftype == TType.STRING:
6307 anupam.sin 28622 
          self.circleCode = iprot.readString();
6289 anupam.sin 28623 
        else:
28624 
          iprot.skip(ftype)
28625 
      elif fid == 3:
28626 
        if ftype == TType.I32:
28627 
          self.denominationType = iprot.readI32();
28628 
        else:
28629 
          iprot.skip(ftype)
28630 
      else:
28631 
        iprot.skip(ftype)
28632 
      iprot.readFieldEnd()
28633 
    iprot.readStructEnd()
28634 
 
28635 
  def write(self, oprot):
28636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28638 
      return
28639 
    oprot.writeStructBegin('getRechargeDenominations_args')
28640 
    if self.operatorId is not None:
28641 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28642 
      oprot.writeI64(self.operatorId)
28643 
      oprot.writeFieldEnd()
6307 anupam.sin 28644 
    if self.circleCode is not None:
28645 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28646 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28647 
      oprot.writeFieldEnd()
28648 
    if self.denominationType is not None:
28649 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28650 
      oprot.writeI32(self.denominationType)
28651 
      oprot.writeFieldEnd()
28652 
    oprot.writeFieldStop()
28653 
    oprot.writeStructEnd()
28654 
 
28655 
  def validate(self):
28656 
    return
28657 
 
28658 
 
28659 
  def __repr__(self):
28660 
    L = ['%s=%r' % (key, value)
28661 
      for key, value in self.__dict__.iteritems()]
28662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28663 
 
28664 
  def __eq__(self, other):
28665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28666 
 
28667 
  def __ne__(self, other):
28668 
    return not (self == other)
28669 
 
28670 
class getRechargeDenominations_result:
28671 
  """
28672 
  Attributes:
28673 
   - success
28674 
   - ex
28675 
  """
28676 
 
28677 
  thrift_spec = (
28678 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28679 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28680 
  )
28681 
 
28682 
  def __init__(self, success=None, ex=None,):
28683 
    self.success = success
28684 
    self.ex = ex
28685 
 
28686 
  def read(self, iprot):
28687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28689 
      return
28690 
    iprot.readStructBegin()
28691 
    while True:
28692 
      (fname, ftype, fid) = iprot.readFieldBegin()
28693 
      if ftype == TType.STOP:
28694 
        break
28695 
      if fid == 0:
28696 
        if ftype == TType.LIST:
28697 
          self.success = []
28698 
          (_etype703, _size700) = iprot.readListBegin()
28699 
          for _i704 in xrange(_size700):
28700 
            _elem705 = RechargeDenomination()
28701 
            _elem705.read(iprot)
28702 
            self.success.append(_elem705)
28703 
          iprot.readListEnd()
28704 
        else:
28705 
          iprot.skip(ftype)
28706 
      elif fid == 1:
28707 
        if ftype == TType.STRUCT:
28708 
          self.ex = TransactionServiceException()
28709 
          self.ex.read(iprot)
28710 
        else:
28711 
          iprot.skip(ftype)
28712 
      else:
28713 
        iprot.skip(ftype)
28714 
      iprot.readFieldEnd()
28715 
    iprot.readStructEnd()
28716 
 
28717 
  def write(self, oprot):
28718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28720 
      return
28721 
    oprot.writeStructBegin('getRechargeDenominations_result')
28722 
    if self.success is not None:
28723 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28724 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28725 
      for iter706 in self.success:
28726 
        iter706.write(oprot)
28727 
      oprot.writeListEnd()
28728 
      oprot.writeFieldEnd()
28729 
    if self.ex is not None:
28730 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28731 
      self.ex.write(oprot)
28732 
      oprot.writeFieldEnd()
28733 
    oprot.writeFieldStop()
28734 
    oprot.writeStructEnd()
28735 
 
28736 
  def validate(self):
28737 
    return
28738 
 
28739 
 
28740 
  def __repr__(self):
28741 
    L = ['%s=%r' % (key, value)
28742 
      for key, value in self.__dict__.iteritems()]
28743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28744 
 
28745 
  def __eq__(self, other):
28746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28747 
 
28748 
  def __ne__(self, other):
28749 
    return not (self == other)